Apache Parquet spiegato: una guida per i professionisti dei dati

Funzionalità di Apache Parquet

Vediamo l'architettura di Apache Parquet attraverso le sue caratteristiche chiave: 

Archiviazione colonnare

A differenza dei formati basati su righe come CSV, Parquet organizza i dati in colonne. Questo significa che quando eseguiamo una query, recupera solo le colonne specifiche di cui abbiamo bisogno invece di caricare tutto. Migliora le prestazioni e riduce l'I/O.

Struttura basata su righe vs. colonne. Immagine dell'autore.

I file Parquet sono suddivisi in gruppi di righe (row group), che contengono un lotto di righe. Ogni row group è suddiviso in chunk di colonna, ognuno con i dati di una colonna. Questi chunk sono ulteriormente divisi in parti più piccole chiamate pagine, che sono compresse per risparmiare spazio.

Inoltre, i file Parquet memorizzano informazioni aggiuntive nel footer, chiamate metadati, che permettono di localizzare e leggere solo i dati necessari. 

Ecco come appare la struttura:

Struttura interna del file Parquet. Immagine dell'autore. 

Scomponiamo i componenti nel diagramma qui sopra.

Row group

• Un row group contiene più righe ma archivia i dati per colonna per una lettura efficiente.
• Esempio: un dataset con 1 milione di righe può essere suddiviso in 10 gruppi da 100.000 righe ciascuno.

Chunk di colonna

• All'interno di ogni row group, i dati sono separati per colonne.
• Questo design consente il column pruning, ossia la lettura solo delle colonne rilevanti invece di scansionare l'intero file.

Pagine

• Ogni chunk di colonna è ulteriormente diviso in pagine per ottimizzare l'uso della memoria.
• Le pagine sono tipicamente compresse, riducendo i costi di archiviazione.

Footer (metadati)

• Il footer alla fine di un file Parquet memorizza informazioni di indice:
• Schema: definisce i tipi di dato e i nomi delle colonne.
• Offset dei row group: aiutano a localizzare rapidamente dati specifici.
• Statistiche: valori min/max per abilitare il predicate pushdown (filtraggio a livello di storage).

Compressione e codifica

Come detto, Parquet comprime i dati colonna per colonna usando metodi come Snappy e Gzip. Usa anche due tecniche di codifica:

• Run-length encoding per archiviare in modo compatto i valori ripetuti.
• Dictionary encoding per sostituire i duplicati con riferimenti a un dizionario. 

Questo riduce le dimensioni dei file e accelera la lettura dei dati, soprattutto quando lavori con big data.

Evoluzione dello schema

L'evoluzione dello schema significa modificare la struttura dei dataset, ad esempio aggiungendo o cambiando colonne. Può sembrare semplice, ma a seconda di come sono archiviati i dati, modificare lo schema può essere lento e dispendioso in risorse. 

Capiremo meglio confrontando l'evoluzione dello schema in CSV e Parquet.

Supponiamo di avere un file CSV con colonne come student_id, student_name e student_age. Se vuoi aggiungere una nuova colonna scores, dovresti fare quanto segue:

1. Leggere l'intero file in memoria.
2. Aggiornare l'intestazione per includere la nuova colonna, scores.
3. Aggiungere un punteggio per ogni studente. Significa aggiungere valori a tutte le righe (anche se mancanti, potresti aver bisogno di segnaposto come stringhe vuote o NULL).
4. Salvare tutto in un nuovo file CSV.

CSV è un formato semplice basato su testo, senza supporto integrato per lo schema. Questo significa che qualsiasi modifica alla struttura richiede la riscrittura dell'intero file, e i sistemi più vecchi che leggono il file modificato potrebbero bloccarsi se si aspettano una struttura diversa!

Con Parquet puoi aggiungere, rimuovere o aggiornare campi senza rompere i file esistenti. Come visto, Parquet memorizza le informazioni di schema nel footer del file (metadati), consentendo di evolvere gli schemi senza modificare i file esistenti.

Ecco come funziona:

• Quando aggiungi una nuova colonna, i file Parquet esistenti rimangono invariati.
• I nuovi file includeranno la colonna aggiuntiva, mentre i file vecchi seguiranno ancora lo schema precedente.
• Rimuovere una colonna non richiede il riprocessamento dei dati passati; le query ignoreranno la colonna mancante.
• Se una colonna non esiste in un file più vecchio, i motori Parquet (come Apache Spark, Hive o BigQuery) restituiscono NULL invece di interrompere la query.
• I file Parquet più vecchi possono essere letti anche dopo modifiche allo schema.
• I file Parquet più recenti con colonne aggiuntive possono comunque essere letti da sistemi che si aspettano uno schema più vecchio.

Aggiunta di una colonna al file Parquet senza romperlo. Immagine dell'autore.

Supporto per lingue e piattaforme

Parquet supporta diversi linguaggi di programmazione, come Java, Python, C++ e Rust. Ciò significa che gli sviluppatori possono usarlo facilmente indipendentemente dalla piattaforma. È anche integrato nativamente con framework per big data come Apache Spark, Hive, Presto, Flink e Trino, garantendo un'elaborazione efficiente dei dati su larga scala.

Quindi, che tu stia usando Python (tramite PySpark) o un altro linguaggio, Parquet può gestire i dati in modo da rendere facili query e analisi su piattaforme diverse.

Se sei alle prime armi con i framework per big data, ti consiglio il corso Introduction to PySpark. È un ottimo modo per iniziare. 

Come leggere e scrivere file Parquet

Ora che conosci le basi di Apache Parquet, ti guiderò nella scrittura, lettura e integrazione dei file Parquet con pandas, PyArrow e altri framework big data come Spark.

Scrivere file Parquet con pandas

Per salvare DataFrame come file Parquet, ti servono pandas e un motore Parquet come PyArrow:

pip install pandas pyarrow

Ora, scrivi un file Parquet usando il seguente codice:

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!")

Scrivi il file Parquet con pandas. Immagine dell'autore.

Leggere file Parquet con pandas

Ecco un semplice codice per leggere il tuo file Parquet:

import pandas as pd

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

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

Leggi il file Parquet con pandas. Immagine dell'autore.

Scrivere file Parquet con PyArrow

PyArrow è uno strumento del progetto Apache Arrow che semplifica il lavoro con i file Parquet. Ecco come puoi scrivere un file Parquet usando 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!")

Scrivi un file Parquet con PyArrow. Immagine dell'autore.

Leggere file Parquet con PyArrow

Ecco come leggere un file Parquet usando 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)

Leggi il file Parquet con PyArrow. Immagine dell'autore.

Integrazione con framework big data

Possiamo usare Spark per leggere e scrivere direttamente file Parquet. Scaricalo dal sito di Apache Spark o configuralo seguendo le istruzioni. 

Una volta fatto, importa le librerie e crea un 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()

Crea un DataFrame di esempio in Spark. Immagine dell'autore.

Poi, scrivi questo DataFrame come file Parquet:

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

Il metodo write.parquet() salva il DataFrame in formato Parquet e il file si chiamerà employee.parquet. Ora, per leggere questo file Parquet, puoi usare il seguente codice:

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

# Show the DataFrame
parquet_df.show()

Leggi il file Parquet. Immagine dell'autore. 

Oltre a Spark, Parquet può funzionare anche con Hive. Quando crei una tabella Hive, usa STORED AS PARQUET per impostare Parquet come formato di archiviazione.

Operazioni utili con Parquet

Oltre a leggere e scrivere, ci sono alcune operazioni di base che ogni sviluppatore dovrebbe conoscere perché utili quando si lavora con file Parquet. Vediamole in questa sezione.

Userò pandas e PyArrow per illustrare i concetti.

Aggiungere dati a un file Parquet esistente

L'append dei dati è utile quando bisogna aggiungere nuovi record senza riscrivere l'intero dataset.

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

Leggere solo colonne specifiche da un file Parquet

Invece di caricare l'intero dataset, puoi selezionare solo le colonne necessarie, riducendo l'uso di memoria e migliorando le prestazioni. È significativamente più veloce che leggere l'intero dataset:

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

Filtrare i dati in lettura (predicate pushdown)

Parquet consente un filtraggio efficiente a livello di storage, noto come predicate pushdown, che evita di caricare dati non necessari. Questo impedisce di scansionare l'intero file, rendendo le query molto più veloci:

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)

Unire più file Parquet

Spesso, i file Parquet sono archiviati come partizioni separate. Puoi unirli in un unico file Parquet. È utile quando si combinano dataset da fonti diverse:

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

Convertire CSV in Parquet

Se hai file CSV esistenti, convertirli in Parquet fa risparmiare spazio e accelera l'elaborazione, riducendo drasticamente la dimensione del file e migliorando le prestazioni in lettura:

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

Partizionare i file Parquet per query più veloci

La partizione organizza i dati in sottodirectory in base al valore di una colonna, rendendo le query significativamente più veloci.

Ecco come puoi scrivere dati partizionati:

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

Il codice sopra crea sottodirectory:

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

Poi puoi leggere solo una partizione specifica:

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

Questo velocizza l'analisi scansionando solo le partizioni rilevanti!

Usare la compressione per ottimizzare lo storage

Parquet supporta algoritmi di compressione come Snappy, Gzip e Brotli per ridurre la dimensione dei file:

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

Best practice per usare Apache Parquet

Quando ho iniziato a usare Apache Parquet, ho capito che piccole regolazioni potevano migliorarne molto l'efficienza. Ecco alcuni dei miei consigli per ottimizzare Parquet in scenari reali.

Scegli il codec di compressione giusto

Se vuoi risparmiare spazio di archiviazione, codec come Snappy o Gzip sono ottime opzioni: Snappy offre compressione e decompressione rapide, perfette quando la velocità conta di più. 

Al contrario, Gzip è ideale se hai poco spazio ma puoi tollerare letture leggermente più lente. La chiave è capire il tuo carico di lavoro: un codec più veloce come Snappy spesso vince se accedi ai file di frequente. Tuttavia, Gzip è migliore per i dati d'archivio.

Partiziona i dati in modo efficace

Suddividi i dati in sottoinsiemi logici, ad esempio per data, area geografica o qualsiasi altro campo interrogato spesso, per ridurre la quantità di dati scansionati durante una query. Una volta ho lavorato con un dataset di anni di log transazionali e l'ho partizionato per anno e mese per recuperare periodi specifici in secondi anziché minuti. 

Monitora l'evoluzione dello schema

Mi assicuro sempre che le nuove colonne vengano aggiunte senza interrompere i processi esistenti. Di solito significa aggiungerle in coda anziché modificare quelle esistenti. Per farlo, puoi usare il supporto all'evoluzione dello schema di Apache Spark per transizioni più fluide. 

Apache Parquet vs altri formati di dati

Confrontiamo Parquet con altri formati di archiviazione dei dati. 

Parquet vs CSV

Ne abbiamo già parlato lungo il post, ma lasciami sottolinearlo di nuovo: Parquet e CSV sono due formati diversi che gestiscono i dati in modo differente.

Parquet organizza i dati in colonne, mentre CSV li dispone in righe. Con Parquet, tutti i dati della stessa colonna sono raggruppati, così puoi estrarre facilmente i dati da colonne specifiche senza dover passare attraverso tutto il resto. È più veloce e occupa meno spazio perché Parquet comprime i dati.

Formato colonnare di Parquet. Immagine dell'autore.

CSV, invece, archivia i dati riga per riga. È semplice e funziona bene per dataset piccoli, ma non è ideale per quelli grandi. Ogni query deve leggere l'intera riga, anche se ti servono solo un paio di colonne. Questo rallenta e richiede più memoria per l'elaborazione.

Formato basato su righe di CSV. Immagine dell'autore.

Parquet vs JSON

JSON è ottimo per strutturare i dati in modo facile da capire, ma ha un difetto: non è molto efficiente in termini di storage o velocità. Quindi, lascia che ti spieghi perché Parquet è più efficiente di JSON con un esempio.

Supponiamo di avere una tabella di dati dei dipendenti con tre colonne: EmployeeID, Department e Location:

Ora, se salviamo questi dati come JSON, appariranno così:

[
  {"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"}
]

Nota come JSON ripete i nomi delle colonne come EmployeeID, Department e Location per ogni singolo record. Ripete anche i valori HR e New York più volte. Questo rende il file molto più grande e più lento.

Ora immaginiamo (perché Parquet non è leggibile dall'uomo) di salvare gli stessi dati come Parquet:

• EmployeeID: [1, 2, 3, 4, 5]
• Department: [HR, HR, HR, IT, IT] (compresso come HR: 3, IT: 2)
• Location: [New York, New York, New York, San Francisco, San Francisco] (compresso come New York: 3, San Francisco: 2).

Invece di archiviare riga per riga, Parquet organizza i dati per colonne e comprime i valori ripetuti.

Parquet vs Avro

Avro è un formato basato su righe. È ottimo per attività come lo streaming di dati o l'elaborazione di log, dove aggiungi costantemente nuovi record o recuperi righe complete. Ma il formato colonnare di Parquet è perfetto per l'analisi. Se esegui query per analizzare grandi quantità di dati, Parquet è l'ideale. Estrae i dati dalle colonne necessarie e salta il resto per risparmiare tempo e risorse.

In breve, Parquet è migliore per leggere e analizzare grandi dataset, mentre Avro è ideale per scrivere e archiviare dati in modo facile da aggiornare.

Ecco una tabella comparativa tra Parquet vs. CSV vs. JSON vs. Avro, con pro, contro e casi d'uso:

Quando usare Apache Parquet

In sintesi, ecco alcune situazioni in cui Parquet è la scelta migliore:

• Workload con analytics pesanti: il formato colonnare di Parquet ci permette di recuperare solo i dati necessari, velocizzando le query e facendoci risparmiare tempo. L'ho visto sul campo processando dataset con Apache Spark: query che prima richiedevano minuti sono passate a pochi secondi grazie alla struttura efficiente di Parquet.
• Architetture di data lake: quando costruisci un data lake, i costi di archiviazione crescono rapidamente. Ma le capacità di compressione di Parquet riducono le dimensioni dei dati memorizzati, aiutandoti a risparmiare senza sacrificare le prestazioni. 
• Casi d'uso con grandi dataset: Parquet gestisce in modo ordinato dataset grandi e complessi, specialmente quelli con strutture annidate o gerarchiche. Il supporto per tipi di dato ricchi e l'evoluzione dello schema ti permette di adattare i dati man mano che cambiano i requisiti.

Considerazioni finali

Apache Parquet è perfetto per gestire i big data. È veloce, fa risparmiare spazio e funziona con strumenti come Spark. Se vuoi approfondire, dai un'occhiata alle risorse seguenti: 

• Introduction to Databricks, un corso per capire Databricks, una piattaforma dati unificata per semplificare i workflow di big data.
• Cleaning Data with PySpark, un corso per pulire e preprocessare i dataset usando PySpark.
• Big Data with PySpark, una track per scalare l'elaborazione dati con Apache Spark usando le API PySpark.