Começar: Ingerir e inserir 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 nesse 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.

o passo 1: Criar um novo Notebook

Para criar um Notebook em seu workspace:

Clique em New na barra lateral e, em seguida, clique em Notebook.
Na página "Criar Notebook":
- Especifique um nome exclusivo para o seu notebook.
- Defina o idioma default para seu Notebook e clique em Confirm, se solicitado.
- Clique em Connect (Conectar ) e selecione um recurso compute. Para criar um novo recurso de computação, consulte Usar computação.

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

o 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

o passo 3: Adicionar um novo arquivo de dados CSV ao volume Unity Catalog

Esse 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 no volume Unity Catalog.

Observação

Esse passo simula a adição de novos dados anuais aos dados existentes carregados para os anos anteriores. Em seu ambiente de produção, esses dados incrementais seriam armazenados em cloud storage.

Copie e cole o código a seguir na nova célula vazia do site 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 no 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 passe para a próxima célula.

o passo 4: Carregar dados no site DataFrame a partir do arquivo CSV

Observação

Esse passo simula o carregamento de dados do armazenamento cloud.

Copie e cole o código a seguir em uma célula vazia do site 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 passe para a próxima célula.

o passo 5: Inserir na tabela existente

Copie e cole o código a seguir em uma célula vazia do site Notebook. Esse código anexa os novos dados de 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.

Ingerir dados adicionais Notebook

Use um dos seguintes Notebooks para realizar os passos deste artigo.

Próximos passos

Para saber mais sobre a limpeza e o aprimoramento de dados, consulte Get começar: Aprimorar e limpar dados.