Apache Parquet uitgelegd: een gids voor dataprofessionals

Features van Apache Parquet

Laten we de architectuur van Apache Parquet begrijpen aan de hand van de belangrijkste features: 

Kolomgeoriënteerde opslag

In tegenstelling tot rijgebaseerde formaten zoals CSV organiseert Parquet data per kolom. Dat betekent dat bij een query alleen de specifieke kolommen worden opgehaald die we nodig hebben, in plaats van alles te laden. Dit verbetert de prestaties en vermindert I/O-gebruik.

Rij- vs kolomgebaseerde structuur. Afbeelding door de auteur.

Parquet-bestanden worden opgesplitst in row groups, die een batch rijen bevatten. Elke row group is opgedeeld in column chunks, die elk de data voor één kolom bevatten. Deze chunks worden verder verdeeld in kleinere stukken, pages genoemd, die gecomprimeerd worden om ruimte te besparen.

Daarnaast slaan Parquet-bestanden extra informatie op in de footer, de metadata, die helpt om alleen de data te lokaliseren en te lezen die we nodig hebben. 

Zo ziet de structuur eruit:

Interne structuur van Parquet-bestand. Afbeelding door de auteur. 

Laten we elk onderdeel in het bovenstaande diagram doornemen.

Row groups

• Een row group bevat meerdere rijen maar slaat data kolomsgewijs op voor efficiënt lezen.
• Voorbeeld: een dataset met 1 miljoen rijen kan worden opgesplitst in 10 groepen van elk 100.000 rijen.

Column chunks

• Binnen elke row group wordt data per kolom gescheiden.
• Dit ontwerp maakt kolompruning mogelijk, waarbij we alleen de relevante kolommen lezen in plaats van het hele bestand te scannen.

Pages

• Elke column chunk is verder opgesplitst in pages om het geheugengebruik te optimaliseren.
• Pages zijn meestal gecomprimeerd, wat de opslagkosten verlaagt.

Footer (metadata)

• De footer aan het einde van een Parquet-bestand slaat indexinformatie op:
• Schema: definieert datatypes en kolomnamen.
• Row group-offsets: helpen specifieke data snel te lokaliseren.
• Statistieken: min/max-waarden om predicate pushdown mogelijk te maken (filteren op opslagniveau).

Compressie en codering

Zoals genoemd comprimeert Parquet data kolom voor kolom met compressiemethoden zoals Snappy en Gzip. Het gebruikt ook twee coderingstechnieken:

• Run-length encoding om herhaalde waarden compact op te slaan.
• Dictionary encoding om duplicaten te vervangen door verwijzingen naar een woordenboek. 

Dit verkleint bestanden en versnelt het lezen van data, wat vooral handig is bij big data.

Schema-evolutie

Schema-evolutie betekent het wijzigen van de structuur van datasets, zoals kolommen toevoegen of aanpassen. Dat klinkt eenvoudig, maar afhankelijk van hoe je data is opgeslagen, kan het aanpassen van het schema traag en resource-intensief zijn. 

Laten we dit begrijpen door de schema-evolutie van CSV en Parquet te vergelijken.

Stel dat je een CSV-bestand hebt met kolommen zoals student_id, student_name en student_age. Als je een nieuwe kolom scores wilt toevoegen, moet je het volgende doen:

1. Het hele bestand in het geheugen lezen.
2. De header updaten om de nieuwe kolom scores toe te voegen.
3. Voor elke student een score toevoegen. Dit betekent waarden toevoegen voor alle rijen (ook als ze ontbreken, heb je mogelijk placeholders nodig zoals lege strings of NULL).
4. Alles opslaan als een nieuw CSV-bestand.

CSV is een simpel tekstformaat zonder ingebouwde schemaondersteuning. Dit betekent dat elke wijziging in de structuur vereist dat je het hele bestand herschrijft, en oudere systemen die het aangepaste bestand lezen kunnen stuklopen als ze een andere structuur verwachten!

Met Parquet kun je velden toevoegen, verwijderen of bijwerken zonder je bestaande bestanden te breken. Zoals we eerder zagen, slaat Parquet schema-informatie op in de footer (metadata) van het bestand, waardoor schema’s kunnen evolueren zonder bestaande bestanden te wijzigen.

Zo werkt het:

• Wanneer je een nieuwe kolom toevoegt, blijven bestaande Parquet-bestanden ongewijzigd.
• Nieuwe bestanden bevatten de extra kolom, terwijl oude bestanden het vorige schema blijven volgen.
• Het verwijderen van een kolom vereist geen herverwerking van eerdere data; queries negeren de missende kolom.
• Als een kolom niet bestaat in een ouder bestand, geven Parquet-engines (zoals Apache Spark, Hive of BigQuery) NULL terug in plaats van de query te laten falen.
• Oudere Parquet-bestanden blijven leesbaar na schemawijzigingen.
• Nieuwere Parquet-bestanden met extra kolommen blijven leesbaar voor systemen die een ouder schema verwachten.

Een kolom toevoegen aan het Parquet-bestand zonder het te breken. Afbeelding door de auteur.

Taal- en platformondersteuning

Parquet ondersteunt verschillende programmeertalen, zoals Java, Python, C++ en Rust. Ontwikkelaars kunnen het daardoor gemakkelijk gebruiken, ongeacht hun platform. Het is ook native geïntegreerd met big data-frameworks zoals Apache Spark, Hive, Presto, Flink en Trino, wat efficiënte dataverwerking op schaal garandeert.

Dus of je nu Python (via PySpark) of een andere taal gebruikt, Parquet kan de data beheren op een manier die het makkelijk maakt om te queryen en te analyseren op verschillende platforms.

Als je nieuw bent met big data-frameworks, raad ik de cursus Introduction to PySpark aan. Een prima startpunt. 

Parquet-bestanden lezen en schrijven

Nu je de basis van Apache Parquet kent, laat ik je zien hoe je Parquet-bestanden schrijft, leest en integreert met pandas, PyArrow en andere big data-frameworks zoals Spark.

Parquet-bestanden schrijven met pandas

Om DataFrames als Parquet-bestanden op te slaan, heb je pandas en een Parquet-engine zoals PyArrow nodig:

pip install pandas pyarrow

Schrijf nu een Parquet-bestand met de volgende code:

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

Schrijf het Parquet-bestand met pandas. Afbeelding door de auteur.

Parquet-bestanden lezen met pandas

Hier is eenvoudige code om je Parquet-bestand te lezen:

import pandas as pd

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

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

Lees het Parquet-bestand met pandas. Afbeelding door de auteur.

Parquet-bestanden schrijven met PyArrow

PyArrow is een tool uit het Apache Arrow-project die het werken met Parquet-bestanden eenvoudig maakt. Zo schrijf je een Parquet-bestand met 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!")

Schrijf een Parquet-bestand met PyArrow. Afbeelding door de auteur.

Parquet-bestanden lezen met PyArrow

Zo lees je een Parquet-bestand met 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)

Lees het Parquet-bestand met PyArrow. Afbeelding door de auteur.

Integreren met big data-frameworks

We kunnen Spark gebruiken om Parquet-bestanden direct te lezen en te schrijven. Download het van de website van Apache Spark of stel het in volgens de instructies. 

Als dat klaar is, importeer je de libraries en maak je een 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()

Maak een voorbeeld-DataFrame in Spark. Afbeelding door de auteur.

Schrijf vervolgens dit DataFrame als een Parquet-bestand:

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

De write.parquet() slaat het DataFrame op in het Parquet-formaat, en het bestand heet employee.parquet. Om dit Parquet-bestand te lezen, kun je de volgende code gebruiken:

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

# Show the DataFrame
parquet_df.show()

Lees het Parquet-bestand. Afbeelding door de auteur. 

Naast Spark kan Parquet ook met Hive werken. Wanneer je een Hive-tabel maakt, gebruik dan STORED AS PARQUET om Parquet als opslagformaat te gebruiken.

Handige bewerkingen met Parquet

Naast lezen en schrijven zijn er een paar basisbewerkingen die elke ontwikkelaar zou moeten kennen, omdat ze handig zijn bij het werken met Parquet-bestanden. Laten we die in deze sectie doornemen.

Ik gebruik pandas en PyArrow om de concepten te illustreren.

Data toevoegen aan een bestaand Parquet-bestand

Data toevoegen (appen) is handig wanneer nieuwe records moeten worden toegevoegd zonder de volledige dataset te herschrijven.

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

Alleen specifieke kolommen uit een Parquet-bestand lezen

In plaats van de hele dataset te laden, kun je alleen de noodzakelijke kolommen selecteren, wat het geheugenverbruik vermindert en de prestaties verbetert. Dit is aanzienlijk sneller dan de volledige dataset lezen:

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

Filteren tijdens het lezen (predicate pushdown)

Parquet ondersteunt efficiënt filteren op opslagniveau, bekend als predicate pushdown, waardoor onnodige data niet wordt geladen. Dit voorkomt het scannen van het hele bestand en maakt queries veel sneller:

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)

Meerdere Parquet-bestanden samenvoegen

Vaak worden Parquet-bestanden opgeslagen als afzonderlijke partities. Je kunt ze samenvoegen tot één Parquet-bestand. Dit is handig bij het combineren van datasets uit verschillende bronnen:

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

CSV naar Parquet converteren

Als je bestaande CSV-bestanden hebt, bespaart het converteren naar Parquet ruimte en versnelt het de verwerking, wat de bestandsgrootte drastisch vermindert en de leessnelheid verbetert:

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

Parquet-bestanden partitioneren voor snellere queries

Partitioneren organiseert data in submappen op basis van een kolomwaarde, waardoor queries aanzienlijk sneller worden.

Zo schrijf je gepartitioneerde data:

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

De bovenstaande code maakt submappen aan:

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

Vervolgens kun je slechts één specifieke partitie lezen:

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

Dit versnelt analyses door alleen relevante partities te scannen!

Compressie gebruiken om opslag te optimaliseren

Parquet ondersteunt compressie-algoritmen zoals Snappy, Gzip en Brotli om de bestandsgrootte te verkleinen:

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

Best practices voor het gebruik van Apache Parquet

Toen ik begon met Apache Parquet, merkte ik dat kleine aanpassingen de efficiëntie flink kunnen verbeteren. Hier zijn enkele van mijn top-tips om Parquet te optimaliseren in praktijksituaties.

Kies de juiste compressiecodec

Als je opslag wilt besparen, zijn codecs zoals Snappy of Gzip vaak je beste opties — Snappy biedt snelle compressie en decompressie, perfect wanneer snelheid het belangrijkst is. 

Gzip is daarentegen ideaal als je krap zit met opslag maar iets tragere reads accepteert. De sleutel is je werklast begrijpen — een snellere codec zoals Snappy wint vaak als je bestanden vaak opent. Gzip is juist beter voor archiveringsdata.

Partioneer data effectief

Verdeel je data in logische subsets, zoals per datum, regio of een ander vaak gequeryde kolom, om de hoeveelheid gescande data tijdens een query te verminderen. Ik werkte eens met een dataset met jaren aan transactie-logs en partitioneerde die per jaar en maand, waardoor specifieke perioden in seconden in plaats van minuten opgehaald werden. 

Houd schema-evolutie in de gaten

Ik zorg er altijd voor dat nieuwe kolommen zo worden toegevoegd dat bestaande processen niet worden verstoord. Dat betekent meestal toevoegen in plaats van bestaande wijzigen. Gebruik hiervoor de ondersteuning voor schema-evolutie in Apache Spark om overgangen soepeler te laten verlopen. 

Apache Parquet vs. andere dataformaten

Laten we Parquet vergelijken met andere opslagformaten. 

Parquet vs CSV

Dit kwam al aan bod in de blogpost, maar ik benadruk het graag nog een keer: Parquet en CSV zijn twee verschillende formaten die data anders behandelen.

Parquet organiseert data in kolommen, terwijl CSV het in rijen plaatst. Met Parquet wordt alle data uit dezelfde kolom gegroepeerd, zodat je eenvoudig data uit specifieke kolommen kunt ophalen zonder door de rest te gaan. Het is sneller en neemt minder ruimte in omdat Parquet data comprimeert.

Kolomgebaseerd formaat van Parquet. Afbeelding door de auteur.

CSV daarentegen slaat data rij voor rij op. Het is eenvoudig en werkt goed voor kleine datasets, maar is niet ideaal voor grote. Elke query moet de hele rij lezen, zelfs als je maar een paar kolommen nodig hebt. Dit vertraagt en kost meer geheugen om te verwerken.

Rijgebaseerd formaat van CSV. Afbeelding door de auteur.

Parquet vs JSON

JSON is geweldig om data op een begrijpelijke manier te structureren, maar heeft een nadeel: het is niet erg efficiënt qua opslag of snelheid. Laat me met een voorbeeld uitleggen waarom Parquet efficiënter is dan JSON.

Stel dat we een tabel met werknemersdata hebben met drie kolommen: EmployeeID, Department en Location:

Als we deze data als JSON opslaan, ziet het er ongeveer zo uit:

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

Merk op dat JSON kolomnamen zoals EmployeeID, Department en Location bij elk record herhaalt. Ook worden de waarden HR en New York meerdere keren herhaald. Dat maakt het bestand veel groter en trager.

Laten we ons nu voorstellen (want Parquet is niet menselijk leesbaar) dat we dezelfde data als Parquet opslaan:

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

In plaats van rij voor rij op te slaan, organiseert Parquet de data per kolom en comprimeert herhalende waarden.

Parquet vs Avro

Avro is een rijgebaseerd formaat. Het is ideaal voor taken zoals streamingdata of logverwerking, waarbij je voortdurend nieuwe records toevoegt of complete rijen ophaalt. Maar het kolomgebaseerde formaat van Parquet is perfect voor analytics. Als je queries draait om grote hoeveelheden data te analyseren, werkt Parquet het best. Het haalt data op uit de benodigde kolommen en slaat de rest over om tijd en resources te besparen.

Kortom: Parquet is beter voor het lezen en analyseren van grote datasets, terwijl Avro ideaal is voor het snel schrijven en opslaan van data die eenvoudig te updaten is.

Hier is een vergelijkingstabel van Parquet vs. CSV vs. JSON vs. Avro, inclusief voor- en nadelen en use-cases:

Wanneer gebruik je Apache Parquet

Samenvattend, dit zijn situaties waarin Parquet de beste keuze is:

• Workloads met veel analytics: het kolomformaat van Parquet zorgt dat we alleen de data ophalen die we nodig hebben, wat queries versnelt en tijd bespaart. Ik heb dit zelf ervaren bij het verwerken van datasets met Apache Spark — queries die eerst minuten duurden, liepen in seconden dankzij Parquet’s efficiënte structuur.
• Datalake-architecturen: bij het bouwen van een datalake lopen opslagkosten snel op. De compressiemogelijkheden van Parquet verkleinen de opgeslagen data, zodat je op opslag bespaart zonder performance op te offeren. 
• Use-cases met grote datasets: Parquet gaat netjes om met grote en complexe datasets, vooral die met geneste of hiërarchische structuren. De ondersteuning voor rijke datatypes en schema-evolutie zorgt dat je je data kunt aanpassen als de eisen veranderen.

Tot slot

Apache Parquet is perfect voor het werken met big data. Het is snel, bespaart opslagruimte en werkt met tools zoals Spark. Als je meer wilt leren, bekijk dan de volgende resources: 

• Cursus Introduction to Databricks om Databricks te begrijpen, een unified dataplatform om big data-workflows te stroomlijnen.
• Cursus Cleaning Data with PySpark om datasets te schonen en voor te bewerken met PySpark.
• Big Data with PySpark-track om dataverwerking op te schalen met Apache Spark via de PySpark-API.