Explicação do Apache Parquet: Um guia para profissionais de dados

Recursos do Apache Parquet

Vamos entender a arquitetura do Apache Parquet com seus principais recursos: 

Armazenamento colunar

Ao contrário dos formatos baseados em linhas, como o CSV, o Parquet organiza os dados em colunas. Isso significa que, quando executamos uma consulta, ela extrai apenas as colunas específicas de que precisamos, em vez de carregar tudo. Isso melhora o desempenho e reduz o uso de E/S.

Estrutura baseada em linhas ou colunas. Imagem do autor.

Os arquivos Parquet são divididos em grupos de linhas, que contêm um lote de linhas. Cada grupo de linhas é dividido em partes de colunas, cada uma contendo dados para uma coluna. Esses blocos são divididos em partes menores, chamadas páginas, que são compactadas para economizar espaço.

Além disso, os arquivos Parquet armazenam informações extras no rodapé, chamadas metadados, que localizam e leem somente os dados de que precisamos. 

Aqui está a aparência da estrutura:

Estrutura interna do arquivo Parquet. Imagem do autor. 

Vamos detalhar cada componente do diagrama acima.

Grupos de linhas

• Um grupo de linhas contém várias linhas, mas armazena os dados em colunas para uma leitura eficiente.
• Exemplo: Um conjunto de dados com 1 milhão de linhas pode ser dividido em 10 grupos de 100.000 linhas cada.

Partes de coluna

• Em cada grupo de linhas, os dados são separados por colunas.
• Esse design permite a poda colunar, em que podemos ler apenas as colunas relevantes em vez de examinar o arquivo inteiro.

Páginas

• Cada bloco de coluna é dividido em páginas para otimizar o uso da memória.
• Normalmente, as páginas são compactadas, reduzindo os custos de armazenamento.

Rodapé (metadados)

• O rodapé no final de um arquivo Parquet armazena informações de índice:
• Schema: Define tipos de dados e nomes de colunas.
• Offsets de grupos de linhas: Ajuda a localizar dados específicos rapidamente.
• Estatísticas: Valores mínimo/máximo para ativar o pushdown do predicado (filtragem no nível de armazenamento).

Compressão e codificação

Conforme mencionado, o Parquet comprime os dados coluna por coluna usando métodos de compactação como Snappy e Gzip. Ele também usa duas técnicas de codificação:

• Codificação de comprimento de execução para armazenar valores repetidos de forma compacta.
• Codificação de dicionário para substituir duplicatas por referências de dicionário.

Isso reduz o tamanho dos arquivos e acelera a leitura de dados, o que é especialmente útil quando você trabalha com big data.

Evolução do esquema

A evolução do esquema significa modificar a estrutura dos conjuntos de dados, como adicionar ou alterar colunas. Pode parecer simples, mas dependendo de como os dados são armazenados, a modificação do esquema pode ser lenta e exigir muitos recursos. 

Vamos entender isso comparando a evolução dos esquemas CSV e Parquet.

Suponha que você tenha um arquivoCSV com colunas como student_id, student_name e student_age. Se você quiser adicionar uma nova coluna scores, terá de fazer o seguinte:

1. Ler o arquivo inteiro na memória.
2. Atualize o cabeçalho para incluir uma nova coluna, scores.
3. Adicione uma pontuação para cada aluno. Isso significa anexar valores para todas as linhas (mesmo que estejam faltando, você pode precisar de espaços reservados, como cadeias de caracteres vazias ou NULL).
4. Salve tudo como um novo arquivo CSV.

O CSV é um formato simples baseado em texto, sem suporte a esquemas incorporados. Isso significa que qualquer alteração na estrutura requer a reescrita de todo o arquivo, e os sistemas mais antigos que lerem o arquivo modificado poderão falhar se esperarem uma estrutura diferente!

Com o Parquet, você pode adicionar, remover ou atualizar campos sem quebrar os arquivos existentes. Como vimos anteriormente, o Parquet armazena as informações do esquema no rodapé do arquivo (metadados), permitindo a evolução dos esquemas sem modificar os arquivos existentes.

Veja como isso funciona:

• Quando você adiciona uma nova coluna, os arquivos Parquet existentes permanecem inalterados.
• Os novos arquivos incluirão a coluna adicional, enquanto os arquivos antigos ainda seguirão o esquema anterior.
• A remoção de uma coluna não requer o reprocessamento de dados anteriores; as consultas ignorarão a coluna ausente.
• Se uma coluna não existir em um arquivo antigo, os mecanismos Parquet (como Apache Spark, Hive ou BigQuery) retornarão NULL em vez de interromper a consulta.
• Os arquivos Parquet mais antigos podem ser lidos mesmo após modificações no esquema.
• Os arquivos Parquet mais novos com colunas adicionais ainda podem ser lidos por sistemas que esperam um esquema mais antigo.

Adicionar uma coluna ao arquivo Parquet sem quebrá-lo. Imagem do autor.

Suporte a idiomas e plataformas

O Parquet oferece suporte a diferentes linguagens de programação, como Java, Python, C++ e Rust. Isso significa que os desenvolvedores podem usá-lo facilmente, independentemente de sua plataforma. Ele também é integrado nativamente a estruturas de big data como Apache Spark, Hive, Presto, Flink e Trino, garantindo um processamento de dados eficiente em escala.

Portanto, quer você esteja usando Python (por meio do PySpark) ou outra linguagem, o Parquet pode gerenciar os dados de forma a facilitar a consulta e a análise em diferentes plataformas.

Se você não tem experiência com estruturas de Big Data, recomendo que faça o curso Introduction to PySpark. É uma ótima maneira de você começar. 

Como ler e gravar arquivos Parquet

Agora que você conhece os conceitos básicos do Apache Parquet, vou orientá-lo na gravação, leitura e integração dearquivos Parquet com o pandas, PyArrowe outras estruturas de Big Data, como o Spark.

Escreva arquivos Parquet usando pandas

Para salvar DataFrames como arquivos Parquet, você precisa do pandas e de um mecanismo Parquet como o PyArrow:

pip install pandas pyarrow

Agora, escreva um arquivo Parquet usando o código a seguir:

import pandas as pd

# Sample DataFrame
data = {
    "Name": ["Alice", "Bob", "Charlie"],
    "Age": [25, 30, 35],
    "City": ["New York", "Los Angeles", "Chicago"]
}
df = pd.DataFrame(data)

# Write to Parquet file
df.to_parquet("data.parquet", engine="pyarrow", index=False)

print("Parquet file written successfully!")

Escreva o arquivo Parquet com o pandas. Imagem do autor.

Ler arquivos Parquet usando pandas

Aqui está um código simples para você ler seu arquivo Parquet:

import pandas as pd

# Read the Parquet file
df = pd.read_parquet("data.parquet", engine="pyarrow")

print("Data from Parquet file:")
print(df)

Leia o arquivo Parquet com o pandas. Imagem do autor.

Escrever arquivos Parquet usando PyArrow

O PyArrow é uma ferramenta do projeto Apache Arrow que facilita o trabalho com arquivos Parquet. Veja como você pode gravar um arquivo parquet usando o PyArrow:

import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq

# Sample data
df = pd.DataFrame({
    "Name": ["Jacob", "Lauren", "Oliver"],
    "Age": [25, 30, 35],
    "City": ["New York", "Los Angeles", "Chicago"]
})

# Convert to a PyArrow table
table = pa.Table.from_pandas(df)

# Write to Parquet file
pq.write_table(table, "data.parquet")

print("Parquet file written successfully!")

Escreva um arquivo Parquet com o PyArrow. Imagem do autor.

Ler arquivos Parquet usando PyArrow

Veja como você pode ler um arquivo Parquet usando o PyArrow:

import pyarrow.parquet as pq

# Read the Parquet file
table = pq.read_table("data.parquet")

# Convert to a pandas DataFrame
df = table.to_pandas()

print("Data from Parquet file:")
print(df)

Leia o arquivo Parquet com o PyArrow. Imagem do autor.

Integrar com estruturas de big data

Podemos usar o Spark para ler e gravar arquivos Parquet diretamente. Faça o download dono site do Apache Spark ou configure-o seguindo as instruções .

Quando terminar, importe as bibliotecas e crie um DataFrame: 

from pyspark.sql import SparkSession

# Initialize a Spark session
spark = SparkSession.builder.appName("SparkExample").getOrCreate()

# Define the schema for the dataset
schema = ["Name", "Age", "City"]

# Create a sample data
data = [
    ("Jacob", 30, "New York"),
    ("Lauren", 35, "Los Angeles"),
    ("Billy", 25, "Chicago")
]

# Create a DataFrame from the sample data
df = spark.createDataFrame(data, schema)

# Show the DataFrame
df.show()

Crie um DataFrame de amostra no Spark. Imagem do autor.

Em seguida, escreva esse DataFrame como um arquivo Parquet:

# Write DataFrame to Parquet
df.write.parquet("data.parquet")

O write.parquet() salva o DataFrame no formato Parquet, e o arquivo será chamado de employee.parquet. Agora, para ler esse arquivo Parquet, você pode usar o seguinte código:

# Read the Parquet file
parquet_df = spark.read.parquet("data.parquet")

# Show the DataFrame
parquet_df.show()

Ler o arquivo Parquet. Imagem do autor. 

Além do Spark, o Parquet também pode trabalhar com o Hive. Quando você criar uma tabela do Hive, use STORED AS PARQUET para tornar o Parquet o formato de armazenamento.

Operações úteis com o Parquet

Além da leitura e da gravação, há algumas operações básicas que todo desenvolvedor deve conhecer, pois elas são úteis ao trabalhar com arquivos Parquet. Vamos analisá-las nesta seção.

Usarei o pandas e o PyArrow para ilustrar os conceitos.

Acrescentar dados a um arquivo Parquet existente

Anexar dados é útil quando novos registros precisam ser adicionados sem reescrever todo o conjunto de dados.

import pyarrow.parquet as pq
import pyarrow as pa

# Load existing Parquet file
existing_table = pq.read_table("data.parquet")

# New data
new_data = pd.DataFrame({
    "Name": ["David", "Emma"],
    "Age": [40, 28],
    "City": ["San Francisco", "Seattle"]
})

# Convert new data to PyArrow table
new_table = pa.Table.from_pandas(new_data)

# Concatenate both tables
merged_table = pa.concat_tables([existing_table, new_table])

# Write back to Parquet file
pq.write_table(merged_table, "data.parquet")

Ler somente colunas específicas de um arquivo Parquet

Em vez de carregar todo o conjunto de dados, você pode selecionar apenas as colunas necessárias, reduzindo o uso da memória e melhorando o desempenho. Isso é significativamente mais rápido do que ler o conjunto de dados completo:

df = pd.read_parquet("data.parquet", columns=["Name", "Age"])
print(df)

Filtragem de dados durante a leitura (predicado pushdown)

O Parquet permite uma filtragem eficiente no nível de armazenamento, conhecida como predicado pushdown, que evita o carregamento de dados desnecessários. Isso evita a varredura de todo o arquivo, tornando as consultas muito mais rápidas:

import pyarrow.parquet as pq

# Read only rows where Age > 30
table = pq.read_table("data.parquet", filters=[("Age", ">", 30)])

df = table.to_pandas()
print(df)

Mesclar vários arquivos Parquet

Em geral, os arquivos Parquet são armazenados em partições separadas. Você pode mesclá-los em um único arquivo Parquet. Isso é útil ao combinar conjuntos de dados de diferentes fontes:

import pyarrow.parquet as pq
import pyarrow as pa

# List of Parquet files to merge
file_list = ["data_part1.parquet", "data_part2.parquet"]

# Read all files and merge
tables = [pq.read_table(f) for f in file_list]
merged_table = pa.concat_tables(tables)

# Write merged Parquet file
pq.write_table(merged_table, "merged_data.parquet")

Converter CSV em Parquet

Se você tiver arquivos CSV existentes, a conversão deles em Parquet economiza espaço e acelera o processamento, o que reduz drasticamente o tamanho do arquivo e melhora o desempenho da leitura:

df = pd.read_csv("data.csv")
df.to_parquet("data.parquet", engine="pyarrow", index=False)

Partição de arquivos Parquet para consultas mais rápidas

O particionamento organiza os dados em subdiretórios com base em um valor de coluna, tornando as consultas significativamente mais rápidas.

Veja como você pode gravar dados particionados:

df.to_parquet("partitioned_data/", engine="pyarrow", partition_cols=["City"])

O código acima cria subdiretórios:

partitioned_data/City=New York/
partitioned_data/City=Los Angeles/
partitioned_data/City=Chicago/

Então, você pode ler apenas uma partição específica:

df = pd.read_parquet("partitioned_data/City=New York/")
print(df)

Isso acelera a análise, pois você verifica apenas as partições relevantes!

Use a compactação para otimizar o armazenamento

O Parquet oferece suporte a algoritmos de compactação como Snappy, Gzip e Brotli para reduzir o tamanho do arquivo:

df.to_parquet("compressed.parquet", engine="pyarrow", compression="snappy")

Práticas recomendadas para o uso do Apache Parquet

Quando comecei a usar o Apache Parquet, percebi que pequenos ajustes poderiam melhorar muito sua eficiência. Aqui estão algumas das minhas principais dicas para otimizar o Parquet em cenários do mundo real.

Escolha o codec de compactação correto

Se você quiser economizar armazenamento, codecs como Snappy ou Gzip podem ser as opções que você precisa - o Snappy oferece compactação e descompactação rápidas, perfeitas para cenários em que a velocidade é mais importante.

Por outro lado, o Gzip é ideal se você tiver pouco espaço de armazenamento, mas puder suportar leituras um pouco mais lentas. A chave é entender sua carga de trabalho - um codec mais rápido como o Snappy geralmente vence se você acessa arquivos com frequência. No entanto, o Gzip é melhor para dados de arquivo.

Particionar dados de forma eficaz

Divida seus dados em subconjuntos lógicos, como por exemplo, por data, região ou qualquer outro campo consultado com frequência, para reduzir a quantidade de dados examinados durante uma consulta. Certa vez, trabalhei com um conjunto de dados que continha anos de registros de transações e o particionei por ano e mês para buscar períodos específicos em segundos em vez de minutos. 

Monitorar a evolução do esquema

Sempre me certifico de que as novas colunas sejam adicionadas de forma a não interromper os processos existentes. Isso geralmente significa anexá-los em vez de modificar os existentes. Para isso, você pode usar o suporte à evolução de esquemas do Apache Spark para obter transições mais suaves. 

Apache Parquet versus outros formatos de dados

Vamos comparar o Parquet com outros formatos de armazenamento de dados. 

Parquet vs CSV

Já falamos sobre isso na postagem do blog, mas quero enfatizá-lo novamente: Parquet e CSV são dois formatos diferentes que tratam os dados de forma diferente.

O Parquet organiza os dados em colunas, enquanto o CSV os organiza em linhas. Quando você usa o Parquet, todos os dados da mesma coluna são agrupados, de modo que você pode extrair facilmente dados de colunas específicas sem ter que vasculhar todo o resto. Ele é mais rápido e ocupa menos espaço porque o Parquet comprime os dados.

Formato baseado em colunas Parquet. Imagem do autor.

O CSV, por outro lado, armazena os dados linha por linha. É simples e funciona bem para conjuntos de dados pequenos, mas não é ideal para os grandes. Toda consulta precisa ler a linha inteira, mesmo que você só precise de algumas colunas. Isso torna as coisas mais lentas e requer mais memória para processar.

Formato baseado em linhas CSV. Imagem do autor.

Parquet vs JSON

O JSON é ótimo para estruturar dados de uma forma fácil de entender, mas tem uma desvantagem: não é muito eficiente em termos de armazenamento ou velocidade. Então, deixe-me explicar por que o Parquet é mais eficiente do que o JSON com um exemplo.

Suponhamos que você tenha uma tabela de dados de funcionários com três colunas: EmployeeID, Department, e Location:

Agora, se salvarmos esses dados como JSON, eles terão a seguinte aparência:

[
  {"EmployeeID": 1, "Department": "HR", "Location": "New York"},
  {"EmployeeID": 2, "Department": "HR", "Location": "New York"},
  {"EmployeeID": 3, "Department": "HR", "Location": "New York"},
  {"EmployeeID": 4, "Department": "IT", "Location": "San Francisco"},
  {"EmployeeID": 5, "Department": "IT", "Location": "San Francisco"}
]

Observe como o JSON repete nomes de colunas como EmployeeID, Department e Location para cada registro. Você também repete os valores de HR e New York várias vezes. Isso torna o arquivo muito maior e mais lento.

Agora vamos imaginar (porque o Parquet não é legível por humanos) que salvamos os mesmos dados que o Parquet:

• EmployeeID: [1, 2, 3, 4, 5]
• Departamento: [HR, HR, HR, IT, IT] (comprimido como HR: 3, IT: 2)
• Localização: [Nova York, Nova York, Nova York, São Francisco, São Francisco] (comprimido como Nova York: 3, San Francisco: 2).

Em vez de armazenar linha por linha, o Parquet organiza os dados por colunas e comprime os valores repetidos.

Parquet x Avro

O Avro é um formato baseado em linhas. É excelente para tarefas como streaming de dados ou processamento de logs, em que você adiciona constantemente novos registros ou recupera linhas completas. Mas o formato baseado em colunas do Parquet é perfeito para análises. Se você executar consultas para analisar grandes quantidades de dados, o Parquet funcionará melhor. Ele extrai dados das colunas necessárias e ignora o restante para economizar tempo e recursos.

Em resumo, o Parquet é melhor para ler e analisar grandes conjuntos de dados, enquanto o Avro é ideal para gravar e armazenar dados de forma fácil de atualizar.

Aqui está uma tabela de comparação entre o Parquet e o Parquet . CSV vs. JSON vs. Avro, incluindo prós, contras e casos de uso:

Quando usar o Apache Parquet

Em resumo, aqui estão algumas situações em que o Parquet é a melhor opção:

• Cargas de trabalho pesadas de análise: O formato colunar do Parquet nos permite buscar apenas os dados de que precisamos, o que acelera as consultas e economiza tempo. Eu vi isso na prática ao processar conjuntos de dados com o Apache Spark - consultas que antes levavam minutos foram executadas em segundos devido à estrutura eficiente do Parquet.
• Arquiteturas de data lake: Quando você cria um lago de dados, os custos de armazenamento aumentam rapidamente. Mas os recursos de compactação do Parquet reduzem o tamanho dos dados armazenados para ajudar você a economizar no armazenamento sem sacrificar o desempenho. 
• Casos de uso que envolvem grandes conjuntos de dados: O Parquet lida perfeitamente com conjuntos de dados grandes e complexos, especialmente aqueles com estruturas aninhadas ou hierárquicas. Seu suporte para tipos de dados avançados e evolução de esquemas garante que você possa adaptar seus dados à medida que os requisitos mudam.

Considerações finais

O Apache Parquet é perfeito para lidar com big data. Ele é rápido, economiza espaço de armazenamento e funciona com ferramentas como o Spark. Se você está animado para saber mais, confira os seguintes recursos :

• Curso Introduction to Databricks para você entender o Databricks, uma plataforma de dados unificada para otimizar os fluxos de trabalho de Big Data.
• Curso Cleaning Data with PySpark para limpeza e pré-processamento de conjuntos de dados usando o PySpark.
• Big Data com PySpark: trilha para dimensionar o processamento de dados com o Apache Spark usando a API do PySpark.