Ler em inglês

Compartilhar via

Introdução: ingerir e inserir dados adicionais

  • Artigo

Este artigo de introdução orienta você pelo uso de um notebook do Azure Databricks para ingerir um arquivo CSV contendo dados adicionais de nome de bebê em seu volume do Catálogo do Unity e importar os novos dados de nome de bebê para uma tabela existente usando Python, Scala e R.

Importante

Este artigo de introdução baseia-se em Introdução: importar e visualizar dados CSV de um notebook – Azure Databricks. Você deve concluir as etapas nesse artigo para concluir este artigo. Para obter um notebook completo para este artigo de introdução, consulte Importar e visualizar notebooks de dados.

Requisitos

Para concluir as tarefas neste artigo, você deve atender aos seguintes requisitos:

  • Seu espaço de trabalho deve ter o Catálogo do Unity habilitado. Para obter informações sobre como começar a usar o Catálogo do Unity, consulte Configurar e gerenciar o Catálogo do Unity.
  • O usuário também deve ter o privilégio WRITE VOLUME em um volume, o privilégio USE SCHEMA no esquema pai e o privilégio USE CATALOG no catálogo pai.
  • Você deve ter permissão para usar um recurso de computação existente ou criar um recurso de computação. Veja Introdução ao Azure Databricks ou consulte o administrador do Databricks.

Dica

Para obter um notebook concluído para este artigo, consulte Ingerirr notebooks de dados adicionais.

Etapa 1: Criar um notebook

Para criar um bloco de notas na sua área de trabalho, clique em ícone NovoNovo na barra lateral e, em seguida, clique em Notebook. Um notebook em branco é aberto no workspace.

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

Etapa 2: definir variáveis

Nesta etapa, você definirá variáveis para uso no notebook de exemplo criado neste artigo.

  1. Copie e cole o código a seguir na nova célula vazia do notebook. Substitua <catalog-name>, <schema-name> e <volume-name> pelos nomes do catálogo, esquema e volume de um volume do Catálogo do Unity. Opcionalmente, substitua o valor table_name por um nome de tabela à sua escolha. Você salvará os dados do nome do bebê nesta tabela mais adiante neste artigo.

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

    Python

    Python 
    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

    Scala

    Scala 
    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

    R

    R 
    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 novo arquivo CSV de dados ao volume do Catálogo do Unity

Esta etapa cria um DataFrame chamado df com um novo nome de bebê para 2022 e salva esses dados em um novo arquivo CSV no volume do Catálogo do Unity.

Observação

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

  1. Copie e cole o código a seguir na nova célula vazia do notebook. Esse código cria o DataFrame com dados de nome de bebê adicionais e grava esses dados em um arquivo CSV no volume do Catálogo do Unity.

    Python

    Python 
    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}"))

    Scala

    Scala 
    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}")

    R

    R 
    # 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")

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

Etapa 4: carregar dados em um DataFrame de um arquivo CSV

Observação

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

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

    Python

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

    Scala

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

    R

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

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

Etapa 5: inserir na tabela existente

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

    Python

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

    Scala

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

    R

    R 
    # 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")))

  2. Pressione Ctrl+Enter para executar a célula.

Ingerir notebooks de dados adicionais

Use um dos notebooks a seguir para seguir as etapas desse artigo. Substitua <catalog-name>, <schema-name> e <volume-name> pelos nomes do catálogo, esquema e volume de um volume do Catálogo do Unity. Opcionalmente, substitua o valor table_name por um nome de tabela à sua escolha.

Python

Ingerir e inserir dados adicionais usando Python

Obter notebook

Scala

Ingerir e inserir dados adicionais usando Scala

Obter notebook

R

Ingerir e inserir dados adicionais usando R

Obter notebook

Próximas etapas

Para aprender sobre limpeza e aprimoramento de dados, veja Introdução: Aprimorar e limpar dados.

Recursos adicionais