Apache Parquet Erklärt: Ein Leitfaden für Datenexperten

Eigenschaften von Apache Parkett

Lass uns die Architektur von Apache Parquet mit seinen wichtigsten Funktionen verstehen: 

Säulenförmige Lagerung

Anders als zeilenbasierte Formate wie CSV organisiert Parquet die Daten in Spalten. Das bedeutet, dass bei einer Abfrage nur die benötigten Spalten abgefragt werden, anstatt alles zu laden. Das verbessert die Leistung und reduziert die E/A-Nutzung.

Zeilen- vs. spaltenbasierte Struktur. Bild vom Autor.

Parquet-Dateien sind in Zeilengruppen aufgeteilt, die einen Stapel von Zeilen enthalten. Jede Zeilengruppe ist in Spaltenblöcke unterteilt, die jeweils Daten für eine Spalte enthalten. Diese Chunks werden in kleinere Teile, die sogenannten Seiten, unterteilt, die komprimiert werden, um Platz zu sparen.

Außerdem speichern Parquet-Dateien zusätzliche Informationen in der Fußzeile, die so genannten Metadaten, die nur die Daten finden und lesen, die wir brauchen. 

Hier siehst du, wie die Struktur aussieht:

Interne Struktur der Parkettdatei. Bild vom Autor. 

Lass uns die einzelnen Komponenten im obigen Diagramm aufschlüsseln.

Zeilengruppen

• Eine Zeilengruppe enthält mehrere Zeilen, speichert die Daten aber spaltenweise, damit sie effizient gelesen werden können.
• Beispiel: Ein Datensatz mit 1 Million Zeilen kann in 10 Gruppen mit jeweils 100.000 Zeilen aufgeteilt werden.

Spalten-Brocken

• Innerhalb jeder Zeilengruppe sind die Daten durch Spalten getrennt.
• Dieses Design ermöglicht ein spaltenbasiertes Pruning, bei dem wir nur die relevanten Spalten lesen können, anstatt die gesamte Datei zu durchsuchen.

Seiten

• Jeder Spaltenchunk wird in Seiten aufgeteilt, um die Speichernutzung zu optimieren.
• Die Seiten werden in der Regel komprimiert, was die Speicherkosten senkt.

Fußzeile (Metadaten)

• Die Fußzeile am Ende einer Parquet-Datei enthält Indexinformationen:
• Schema: Definiert Datentypen und Spaltennamen.
• Versatz der Zeilengruppen: Hilft, bestimmte Daten schnell zu finden.
• Statistik: Min-/Max-Werte, um den Prädikats-Pushdown (Filterung auf Speicherebene) zu aktivieren.

Komprimierung und Kodierung

Wie bereits erwähnt, komprimiert Parquet die Daten spaltenweise mit Kompressionsmethoden wie Snappy und Gzip. Außerdem werden zwei Kodierungstechniken verwendet:

• Lauflängenkodierung um wiederholte Werte kompakt zu speichern.
• Wörterbuch-Kodierung um Duplikate durch Wörterbuchreferenzen zu ersetzen.

Das reduziert die Dateigröße und beschleunigt das Lesen der Daten, was besonders hilfreich ist, wenn du mit großen Daten arbeitest.

Schema-Entwicklung

Schemaentwicklung bedeutet, dass die Struktur von Datensätzen geändert wird, z. B. durch Hinzufügen oder Ändern von Spalten. Es mag einfach klingen, aber je nachdem, wie deine Daten gespeichert sind, kann die Änderung des Schemas langsam und ressourcenintensiv sein. 

Um das zu verstehen, vergleichen wir die Entwicklung des CSV- und des Parkett-Schemas.

Angenommen, du hast eine CSV Datei mit Spalten wie student_id, student_name und student_age. Wenn du eine neue Spalte scores hinzufügen möchtest, musst du Folgendes tun:

1. Lies die gesamte Datei in den Speicher.
2. Aktualisiere die Kopfzeile und füge eine neue Spalte hinzu: scores.
3. Füge für jeden Schüler eine Punktzahl hinzu. Das bedeutet, dass du die Werte für alle Zeilen anfügst (auch wenn sie fehlen, brauchst du vielleicht Platzhalter wie leere Strings oder NULL).
4. Speichere alles als neue CSV-Datei.

CSV ist ein einfaches textbasiertes Format ohne integrierte Schemaunterstützung. Das bedeutet, dass bei jeder Änderung der Struktur die gesamte Datei neu geschrieben werden muss. Ältere Systeme, die die geänderte Datei lesen, könnten dann abbrechen, wenn sie eine andere Struktur erwarten!

Mit Parquet kannst du Felder hinzufügen, entfernen oder aktualisieren, ohne deine bestehenden Dateien zu zerstören. Wie wir bereits gesehen haben, speichert Parquet die Schemainformationen in der Fußzeile der Datei (Metadaten), sodass Schemata weiterentwickelt werden können, ohne dass bestehende Dateien verändert werden müssen.

So funktioniert es:

• Wenn du eine neue Spalte hinzufügst, bleiben die bestehenden Parkettdateien unverändert.
• Neue Dateien werden die zusätzliche Spalte enthalten, während alte Dateien weiterhin dem vorherigen Schema folgen.
• Wenn du eine Spalte entfernst, musst du die vorherigen Daten nicht erneut verarbeiten; die Abfragen ignorieren die fehlende Spalte.
• Wenn eine Spalte in einer älteren Datei nicht existiert, geben Parquet-Engines (wie Apache Spark, Hive oder BigQuery) NULL zurück, anstatt die Abfrage abzubrechen.
• Ältere Parquet-Dateien können auch nach Schemaänderungen gelesen werden.
• Neuere Parquet-Dateien mit zusätzlichen Spalten können auch von Systemen gelesen werden, die ein älteres Schema erwarten.

Hinzufügen einer Spalte zur Parkettdatei, ohne sie zu zerstören. Bild vom Autor.

Unterstützung von Sprachen und Plattformen

Parquet unterstützt verschiedene Programmiersprachen, wie Java, Python, C++ und Rust. Das bedeutet, dass Entwickler es unabhängig von ihrer Plattform einfach nutzen können. Außerdem ist sie nativ in Big-Data-Frameworks wie Apache Spark, Hive, Presto, Flink und Trino integriert, was eine effiziente Datenverarbeitung im großen Maßstab gewährleistet.

Egal, ob du Python (über PySpark) oder eine andere Sprache verwendest, Parquet kann die Daten so verwalten, dass sie auf verschiedenen Plattformen leicht abgefragt und analysiert werden können.

Wenn du dich noch nicht mit Big Data-Frameworks auskennst, empfehle ich dir den Kurs Einführung in PySpark. Das ist eine gute Möglichkeit, um anzufangen. 

Wie man Parkettdateien liest und schreibt

Nachdem du nun die Grundlagen von Apache Parquet kennst, führe ich dich durch das Schreiben, Lesen und Integrieren vonParquet-Dateien mit Pandas, PyArrowund anderen Big Data Frameworks wie Spark.

Parquet-Dateien mit Pandas schreiben

Um DataFrames als Parquet-Dateien zu speichern, brauchst du Pandas und eine Parquet-Engine wie PyArrow:

pip install pandas pyarrow

Schreibe nun eine Parquet-Datei mit folgendem 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!")

Schreibe die Parquet-Datei mit Pandas. Bild vom Autor.

Parquet-Dateien mit Pandas lesen

Hier ist ein einfacher Code, um deine Parquet-Datei zu lesen:

import pandas as pd

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

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

Lies die Parquet-Datei mit Pandas. Bild vom Autor.

Parquet-Dateien mit PyArrow schreiben

PyArrow ist ein Tool aus dem Apache Arrow-Projekt, das die Arbeit mit Parkettdateien erleichtert. Hier erfährst du, wie du mit PyArrow eine Parkettdatei schreiben kannst:

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

Schreibe eine Parquet-Datei mit PyArrow. Bild vom Autor.

Parquet-Dateien mit PyArrow lesen

Hier erfährst du, wie du eine Parquet-Datei mit PyArrow lesen kannst:

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)

Lies die Parquet-Datei mit PyArrow ein. Bild vom Autor.

Integration mit Big Data-Frameworks

Wir können Spark nutzen, um Parquet-Dateien direkt zu lesen und zu schreiben. Lade sie von der Apache Spark-Websiteherunter oder richte sie gemäß den Anweisungen ein.

Anschließend importierst du die Bibliotheken und erstellst einen 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()

Erstelle ein DataFrame-Beispiel in Spark. Bild vom Autor.

Als Nächstes schreibst du diesen DataFrame in eine Parquet-Datei:

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

write.parquet() speichert den DataFrame im Parquet-Format, und die Datei wird employee.parquet genannt. Um diese Parkettdatei zu lesen, kannst du den folgenden Code verwenden:

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

# Show the DataFrame
parquet_df.show()

Lies die Parkettdatei. Bild vom Autor. 

Neben Spark kann Parquet auch mit Hive arbeiten. Wenn du eine Hive-Tabelle erstellst, verwende STORED AS PARQUET, um Parquet als Speicherformat festzulegen.

Nützliche Operationen mit Parkett

Neben dem Lesen und Schreiben gibt es einige grundlegende Operationen, die jeder Entwickler kennen sollte, da sie bei der Arbeit mit Parkettdateien nützlich sind. In diesem Abschnitt gehen wir sie durch.

Ich werde Pandas und PyArrow verwenden, um die Konzepte zu veranschaulichen.

Daten an eine bestehende Parquet-Datei anhängen

Das Anhängen von Daten ist nützlich, wenn neue Datensätze hinzugefügt werden müssen, ohne den gesamten Datensatz neu zu schreiben.

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

Nur bestimmte Spalten aus einer Parquet-Datei lesen

Anstatt den gesamten Datensatz zu laden, kannst du nur die benötigten Spalten auswählen, was den Speicherbedarf reduziert und die Leistung verbessert. Das ist deutlich schneller als das Lesen des gesamten Datensatzes:

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

Filtern von Daten beim Lesen (Prädikat Pushdown)

Parquet ermöglicht eine effiziente Filterung auf der Speicherebene, bekannt als Prädikats-Pushdown, der das Laden unnötiger Daten verhindert. Dadurch muss nicht die gesamte Datei gescannt werden, was Abfragen viel schneller macht:

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)

Mehrere Parkettdateien zusammenführen

Oft werden die Parkettdateien in separaten Partitionen gespeichert. Du kannst sie in einer einzigen Parkettdatei zusammenführen. Dies ist nützlich, wenn du Datensätze aus verschiedenen Quellen kombinierst:

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 in Parkett umwandeln

Wenn du vorhandene CSV-Dateien hast, spart die Konvertierung in Parquet Platz und beschleunigt die Verarbeitung, was die Dateigröße drastisch reduziert und die Leseleistung verbessert:

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

Partitionierung von Parquet-Dateien für schnellere Abfragen

Durch die Partitionierung werden Daten auf der Grundlage eines Spaltenwerts in Unterverzeichnissen organisiert, wodurch Abfragen deutlich schneller werden.

Hier erfährst du, wie du partitionierte Daten schreiben kannst:

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

Der obige Code erstellt Unterverzeichnisse:

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

Dann kannst du nur eine bestimmte Partition lesen:

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

Dies beschleunigt die Analyse, da nur relevante Partitionen gescannt werden!

Komprimierung zur Optimierung der Speicherung verwenden

Parquet unterstützt Komprimierungsalgorithmen wie Snappy, Gzip und Brotli, um die Dateigröße zu reduzieren:

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

Best Practices für die Verwendung von Apache Parquet

Als ich anfing, Apache Parquet zu benutzen, merkte ich, dass kleine Anpassungen seine Effizienz erheblich verbessern können. Hier sind einige meiner besten Tipps für die Optimierung von Parkett in realen Szenarien.

Wähle den richtigen Komprimierungscodec

Wenn du Speicherplatz sparen willst, können Codecs wie Snappy oder Gzip Snappy bietet eine schnelle Komprimierung und Dekomprimierung und eignet sich perfekt für Situationen, in denen es auf Geschwindigkeit ankommt.

Umgekehrt ist Gzip ideal, wenn du wenig Speicherplatz zur Verfügung hast, aber etwas langsamere Lesevorgänge verkraften kannst. Entscheidend ist, dass du dein Arbeitspensum verstehst - ein schneller Codec wie Snappy ist oft die bessere Wahl, wenn du häufig auf Dateien zugreifst. Für die Archivierung von Daten ist Gzip jedoch am besten geeignet.

Daten effektiv partitionieren

Unterteile deine Daten in logische Teilmengen, z. B. nach Datum, Region oder einem anderen häufig abgefragten Feld, um die Datenmenge zu reduzieren, die bei einer Abfrage durchsucht wird. Ich habe einmal mit einem Datensatz gearbeitet, der Jahre von Transaktionsprotokollen enthielt, und ihn nach Jahr und Monat unterteilt, um bestimmte Zeiträume in Sekunden statt in Minuten abzurufen. 

Schema-Entwicklung überwachen

Ich achte immer darauf, dass neue Spalten so hinzugefügt werden, dass sie die bestehenden Prozesse nicht stören. Das bedeutet in der Regel, dass sie angehängt werden, anstatt bestehende zu ändern. Dazu kannst du die Schema-Evolution von Apache Spark nutzen, um sanftere Übergänge zu schaffen. 

Apache Parquet im Vergleich zu anderen Datenformaten

Lass uns Parquet mit anderen Datenspeicherformaten vergleichen. 

Parkett vs. CSV

Wir haben das bereits in diesem Blogpost behandelt, aber ich möchte es noch einmal betonen: Parquet und CSV sind zwei verschiedene Formate, die Daten unterschiedlich verarbeiten.

Parquet organisiert die Daten in Spalten, während CSV sie in Zeilen anordnet. Wenn du Parquet verwendest, werden alle Daten aus derselben Spalte gruppiert, so dass du ganz einfach Daten aus bestimmten Spalten abrufen kannst, ohne alles andere durchsuchen zu müssen. Es ist schneller und braucht weniger Platz, weil Parquet die Daten komprimiert.

Spaltenbasiertes Parkettformat. Bild vom Autor.

CSV hingegen speichert die Daten Zeile für Zeile. Es ist einfach und funktioniert gut für kleine Datensätze, aber es ist nicht ideal für große Datensätze. Jede Abfrage muss die gesamte Zeile lesen, auch wenn du nur ein paar Spalten brauchst. Das verlangsamt die Abläufe und benötigt mehr Speicherplatz für die Verarbeitung.

Zeilenbasiertes CSV-Format. Bild vom Autor.

Parkett vs. JSON

JSON eignet sich hervorragend, um Daten so zu strukturieren, dass sie leicht zu verstehen sind, aber es hat einen Nachteil: Es ist nicht sehr effizient, was die Speicherung oder Geschwindigkeit angeht. Lass mich also anhand eines Beispiels erklären, warum Parquet effizienter ist als JSON.

Angenommen, wir haben eine Tabelle mit Mitarbeiterdaten mit drei Spalten: EmployeeID, Department, und Location:

Wenn wir diese Daten nun als JSON speichern, sehen sie etwa so aus:

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

Beachte, dass JSON Spaltennamen wie EmployeeID, Department und Location für jeden einzelnen Datensatz wiederholt. Außerdem werden die Werte für HR und New York mehrfach wiederholt. Dadurch wird die Datei viel größer und langsamer.

Stellen wir uns nun vor (weil Parquet nicht für Menschen lesbar ist), wir speichern die gleichen Daten wie Parquet:

• EmployeeID: [1, 2, 3, 4, 5]
• Abteilung: [HR, HR, HR, IT, IT] (komprimiert als HR: 3, IT: 2)
• Standort: [New York, New York, New York, San Francisco, San Francisco] (komprimiert als New York: 3, San Francisco: 2).

Anstatt Zeile für Zeile zu speichern, organisiert Parquet die Daten nach Spalten und komprimiert sich wiederholende Werte.

Parkett vs Avro

Avro ist ein zeilenbasiertes Format. Sie eignet sich hervorragend für Aufgaben wie das Streaming von Daten oder die Verarbeitung von Protokollen, bei denen du ständig neue Datensätze hinzufügst oder komplette Zeilen abrufst. Aber das spaltenbasierte Format von Parquet ist perfekt für Analysen. Wenn du Abfragen durchführst, um große Datenmengen zu analysieren, ist Parquet am besten geeignet. Es zieht die Daten aus den notwendigen Spalten und überspringt den Rest, um Zeit und Ressourcen zu sparen.

Kurz gesagt: Parquet eignet sich besser zum Lesen und Analysieren großer Datensätze, während Avro ideal zum Schreiben und Speichern von Daten ist, die sich leicht aktualisieren lassen.

Hier ist eine Tabelle zum Vergleich zwischen Parkett und CSV vs. JSON vs. Avro, einschließlich Vor- und Nachteile sowie Anwendungsfälle:

Wann sollte man Apache Parquet verwenden?

Zusammengefasst gibt es hier einige Situationen, in denen Parkett die beste Wahl ist:

• Analytik-lastige Workloads: Das Spaltenformat von Parquet ermöglicht es uns, nur die Daten abzurufen, die wir brauchen, was Abfragen beschleunigt und Zeit spart. Ich habe das bei der Verarbeitung von Datensätzen mit Apache Spark in der Praxis erlebt - Abfragen, die früher Minuten dauerten, liefen dank der effizienten Struktur von Parquet in Sekundenschnelle.
• Data Lake-Architekturen: Wenn du einen Data Lake aufbaust, summieren sich die Speicherkosten schnell. Aber die Komprimierungsfunktionen von Parquet reduzieren die Größe der gespeicherten Daten, damit du Speicherplatz sparen kannst, ohne die Leistung zu beeinträchtigen. 
• Anwendungsfälle mit großen Datenmengen: Parquet kann mit großen und komplexen Datensätzen umgehen, insbesondere mit solchen mit verschachtelten oder hierarchischen Strukturen. Durch die Unterstützung zahlreicher Datentypen und die Schemaentwicklung wird sichergestellt, dass du deine Daten anpassen kannst, wenn sich die Anforderungen ändern.

Schlussgedanken

Apache Parquet ist perfekt für die Verarbeitung großer Datenmengen. Es ist schnell, spart Speicherplatz und funktioniert mit Tools wie Spark. Wenn du mehr erfahren möchtest, schau dir die folgenden Ressourcen an:

• Einführung in Databricks Kurs zum Verständnis von Databricks, einer einheitlichen Datenplattform zur Rationalisierung von Big Data Workflows.
• Datenbereinigung mit PySpark Kurs zur Bereinigung und Vorverarbeitung von Datensätzen mit PySpark.
• Lernpfad Big Data mit PySpark zur Skalierung der Datenverarbeitung mit Apache Spark unter Verwendung der PySpark API.