Primeiros passos: ingestão e inserção de dados adicionais

Este get começar artigos orienta o senhor a usar um Databricks Notebook para ingerir um arquivo CSV contendo dados adicionais de nomes de bebês no volume Unity Catalog e, em seguida, importar os novos dados de nomes de bebês para uma tabela existente usando Python, Scala e R.

Importante

Este artigo do Get Começar baseia-se no Get Começar: Importar e visualizar dados de CSV de um site Notebook. O senhor deve completar os passos desse artigo para concluir este artigo. Para acessar o site Notebook completo sobre como começar artigos, consulte Import and visualize data Notebook.

Requisitos

Para concluir a tarefa neste artigo, o senhor deve atender aos seguintes requisitos:

O site workspace deve ter Unity Catalog habilitado. Para obter informações sobre como começar com Unity Catalog, consulte Configurar e gerenciar Unity Catalog.
O senhor deve ter permissão para usar um recurso compute existente ou criar um novo recurso compute. Consulte Get começar: account e workspace setup ou consulte o administrador do site Databricks.

Dica

Para obter um Notebook completo para este artigo, consulte Ingest additional data Notebook.

Passo 1: criar um novo notebook

Para criar um notebook no seu workspace, clique em Novo na barra lateral e clique em Notebook. Um notebook em branco será aberto no workspace.

Para saber mais sobre como criar e gerenciar notebooks, consulte Gerenciar notebooks.

Passo 2: definir variáveis

Neste passo, o senhor define variáveis para uso no exemplo Notebook que criou neste artigo.

Copie e cole o código a seguir na nova célula vazia do site Notebook. Substitua <catalog-name>, <schema-name> e <volume-name> pelos nomes de catálogo, esquema e volume de um volume do Unity Catalog. Substitua <table_name> por um nome de tabela de sua escolha. O senhor salvará os dados do nome do bebê nessa tabela mais adiante neste artigo.

Pressione Shift+Enter para executar a célula e criar uma nova célula em branco.

catalog = "<catalog_name>"
schema = "<schema_name>"
volume = "<volume_name>"
file_name = "new_baby_names.csv"
table_name = "baby_names"
path_volume = "/Volumes/" + catalog + "/" + schema + "/" + volume
path_table = catalog + "." + schema
print(path_table) # Show the complete path
print(path_volume) # Show the complete path

val catalog = "<catalog_name>"
val schema = "<schema_name>"
val volume = "<volume_name>"
val fileName = "new_baby_names.csv"
val tableName = "baby_names"
val pathVolume = s"/Volumes/${catalog}/${schema}/${volume}"
val pathTable = s"${catalog}.${schema}"
print(pathVolume) // Show the complete path
print(pathTable) // Show the complete path

catalog <- "<catalog_name>"
schema <- "<schema_name>"
volume <- "<volume_name>"
file_name <- "new_baby_names.csv"
table_name <- "baby_names"
path_volume <- paste0("/Volumes/", catalog, "/", schema, "/", volume, sep = "")
path_table <- paste0(catalog, ".", schema, sep = "")
print(path_volume) # Show the complete path
print(path_table) # Show the complete path

Etapa 3: adicionar um novo arquivo CSV de dados ao seu volume do Unity Catalog

Este o passo cria um DataFrame chamado df com um novo nome de bebê para 2022 e, em seguida, salva esses dados em um novo arquivo CSV em seu volume do Unity Catalog.

Observação

Essa etapa simula a adição de novos dados anuais aos dados existentes carregados em relação aos anos anteriores. Em seu ambiente de produção, esses dados incrementais seriam armazenados na nuvem.

Copie e cole o código a seguir na nova célula vazia do notebook. Esse código cria o DataFrame com dados adicionais sobre o nome do bebê e, em seguida, grava esses dados em um arquivo CSV em seu volume do Unity Catalog.

data = [[2022, "CARL", "Albany", "M", 42]]

df = spark.createDataFrame(data, schema="Year int, First_Name STRING, County STRING, Sex STRING, Count int")
# display(df)
(df.coalesce(1)
    .write
    .option("header", "true")
    .mode("overwrite")
    .csv(f"{path_volume}/{file_name}"))

val data = Seq((2022, "CARL", "Albany", "M", 42))
val columns = Seq("Year", "First_Name", "County", "Sex", "Count")

val df = data.toDF(columns: _*)

// display(df)
df.coalesce(1)
    .write
    .option("header", "true")
    .mode("overwrite")
    .csv(f"{pathVolume}/{fileName}")

# Load the SparkR package that is already preinstalled on the cluster.
library(SparkR)

data <- data.frame(Year = 2022,
    First_Name = "CARL",
    County = "Albany",
    Sex = "M",
    Count = 42)

df <- createDataFrame(data)
# display(df)
write.df(df, path = paste0(path_volume, "/", file_name),
    source = "csv",
    mode = "overwrite",
    header = "true")

Pressione Shift+Enter para executar a célula e depois passar para a próxima célula.

Etapa 4: carregar dados no DataFrame a partir do arquivo CSV

Observação

Esta etapa simula o carregamento de dados do armazenamento em nuvem.

Copie e cole o código a seguir em uma célula vazia do notebook. Esse código carrega os dados dos novos nomes de bebês em um novo DataFrame do arquivo CSV.

df1 = spark.read.csv(f"{path_volume}/{file_name}",
    header=True,
    inferSchema=True,
    sep=",")
display(df1)

val df1 = spark.read
    .option("header", "true")
    .option("inferSchema", "true")
    .option("delimiter", ",")
    .csv(s"$pathVolume/$fileName")
display(df1)

df1 <- read.df(paste0(path_volume, "/", file_name),
    source = "csv",
    header = TRUE,
    inferSchema = TRUE)
display(df1)

Pressione Shift+Enter para executar a célula e depois passar para a próxima célula.

Etapa 5: inserir em tabela existente

Copie e cole o código a seguir em uma célula vazia do notebook. Esse código acrescenta os dados dos novos nomes de bebês do DataFrame à tabela existente.

df.write.mode("append").insertInto(f"{path_table}.{table_name}")
display(spark.sql(f"SELECT * FROM {path_table}.{table_name} WHERE Year = 2022"))

df1.write.mode("append").insertInto(s"${pathTable}.${tableName}")
display(spark.sql(s"SELECT * FROM ${pathTable}.${tableName} WHERE Year = 2022"))

# The write.df function in R, as provided by the SparkR package, does not directly support writing to Unity Catalog.
# In this example, you write the DataFrame into a temporary view and then use the SQL command to insert data from the temporary view to the Unity Catalog table
createOrReplaceTempView(df1, "temp_view")
sql(paste0("INSERT INTO ", path_table, ".", table_name, " SELECT * FROM temp_view"))
display(sql(paste0("SELECT * FROM ", path_table, ".", table_name, " WHERE Year = 2022")))

Pressione Ctrl+Enter para executar a célula.

Ingestão de notebooks de dados adicionais

Use um dos notebook a seguir para executar as etapas deste artigo.

Próximas etapas

Para saber mais sobre como limpar e aprimorar dados, consulte Começar a usar: aprimorar e limpar dados.