Apache Arrow: A Beginner’s Guide with Practical Examples

Apache Arrow helpt verschillende tools en systemen om snel en eenvoudig data uit te wisselen. Het slaat data op in een speciaal kolomgebaseerd formaat dat in het geheugen blijft, waardoor ermee werken erg snel is.

In deze tutorial neem ik je mee door de basis van Apache Arrow. Je krijgt hands-on voorbeelden om te begrijpen hoe het werkt en hoe je het in je projecten gebruikt.

Wat is Apache Arrow?

Apache Arrow is een open-source, taalonafhankelijk platform voor high-performance in-memory dataverwerking. Het definieert een gestandaardiseerd, kolomgeoriënteerd geheugenformaat geoptimaliseerd voor moderne CPU's om efficiënte analytics en gevectoriseerde berekeningen mogelijk te maken.

Arrow neemt ook de noodzaak voor serialisatie weg tussen systemen en talen, wat zero-copy reads mogelijk maakt en de verwerkingslast vermindert. 

Omdat het goed samenwerkt met tools zoals pandas, Apache Spark en Dask, kun je data met minimale moeite verplaatsen. Dat maakt het een uitstekende keuze voor iedereen die snelle, flexibele systemen bouwt die veel data moeten verwerken.

Laten we Arrow nu verkennen met wat praktische voorbeelden!

Apache Arrow installeren

Apache Arrow ondersteunt meerdere talen, waaronder C, C++, C#, Python, Rust, Java, JavaScript, Julia, Go, Ruby en R. 

Het werkt op Windows, macOS en populaire Linux-distributies zoals Debian, Ubuntu, CentOS en Red Hat Enterprise Linux.

In deze gids gebruiken we het met Python.

Stapsgewijze installatiewijzer

Laten we kijken hoe je Apache Arrow voor Python installeert met de officiële binary wheels die op PyPI zijn gepubliceerd. Deze stappen werken hetzelfde op Windows, macOS en Linux.

Stap 1: Controleer of Python is geïnstalleerd

Open je terminal en voer uit:

python --versionMogelijk gemaakt door

Als dit een versienummer teruggeeft, kun je aan de slag. Zo niet, installeer Python vanaf de officiële site.

Stap 2: Installeer pyarrow met pip

Om Apache Arrow voor Python te installeren, voer je uit:

pip install 'pyarrow==19.0.* '  Mogelijk gemaakt door

De * zorgt ervoor dat je de nieuwste patchrelease in de 19.0-serie krijgt. 

Ik raad ook aan om pyarrow==19.0.* in je requirements.txt te gebruiken om alles consistent te houden tussen omgevingen. Dit installeert pyarrow samen met de vereiste Apache Arrow- en Parquet C++-binary libraries die met het wheel worden meegeleverd.

Wil je Arrow voor een andere taal installeren, bekijk dan de volledige documentatie.

Installatie testen

Je kunt deze korte Python-snippet draaien om te controleren of alles werkt:

import pyarrow as pa
# Create a simple Arrow array
data = pa.array([1, 2, 3, 4, 5])
print("Apache Arrow is installed and working!")
print("Arrow Array:", data)Mogelijk gemaakt door

Als pyarrow correct is geïnstalleerd, zie je de array in je terminal geprint. Zo niet, dan geeft de code een foutmelding.

Apache Arrow-kerntheorie

Voordat we dieper de code induiken, kijken we hoe Apache Arrow is opgebouwd.

Het kolomgeheugenformaat begrijpen

Het in-memory kolomformaat is een van de belangrijkste features van Apache Arrow. Het definieert een taalonafhankelijke, in-memory datastructuur. Daarnaast bevat het metadata-serialisatie, een protocol voor datatransport en een standaard manier om data over systemen te representeren.

In een kolomformaat wordt data in kolommen opgeslagen in plaats van rijen, wat verschilt van traditionele rijgebaseerde opslag. Kolomindelingen zijn populair voor analytische workloads omdat ze veel sneller te scannen en te verwerken zijn.

De afbeelding hieronder legt het formaat uit:

Kolomformaat. Bron: Apache Arrow docs

Het formaat van Apache Arrow verhoogt de efficiëntie door kolommen in aaneengesloten geheugengebieden te leggen. Dit ondersteunt moderne gevectoriseerde (SIMD) operaties, die de dataverwerking versnellen.

Door een standaard kolomindeling te gebruiken, neemt Arrow de noodzaak weg voor elk systeem om zijn eigen interne dataformaat te definiëren. Dat vermindert zowel serialisatie-overhead als dubbel werk. 

Systemen kunnen data gemakkelijker delen en ontwikkelaars kunnen algoritmes hergebruiken in verschillende talen.

Zonder een gedeeld formaat zoals Arrow moeten databases of tools data serialiseren en deserialiseren voordat ze het doorgeven. Dat voegt kosten en complexiteit toe. En veelgebruikte algoritmes moeten voor de interne datastructuur van elk systeem worden herschreven. 

Arrow verandert dat door te standaardiseren hoe data in het geheugen wordt weergegeven.

Hoewel kolomformaten geweldig zijn voor analytische prestaties en geheugenlokaliteit, zijn ze niet ontworpen voor frequente updates.

Dat komt omdat kolomopslag is geoptimaliseerd voor snel lezen, niet voor wijzigen. Aanpassingen aan data betekenen vaak kopiëren of geheugen opnieuw toewijzen, wat traag en resource-intensief kan zijn.

Arrow richt zich op efficiënte in-memory representatie en serialisatie. Als je usecase frequente datamutaties vereist, moet je dat op implementatieniveau afhandelen.

Wil je dieper duiken in Arrow-compatibele formaten, bekijk dan deze guide naar Apache Parquet, ideaal voor kolomgebaseerde dataopslag.        

Arrow-datastructuren

Apache Arrow biedt twee kern-datastructuren: Array en Table: 

•  Arrow Array: Een Array staat voor één kolom data. Het slaat waarden op in een aaneengesloten geheugengebied, wat snelle toegang, efficiënte scans en ondersteuning voor processoroptimalisaties zoals SIMD mogelijk maakt. Elke array kan ook metadata bevatten, zoals null-indicatoren (bitmaps) en informatie over het datatype.
• Arrow Table: Data komt vaak in tweedimensionale formaten, zoals databasetabellen of CSV-bestanden. Een Arrow Table vertegenwoordigt dus een 2D-dataset. Elke kolom is een gechunkte array en alle kolommen volgen een gedeeld schema dat veldnamen en types definieert. Hoewel de chunks per kolom kunnen verschillen, moet het totale aantal elementen uitgelijnd blijven om de rijen consistent te houden.

Je kunt het zien als een DataFrame in pandas of R. Het is tabelvormig, efficiënt en ondersteunt bewerkingen over meerdere kolommen tegelijk.

Voorbeeld van basisdatastructuren

Laten we een paar voorbeelden bekijken van het maken van een Arrow-Array en Table in Python. 

Zorg dat je pyarrow hebt geïnstalleerd voordat je de onderstaande code draait, volgens de eerdere instructies.

Een Arrow Array maken

import pyarrow as pa

# Create an Arrow Array (single column)
data = pa.array([1, 2, 3, 4, 5])
print("Arrow Array:")
print(data)Mogelijk gemaakt door

Een Arrow Array printen. Afbeelding door de auteur.

Een Arrow Table maken

import pyarrow as pa

# Create an Arrow Table (multiple columns)
table = pa.table({
    'column1': pa.array([1, 2, 3]),
    'column2': pa.array(['a', 'b', 'c'])
})

print("\nArrow Table:")
print(table)Mogelijk gemaakt door

Een Arrow Table printen. Afbeelding door de auteur.          

Werken met Apache Arrow Arrays

Laten we zien hoe je met Arrow Arrays werkt en veelvoorkomende bewerkingen uitvoert, zoals slicen, filteren en metadata controleren.

Arrow Arrays maken

Arrow Arrays werken met verschillende datatypes, waaronder strings, drijvende-kommagetallen en gehele getallen. Zo maak je ze:

import pyarrow as pa

# Integer Array
int_array = pa.array([10, 20, 30], type=pa.int32())
print("Integer Array:")
print(int_array)

# String Array
string_array = pa.array(["apple", "banana", "cherry"], type=pa.string())
print("\nString Array:")
print(string_array)

# Floating-point Array
float_array = pa.array([1.1, 2.2, 3.3], type=pa.float64())
print("\nFloating-point Array:")
print(float_array)Mogelijk gemaakt door

Arrow Arrays met verschillende datatypes printen. Afbeelding door de auteur.

Basisbewerkingen op Arrow Arrays

Laten we een paar veelvoorkomende bewerkingen bekijken die je met Arrow Arrays kunt uitvoeren.

Slicen

Met slicen pak je een subsectie van een array. Je kunt bijvoorbeeld elementen uit specifieke indexbereiken halen:

import pyarrow as pa
arr = pa.array([10, 20, 30, 40, 50])
# Slice from index 1 to 4 (3 elements: 20, 30, 40)
sliced = arr.slice(1, 3)
print("Original Array:", arr)
print("Sliced Array (1:4):", sliced)Mogelijk gemaakt door

Een geslicete Arrow Array printen. Afbeelding door de auteur.

Filteren en metadata

Filteren gebruikt een booleaanse mask om alleen waarden te behouden die aan een voorwaarde voldoen. Je kunt ook metadata zoals type, lengte en aantal nulls opvragen. 

import pyarrow.compute as pc

arr = pa.array([10, 20, 30, 40, 50])

# Create a boolean mask: Keep elements > 25
mask = pc.greater(arr, pa.scalar(25))

# Apply the filter
filtered = pc.filter(arr, mask)

print("Filtered Array (values > 25):", filtered)

print("Array Type:", arr.type)
print("Array Length:", len(arr))
print("Null Count:", arr.null_count)
print("Is Null Bitmap Buffers:", arr.buffers())Mogelijk gemaakt door

Een gefilterde Arrow Array printen. Afbeelding door de auteur.

Metadata van een Arrow Array printen. Afbeelding door de auteur.

Apache Arrow Tables gebruiken

Je kunt Arrow Tables maken vanuit Arrow Arrays of direct vanuit native Python-datastructuren zoals dictionaries. Laten we kijken hoe. 

Tabellen maken en bekijken

Er zijn twee gebruikelijke manieren om een Arrow Table te maken:

1. Met meerdere Arrow Arrays
2. Met een Python-dictionary met pa.table()

Laten we beide manieren één voor één bekijken.

1. Met Arrow Arrays

import pyarrow as pa

# Create individual Arrow Arrays
ids = pa.array([1, 2, 3])
names = pa.array(['Alice', 'Bob', 'Charlie'])
scores = pa.array([85.0, 92.5, 78.3])

# Combine them into a Table
table = pa.table({
    'id': ids,
    'name': names,
    'score': scores
})

print("Arrow Table from Arrays:")
print(table)Mogelijk gemaakt door

In de bovenstaande code:

• We maken drie arrays (integer, string, float)
• We definiëren een schema door elke kolom een naam te geven
• We combineren ze in een Table met pa.table()

Een Arrow Table maken met meerdere Arrow Arrays. Afbeelding door de auteur.

2. Met een Python-dictionary

Laten we nu zien hoe je een Table maakt vanuit een Python-dictionary.

# Create a table directly from Python data
data = {
    'id': [4, 5, 6],
    'name': ['Diana', 'Eve', 'Frank'],
    'score': [88.0, 79.5, 91.2]
}

table2 = pa.table(data)

print("\nArrow Table from Dictionary:")
print(table2)Mogelijk gemaakt door

Deze methode is korter en compacter. We hoeven niet handmatig arrays te definiëren; Arrow regelt dat voor ons. 

Een Arrow Table direct vanuit Python-dictionaries maken. Afbeelding door de auteur.

Converteren tussen Arrow Tables en pandas DataFrames

Een van de grootste krachten van Arrow is de interoperabiliteit. Je kunt eenvoudig heen en weer tussen een Arrow Table en een pandas DataFrame. Zo doe je dat:

Een Arrow Table omzetten naar een pandas DataFrame

import pyarrow as pa
import pandas as pd

# Create an Arrow Table
data = {
    'numbers': [1, 2, 3],
    'fruits': ['apple', 'banana', 'cherry'],
    'prices': [1.1, 2.2, 3.3]
}
arrow_table = pa.table(data)

# Convert Arrow Table to pandas DataFrame
df = arrow_table.to_pandas()

# Show the DataFrame
print(df)Mogelijk gemaakt door

Een Arrow Table omzetten naar een Pandas DataFrame. Afbeelding door de auteur.

Een pandas DataFrame omzetten naar een Arrow Table

Laten we nu het omgekeerde doen: 

import pyarrow as pa
import pandas as pd

# Create a pandas DataFrame
df = pd.DataFrame({
    'numbers': [1, 2, 3],
    'fruits': ['apple', 'banana', 'cherry'],
    'prices': [1.1, 2.2, 3.3]
})

# Convert pandas DataFrame to Arrow Table
arrow_table = pa.Table.from_pandas(df)

# Show the Arrow Table
print(arrow_table)Mogelijk gemaakt door

Een pandas DataFrame converteren naar een Array Table. Afbeelding door de auteur.