Tutorial: Trabalhar com o SparkR SparkDataFrames no Databricks

Este tutorial mostra aos senhores como carregar e transformar dados usando o SparkDataFrame API para SparkR em Databricks.

Ao final deste tutorial, o senhor entenderá o que é um DataFrame e estará familiarizado com a seguinte tarefa:

Consulte também a referência da API do Apache SparkR.

O que é um DataFrame?

Um DataFrame é uma estrutura de dados bidimensional com rótulos e colunas de tipos variados.Você pode pensar em um DataFrame como uma planilha, uma tabela SQL ou um dicionário de objetos em série. Os DataFrames do Apache Spark oferecem um conjunto abrangente de funções (selecionar colunas, filtrar, unir, agregar) que permitem a você resolver eficientemente problemas comuns de análise de dados.

Os DataFrames do Apache Spark são uma abstração criada sobre os Resilient Distributed Datasets (RDDs).Os DataFrames do Spark e o Spark SQL utilizam um mecanismo de planejamento e otimização unificado, permitindo que você obtenha desempenho quase idêntico em todas as linguagens compatíveis com o o Databricks (Python, SQL, Scala e R).

Requisitos

Para concluir o tutorial a seguir, o senhor deve atender aos seguintes requisitos:

Observação

Se o senhor não tiver privilégios de controle cluster, ainda poderá concluir a maioria dos passos a seguir, desde que tenha acesso a um cluster.

Na barra lateral da página inicial, o senhor acessa as entidades Databricks: o navegador workspace, o Catalog Explorer, o fluxo de trabalho e o compute. workspace é a pasta raiz que armazena seu Databricks ativo, como Notebook e biblioteca.

o passo 1: Crie um DataFrame com o SparkR

Para saber como navegar pelo Databricks Notebook, consulte Databricks Notebook interface e controles.

  1. Abra um novo Notebook clicando no ícone Novo ícone.

  2. Copie e cole o código a seguir na célula vazia Notebook e, em seguida, pressione Shift+Enter para executar a célula. O exemplo de código a seguir cria um DataFrame chamado df1 com dados sobre a população da cidade e exibe seu conteúdo.

    # Load the SparkR package that is already preinstalled on the cluster.
    
    library(SparkR)
    
    # Define the data
    data <- data.frame(
      rank = c(295),
      city = c("South Bend"),
      state = c("Indiana"),
      code = c("IN"),
      population = c(101190),
      price = c(112.9)
    )
    
    # Define the schema
    schema <- structType(
      structField("rank", "double"),
      structField("city", "string"),
      structField("state", "string"),
      structField("code", "string"),
      structField("population", "double"),
      structField("price", "double")
    )
    
    # Create the dataframe
    df1 <- createDataFrame(
        data   = data,
        schema = schema
    )
    

o passo 2: Carregar dados em um DataFrame a partir de arquivos

Adicionar mais dados sobre a população da cidade do diretório /databricks-datasets para df2.

Para carregar dados em DataFrame df2 a partir do arquivo data_geo.csv, copie e cole o seguinte código na nova célula vazia Notebook. Pressione Shift+Enter para executar a célula.

Você pode enviar dados de vários formatos de arquivo compatíveis. O exemplo a seguir usa um dataset disponível no diretório /databricks-datasets, acessível na maioria dos workspaces. Consulte Sample datasets (amostra de datasets).

# Create second dataframe from a file
df2 <- read.df("/databricks-datasets/samples/population-vs-price/data_geo.csv",
              source = "csv",
              header = "true",
              schema = schema
)

o passo 3: view e interaja com o senhor DataFrame

view e interagir com a população de sua cidade DataFrames usando os seguintes métodos.

Combinar DataFrames

Combine o conteúdo do primeiro DataFrame df1 com o Dataframe df2 que contém o conteúdo de data_geo.csv.

No site Notebook, use o seguinte código de exemplo para criar um novo DataFrame que adiciona as linhas de um DataFrame a outro usando a união de operações:

# Returns a DataFrame that combines the rows of df1 and df2
df <- union(df1, df2)

Visualizar o DataFrame

Para view os dados da cidade dos EUA em um formato tabular, use o comando Databricks display() em uma célula Notebook.

display(df)

Filtrar linhas em um DataFrame

Descubra as cinco cidades mais populosas em seu conjunto de dados filtrando as linhas, usando .filter() ou .where(). Use a filtragem para selecionar um subconjunto de linhas para retornar ou modificar em um DataFrame. Não há diferença no desempenho ou na sintaxe, como pode ser visto no exemplo a seguir.

Para selecionar as cidades mais populosas, continue a adicionar novas células ao site Notebook e adicione o seguinte exemplo de código:

# Filter rows using filter()
filtered_df <- filter(df, df$rank < 6)
display(filtered_df)
# Filter rows using .where()
filtered_df <- where(df, df$rank < 6)
display(filtered_df)

Selecionar colunas a partir de um DataFrame

Saiba em qual estado uma cidade está localizada usando o método select(). Selecione colunas passando um ou mais nomes de colunas para .select(), como no exemplo a seguir:

# Select columns from a DataFrame
select_df <- select(df,"City", "State")
display(select_df)

Criar um DataFrame de subconjunto

Crie um DataFrame de subconjunto com as dez cidades com a maior população e exiba os dados resultantes. Combine consultas de seleção e filtro para limitar as linhas e colunas retornadas, usando o seguinte código em seu site Notebook:

# Create a subset Dataframe
subset_df <- filter(select(df, col = list("city", "rank")),condition = df$rank > 1)
display(subset_df)

o passo 4: Salvar o DataFrame

O senhor pode salvar seu DataFrame em uma tabela ou gravar o DataFrame em um arquivo ou em vários arquivos.

Salvar o DataFrame em uma tabela

Databricks usa o formato Delta Lake para todas as tabelas por default. Para salvar o DataFrame, o senhor deve ter privilégios de tabela CREATE no catálogo e no esquema. O exemplo a seguir salva o conteúdo do DataFrame em uma tabela chamada us_cities:

# Save DataFrame to a table
saveAsTable(df, "us_cities", source = "parquet", mode = "overwrite")

A maioria dos aplicativos Spark trabalha com grandes conjuntos de dados e de forma distribuída. O Spark grava um diretório de arquivos em vez de um único arquivo. O Delta Lake divide as pastas e os arquivos do Parquet. Muitos sistemas de dados podem ler esses diretórios de arquivos. A Databricks recomenda o uso de tabelas em vez de caminhos de arquivos para a maioria dos aplicativos.

Salvar o DataFrame em arquivos JSON

O exemplo a seguir salva um diretório de arquivos JSON:

# Write a DataFrame to a directory of files
write.df(df, path = "/tmp/json_data", source = "json", mode = "overwrite")

Ler o DataFrame de um arquivo JSON

# Read a DataFrame from a JSON file
df3 <- read.json("/tmp/json_data")
display(df3)

Tarefa adicional: execução SQL queries in SparkR

Os Spark DataFrames fornecem as seguintes opções para combinar SQL com SparkR. O senhor pode executar o seguinte código no mesmo Notebook que criou para este tutorial.

Especificar uma coluna como uma consulta SQL

O método selectExpr() permite a você especificar cada coluna como uma consulta SQL, como no seguinte exemplo:

display(df_selected <- selectExpr(df, "`rank`", "upper(city) as big_name"))

Use selectExpr()

selectExpr permite que o senhor use a sintaxe SQL em qualquer lugar onde uma coluna seria especificada, como no exemplo a seguir:

display(df_selected <- selectExpr(df, "`rank`", "lower(city) as little_name"))

execução de uma consulta arbitrária no site SQL

O senhor pode usar spark.sql() para executar consultas SQL arbitrárias, como no exemplo a seguir:

display(query_df <- sql("SELECT * FROM us_cities"))

Parametrizar consultas SQL

O senhor pode usar a formatação do SparkR para parametrizar as consultas SQL, como no exemplo a seguir:

# Define the table name
table_name <- "us_cities"

# Construct the SQL query using paste()
query <- paste("SELECT * FROM", table_name)

# Query the DataFrame using the constructed SQL query
display(query_df <- sql(query))