DuckDB vs SQLite: Ein kompletter Datenbankvergleich

Im modernen Datenmanagement spielen leichtgewichtige eingebettete Datenbanken eine wichtige Rolle bei der Unterstützung von Anwendungen, Arbeitsabläufen und Analysen. Zwei Systeme, die oft miteinander verglichen werden, sind DuckDB und SQLite. 

Beide sind eingebettete Datenbanken, aber sie haben unterschiedliche Aufgaben: SQLite ist super für Transaktions-Workloads, während DuckDB für analytische Abfragen optimiert ist.

In diesem Vergleichsartikel schauen wir uns an, wie sich die beiden Datenbanken voneinander unterscheiden.

Auf einen Blick: DuckDB vs SQLite

Hier ist 'ne Tabelle, die zeigt, was DuckDB und SQLite gemeinsam haben und wo sie sich unterscheiden. Für alle Details check einfach die Erklärungen in diesem Artikel. 

Was ist SQLite?

SQLite ist eine der am häufigsten eingesetzten Datenbanken weltweit. SQLite kam im Jahr 2000 raus und wurde als leichtes, serverlose SQL-Datenbank-Engine.

Hier sind ein paar der wichtigsten Features:

• Eigenständig und ohne Server
• Einrichtung ohne Konfiguration
• Vollständig ACID-konform
• Zeilenorientierte Speicherung

Wegen seiner schlanken Architektur kann es in folgenden Fällen eingesetzt werden:

• Mobile Apps (Android, iOS)
• Desktop-Software
• Eingebettete Systeme wie IoT-Geräte

Die größte Stärke von SQLite ist, dass es einfach und zuverlässig ist. Entwickler können eine einzelne dateibasierte Datenbank mit ihrer Anwendung ausliefern, ohne sich um externe Abhängigkeiten kümmern zu müssen.

Was ist DuckDB?

DuckDB wird oft als SQLite für Analysen bezeichnet. DuckDB wurde 2019 eingeführt und am CWI entwickelt. Das Hauptziel von DuckDB war, eine In-Process-OLAP-Datenbanklösung zu haben. OLAP-Datenbanklösung.

Hier sind ein paar der wichtigsten Features:

• Spaltenorientiertes Speicherformat
• Optimiert für OLAP-Workloads
• Vektorisierte Abfrageausführung
• Eingebettetes Design während des Prozesses
• Direkte Unterstützung für Dateiformate wie Parquet und Arrow

Ein paar typische Anwendungsfälle sind:

• Interaktive Analysen
• Data-Science-Workflows (Python, R, Jupyter)
• Leichte ETL-Pipelines

Der wichtigste Punkt bei der Verwendung von DuckDB ist, dass es die Leistungsfähigkeit analytischer Datenbanken (wie Snowflake oder BigQuery) in einem eingebetteten Paket bietet.

DuckDB vs SQLite: Wichtige Unterschiede und Gemeinsamkeiten

1. Installation und Abhängigkeiten

SQLite

SQLite ist bekannt dafür, dass es keine Abhängigkeiten hat. Es wird zu einer einzigen C-Bibliothek zusammengestellt, die in so ziemlich jede Anwendung eingebaut werden kann.

Die Installation ist echt einfach und du kannst das Programm einfach von der SQLite-Website runterladen.

Die Portabilität ist eine der größten Stärken: Es läuft auf Windows, macOS, Linux, iOS und Android fast ohne zusätzlichen Aufwand gleich.

DuckDB

DuckDB ist auch einfach zu installieren, wird aber als separate Binärdateien oder Python-/R-Pakete und nicht überall vorinstalliert.

Es gibt ein paar weitere Abhängigkeiten, vor allem wenn man Integrationen mit Apache Arrow, Parquet oder Pandas.

Der Platzbedarf ist immer noch gering, aber im Vergleich zu SQLite braucht DuckDB ein bisschen mehr Einrichtung, wenn du erweiterte Funktionen wie Cloud-Speicher-Konnektoren oder die Integration von Data-Science-Tools haben willst.

2. Speicherformate und Architektur

SQLite 

Speichert Daten in einem zeilenbasierten Format, das für OLTP (Online Transaction Processing) Aufgaben wie Einfügen, Aktualisieren und Löschen.

Das Abrufen einer ganzen Zeile geht schnell, aber analytische Abfragen, die nur ein paar Spalten über Millionen von Zeilen scannen, können langsam werden, weil unnötige Daten gelesen werden.

DuckDB

DuckDB nutzt eine Spaltenspeicher-Engine, die extra für OLAP (Online Analytical Processing) entwickelt wurde.

Das spaltenorientierte Format bedeutet, dass Abfragen, die große Datensätze zusammenfassen (z. B. AVG(sales) oder COUNT(*)), viel schneller sind, weil nur die relevanten Spalten in den Speicher geladen werden.

Ermöglicht außerdem eine bessere Komprimierung und vektorisierte Ausführung für mehr Geschwindigkeit.

Beispiel: Eine Abfrage wie „ SELECT * FROM sales WHERE customer_id=123 “ läuft schneller auf SQLite, während „ SELECT AVG(amount) FROM sales GROUP BY region “ auf DuckDB viel schneller geht.

3. Transaktionsbezogene vs. analytische Arbeitslasten

Die beiden Datenbanken haben auch unterschiedliche Arbeitslasten:

• OLTP (Transactional): Kurze, häufige Vorgänge (z. B. Banking-Apps, Benutzerprofile, Kassensysteme). Die wichtigsten Sachen sind niedrige Latenz, Datenintegrität und gleichzeitiger Zugriff.
• OLAP (Analytisch): Komplexe Abfragen über große Datensätze (z. B. Dashboards, BI-Tools, Ad-hoc-Datenanalysen). Die wichtigsten Sachen sind Durchsatz, Scan-Leistung und wie schnell die Daten zusammengefasst werden.

SQLite

SQLite ist für OLTP (Einfügen, Aktualisieren, Löschen, Punktabfragen) optimiert.

Zum Beispiel:

• Mobile Apps, die Offline-Daten speichern.
• IoT-Geräte, die Benutzerinteraktionen aufzeichnen.
• Lokale Caches in Desktop-Anwendungen.

DuckDB

DuckDB ist für OLAP (Aggregationen, Verknüpfungen, Scans) optimiert.

Zum Beispiel:

• Datenwissenschaftler, die Aggregationen auf Parquet-/CSV-Dateien machen.
• Interaktive BI-Dashboards , wo Abfragen Millionen von Zeilen zusammenfassen.
• ETL/ELT-Pipelines die leichte In-Memory-Transformationen brauchen.

4. SQL-Unterstützung und Syntax

Als Nächstes schauen wir uns mal ihre SQL-Syntax an. Beide setzen einen großen Teil des SQL-Standards mit Erweiterungen um; keiner ist komplett ANSI-konform.

SQLite

• Unterstützt einen Großteil des SQL-Standards, lässt aber fortgeschrittene analytische Konstrukte weg.
• Super für CRUD-Operationen und einfachere Verknüpfungen.
• Unterstützt Fensterfunktionen und CTEs, aber es fehlen fortgeschrittenere Analysefunktionen wie GROUPING SETS und einige Aggregat-Erweiterungen.

So sieht die Syntax aus:

CREATE TABLE sales (
    id INTEGER PRIMARY KEY,
    product TEXT,
    amount REAL,
    sale_date TEXT
);

DuckDB

• Viel näher an der ANSI-SQL-Konformität, mit starker Unterstützung für Fensterfunktionen, CTEs, Aggregationen und Mengenoperationen.
• Entwickelt, um sich wie ein leichtes PostgreSQL für Analysen anzufühlen.
• Durch die Integration mit Arrow und Pandas kannst du SQL direkt auf externen Datensätzen ausführen, ohne sie vorher importieren zu müssen.

Hier ist ein ähnliches Beispiel dafür, wie die Syntax für DuckDB aussieht:

CREATE TABLE sales (
    id INTEGER,
    product VARCHAR,
    amount DOUBLE,
    sale_date DATE
);

SQLite vs DuckDB: Grundlegende Architektur und Designphilosophie

Was die grundlegende Architektur angeht, sind SQLite und DuckDB beides eingebettete In-Process-Datenbanken. Aber ihre Designideen sind unterschiedlich. 

SQLite legt Wert auf einfache Transaktionen und Zuverlässigkeit, während DuckDB für analytische Aufgaben und moderne Datenwissenschaftsintegration optimiert ist.

1. Speicherarchitektur

Erstens unterscheiden sich die beiden Datenbanken in ihrer Speicherarchitektur.

SQLite

SQLite ist zeilenbasiert, was super für den transaktionalen Zugriff ist. Das heißt, ganze Zeilen werden zusammen auf der Festplatte gespeichert.

Dieses Design ist super für Transaktions-Workloads (OLTP), weil man zum Einfügen, Aktualisieren oder Abrufen eines einzelnen Datensatzes normalerweise nur auf eine Zeile zugreifen muss.

Apps, die schnell und immer auf einzelne Datensätze zugreifen müssen, wie zum Beispiel Benutzerprofile oder Bestelldetails, laufen in diesem Modell super.

DuckDB

DuckDB nutzt ein spaltenorientiertes Format, das dafür gemacht ist, Milliarden von Zeilen schnell zu scannen. Ein spaltenorientiertes Format heißt, dass Werte derselben Spalte auf der Festplatte und im Speicher zusammen gruppiert werden.

Die spaltenorientierte Speicherung macht super effiziente analytische Abfragen (OLAP) möglich, weil Aggregationen, Filter und Scans oft nur auf einen Teil der Spalten zugreifen müssen.

Komprimierungstechniken funktionieren besser über Spalten hinweg, sparen Speicherplatz und verbessern die Scan-Leistung.

2. Methoden zur Abfrageverarbeitung

Als Nächstes müssen wir uns anschauen, wie jeder von ihnen Abfragen verarbeitet.

Im Allgemeinen ist das Modell von SQLite auf Einfachheit und Transaktionskorrektheit ausgelegt, während die vektorisierte Engine von DuckDB auf Durchsatz und analytische Leistung optimiert ist.

SQLite

SQLite nutzt ein klassisches iteratorbasiertes Modell, bei dem eine Zeile nach der anderen durch die Abfrage-Pipeline geschickt wird.

Dieser Ansatz, bei dem eine Zeile nach der anderen abgearbeitet wird, ist leicht und passt gut zu Transaktions-Workloads, wo Abfragen oft kleine Datensätze und häufige Einfügungen oder Aktualisierungen beinhalten.

Allerdings gibt's Performance-Probleme, wenn Abfragen große Datensätze durchsuchen müssen, weil die zeilenweise Auswertung zusätzlichen Aufwand bedeutet.

DuckDB

DuckDB nutzt vektorisierte Abfrageausführung und verarbeitet mehrere Zeilen (Vektoren) gleichzeitig, statt eine nach der anderen.

Dieser Ansatz reduziert den CPU-Overhead, nutzt moderne CPU-Caches besser aus und ermöglicht SIMD-Parallelität (Single Instruction, Multiple Data).

Die vektorisierte Ausführung ist besonders praktisch für Analysen: Sachen wie Aggregationen, Verknüpfungen und Filter laufen bei großen Datenmengen echt schneller.

In DuckDB wird die folgende Abfrage durch die spaltenorientierte Speicherung und die vektorisierte Verarbeitung beschleunigt, was sie deutlich schneller macht.

SELECT region, AVG(amount)
FROM sales
GROUP BY region;

3. In-Process-Datenbankarchitektur

Zu guter Letzt sind SQLite und DuckDB eingebettete Datenbanken, was bedeutet, dass sie innerhalb des Prozesses der Host-Anwendung laufen und nicht als separater Datenbankserver.

Diese Architektur macht Schluss mit Netzwerkverzögerungen, macht die Bereitstellung einfacher und reduziert den Aufwand für die Verwaltung externer Dienste.

Das macht sie zu:

• Einfach zu verteilen
• Einfach einzusetzen
• Geringe Latenz (kein Client-Server-Overhead)

SQLite 

SQLite hat die Idee einer „serverlosen“ Datenbank ins Leben gerufen. Das heißt, deine Apps sind direkt mit der Bibliothek verbunden und alle Abfragen laufen direkt in der App ab.

DuckDB 

DuckDB hat ein ähnliches In-Process-Design, nutzt es aber für analytische Sachen.

Um den Aufwand für das Hochfahren externer Analyse-Engines zu vermeiden, nutzt DuckDB Data-Science-Umgebungen (Python, R oder sogar Jupyter-Notebooks), indem es Abfragen darin ausführt.

DuckDB vs. SQLite – Leistungsanalyse und Benchmarking

Die Leistung ist einer der wichtigsten Unterschiede zwischen DuckDB und SQLite. Beide sind zwar eingebettete Datenbanken, aber wie sie sich bei unterschiedlichen Arbeitslasten verhalten, hängt davon ab, was bei ihrer Entwicklung im Vordergrund stand. 

Im Allgemeinen ist SQLite super für Transaktionsanwendungen, während DuckDB in analytischen Sachen gut abschneidet.

1. Analytische Abfrageleistung

DuckDB:

• Besser als SQLite bei Aggregationen, Verknüpfungen und Gruppierungen.
• Kann Parquet-/Arrow-Dateien direkt abfragen.
• DuckDB ist für die Ausführung analytischer Abfragen gemacht und ist bei der Verarbeitung großer Datensätze meistens besser als SQLite.

Schauen wir mal, wie man das mit einer Aggregationsabfrage testen kann.

Angenommen, wir haben einen Datensatz mit Verkaufsdaten (sales.csv) mit 10 Millionen Zeilen, die folgende Werte enthalten: order_id, customer_id, amount und date.

SQLite (Python):

Um diese Abfrage in SQLite mit Python auszuführen, müssen wir die CSV-Datei in ein DataFrame laden, sie in eine Datenbank mit einer „ SQLite3 “-Verbindung einlesen und unsere SQL-Abfrage darin ausführen.

Hier ist ein Beispiel für einen Code:

import sqlite3
import pandas as pd

# Load CSV into SQLite
df = pd.read_csv("sales.csv")
conn = sqlite3.connect("sales.db")
df.to_sql("sales", conn, if_exists="replace", index=False)

# Run a GROUP BY query directly on the imported table
cursor = conn.execute("""
    SELECT customer_id, SUM(amount) AS total_spent
    FROM sales
    GROUP BY customer_id
    ORDER BY total_spent DESC
    LIMIT 5
""")
print(cursor.fetchall())

DuckDB (Python):

Um eine ähnliche Abfrage mit DuckDB in Python zu machen, braucht man weniger Schritte. Ein Datenrahmen ist nicht nötig.

Hier ist ein Beispiel für einen Code:

import duckdb

con = duckdb.connect()
# Run a GROUP BY query directly on the CSV file
result = con.execute(""" SELECT customer_id, SUM(amount) AS total_spent FROM read_csv_auto('sales.csv') GROUP BY customer_id ORDER BY total_spent DESC LIMIT 5 """).fetchdf()
print(result)

2. Leistung bei Transaktions-Workloads

Was die Transaktionsauslastung angeht, hat jede Datenbank ihre eigenen Anwendungsfälle.

SQLite ist super für transaktionsintensive Punktabfragen. Es macht häufig vorkommende INSERT-, UPDATE- und DELETE-Operationen mit echt geringem Aufwand und ist damit super für eingebettete Transaktionssysteme.

SQLite macht Massen-Einfügungen mit Transaktionen richtig gut und läuft super, wenn man oft kleine Aktualisierungen machen muss.

DuckDB konzentriert sich dagegen mehr auf analytische Abfragen nach der Datenerfassung als auf hochfrequente Transaktionsaktualisierungen.

3. Skalierbarkeit und Ressourcennutzung

SQLite

SQLite ist leicht und wird oft für kleine bis mittlere Datensätze benutzt. Eine einzelne Abfrage läuft auf einem Thread und SQLite nutzt ein Single-Writer-Modell mit gleichzeitigen Lesevorgängen; es parallelisiert keine einzelnen SELECT-Anfragen, was den analytischen Durchsatz einschränken kann.

DuckDB

DuckDB kann mit Multi-Core-Parallelität und Abfragen, die größer als der Arbeitsspeicher sind, umgehen. Es skaliert durch parallele Ausführung und kann bei Bedarf auf die Festplatte ausgelagert werden, was Out-of-Core-Analysen ermöglicht.

Dadurch kann es Datensätze analysieren, die den Systemspeicher weit übersteigen, und trotzdem eine Leistung beibehalten, die der Ausführung im Arbeitsspeicher nahekommt.

4. Dateiformat und I/O-Leistung

SQLite

SQLite speichert Daten in seinem eigenen zeilenbasierten Format, das zwar portabel und stabil ist, aber nicht direkt mit modernen Analyseformaten zusammenarbeitet. Daten müssen oft erst in SQLite importiert werden, bevor Abfragen laufen können, was zusätzlichen I/O-Overhead verursacht.

DuckDB

DuckDB unterstützt von Haus aus mehrere Dateiformate, wie Parquet, Arrow und CSV, sodass Daten direkt abgefragt werden können, ohne dass sie erst umgewandelt werden müssen (z. B. SELECT … FROM 'file.parquet').

Das spart ETL-Aufwand und macht die Analyse schneller, weil nur die benötigten Daten aus Spaltenformaten wie Parquet gelesen werden.

Datenaufnahme und Interoperabilität in DuckDB vs. SQLite

Datenbanken werden oft benutzt, um viele Daten zu speichern. Als Nächstes schauen wir uns an, wie sie in Sachen Datenaufnahme und Interoperabilität abschneiden.

1. Unterstützte Dateiformate und Import

DuckDB

DuckDB kann Parquet, Arrow und CSV direkt einlesen. Es kann SQL-Abfragen direkt auf Parquet ausführen, ohne es in eine Datenbankdatei zu importieren.

import duckdb

con = duckdb.connect()
result = con.execute("""
    SELECT customer_id, SUM(amount) AS total_spent
    FROM 'sales.parquet'
    GROUP BY customer_id
    ORDER BY total_spent DESC
    LIMIT 5
""").fetchdf()

print(result)

SQLite

SQLite braucht externe Daten in sein Speicherformat zu importieren, bevor Abfragen gemacht werden können.

import sqlite3
import pandas as pd

# Load CSV into pandas first
df = pd.read_csv("sales.csv")

# Store into SQLite
conn = sqlite3.connect("sales.db")
df.to_sql("sales", conn, if_exists="replace", index=False)

# Query the imported table
cursor = conn.execute("""
    SELECT customer_id, SUM(amount) AS total_spent
    FROM sales
    GROUP BY customer_id
    ORDER BY total_spent DESC
    LIMIT 5
""")

print(cursor.fetchall())

2. Integration mit Data-Science-Tools

DuckDB

DuckDB ist eng mit Pandas, R und Jupyter verbunden und lässt sich direkt in Pandas DataFrames integrieren, sodass du sie wie SQL-Tabellen behandeln kannst:

import duckdb
import pandas as pd

# Example pandas DataFrame
df = pd.DataFrame({
    "customer_id": [1, 2, 1, 3],
    "amount": [100, 200, 150, 300]
})

# Query DataFrame directly with DuckDB
result = duckdb.query("""
    SELECT customer_id, AVG(amount) as avg_spent
    FROM df
    GROUP BY customer_id
""").to_df()

print(result)

SQLite

SQLite läuft mit vielen Programmiersprachen, ist aber nicht so sehr auf Datenwissenschaft ausgerichtet.

Zum Beispiel kann SQLite auch mit Pandas zusammenarbeiten, aber meistens braucht man dafür mehr Boilerplate-Code.

import sqlite3
import pandas as pd

conn = sqlite3.connect(":memory:")
df = pd.DataFrame({
    "customer_id": [1, 2, 1, 3],
    "amount": [100, 200, 150, 300]
})

df.to_sql("sales", conn, index=False, if_exists="replace")

# Query back into pandas
query = "SELECT customer_id, AVG(amount) as avg_spent FROM sales GROUP BY customer_id"
result = pd.read_sql_query(query, conn)

print(result)

3. Sprachbindungen und APIs

SQLite

SQLite gibt's schon seit 2000, also sind seine Bindungen echt ausgereift. Weil es nur eine kleine C-Bibliothek ist, haben die meisten Sprachen offizielle oder Community-Unterstützung.

Einige Beispiele sind: C, Python (sqlite3), Java, PHP und mehr.

DuckDB

DuckDB ist viel neuer, wurde aber mit Blick auf Datenwissenschaft und Analyse-Workflows entwickelt. Es hat weniger Bindungen, ist aber super für die Datenwissenschaft geeignet.

Einige Beispiele sind: Python-, R-, C++- und JavaScript-Bindungen.

Anwendungsfälle und Anwendungsbereiche

Obwohl sowohl SQLite als auch DuckDB leichte, eingebettete Datenbanken sind, haben sie ganz unterschiedliche Aufgaben. 

SQLite ist super für Transaktionen und Anwendungen, während DuckDB eher für Analysen in der Datenwissenschaft und Business Intelligence gemacht ist. In manchen Fällen können sie sich sogar gegenseitig ergänzen.

Schauen wir uns mal ein paar konkrete Beispiele an:

1. SQLite-Anwendungsszenarien

SQLite ist super leicht, was es perfekt macht für:

• Speicherplatz für mobile Apps: SQLite ist die Standarddatenbank für Android- und iOS-Apps und bietet dauerhaften lokalen Speicherplatz, ohne dass ein Server-Backend nötig ist.
• IoT-Geräte: Leichte IoT-Geräte nutzen oft SQLite, weil es wenig Speicherplatz braucht und man es nicht extra einrichten muss.
• Browser-Caching: SQLite wird oft als Cache-Schicht in verteilten Systemen oder als Zwischenspeicher beim Datenaustausch zwischen Systemen genutzt.

2. Analytische Anwendungen von DuckDB

DuckDB ist eng mit analytischen Abläufen wie ETL-Pipelines verbunden. Hier ist ein Beispiel, wie man das in Python machen kann.

Die DuckDB-Befehlszeilenschnittstelle benutzen:

-- Connect / create DB
ATTACH 'warehouse.duckdb' AS wh; USE wh;

-- EXTRACT: read a CSV
CREATE OR REPLACE VIEW v_orders AS
SELECT * FROM read_csv_auto('data/orders.csv');  -- order_id, customer_id, order_ts, status, amount

-- TRANSFORM: clean types + derive metrics
WITH cleaned AS (
  SELECT
    CAST(order_id AS BIGINT)              AS order_id,
    CAST(customer_id AS BIGINT)           AS customer_id,
    TRY_CAST(order_ts AS TIMESTAMP)       AS order_ts,
    COALESCE(NULLIF(status,''),'unknown') AS status,
    TRY_CAST(amount AS DOUBLE)            AS amount
  FROM v_orders
),
agg AS (
  SELECT DATE_TRUNC('day', order_ts) AS order_date,
         SUM(amount)                 AS daily_gmv,
         COUNT(*)                    AS orders
  FROM cleaned
  GROUP BY 1
)
-- LOAD: upsert curated tables + export parquet
CREATE TABLE IF NOT EXISTS fact_orders AS SELECT * FROM cleaned WHERE 1=0;
MERGE INTO fact_orders t USING cleaned s
ON t.order_id = s.order_id
WHEN MATCHED THEN UPDATE SET
  customer_id=s.customer_id, order_ts=s.order_ts, status=s.status, amount=s.amount
WHEN NOT MATCHED THEN INSERT VALUES
  (s.order_id, s.customer_id, s.order_ts, s.status, s.amount);

COPY agg TO 'warehouse/daily_gmv' (FORMAT PARQUET, PARTITION_BY (order_date), OVERWRITE_OR_IGNORE 1);

Jetzt startest du die Datei im Terminal:

duckdb -c ".read etl.sql"

Alternativ kannst du DuckDB auch in Python für einen optimierten Datenanalyse-Workflow nutzen.

import duckdb, pathlib
db = pathlib.Path("warehouse.duckdb")
con = duckdb.connect(str(db))

# EXTRACT
con.execute("""
CREATE OR REPLACE VIEW v_orders AS
SELECT * FROM read_csv_auto('data/orders.csv')
""")

# TRANSFORM
con.execute("""
CREATE OR REPLACE VIEW v_clean AS
SELECT CAST(order_id AS BIGINT) order_id,
       CAST(customer_id AS BIGINT) customer_id,
       TRY_CAST(order_ts AS TIMESTAMP) order_ts,
       COALESCE(NULLIF(status,''),'unknown') status,
       TRY_CAST(amount AS DOUBLE) amount
FROM v_orders
""")

# LOAD (table + parquet export)
con.execute("CREATE TABLE IF NOT EXISTS fact_orders AS SELECT * FROM v_clean WHERE 1=0")
con.execute("""
MERGE INTO fact_orders t USING v_clean s
ON t.order_id = s.order_id
WHEN MATCHED THEN UPDATE SET customer_id=s.customer_id, order_ts=s.order_ts, status=s.status, amount=s.amount
WHEN NOT MATCHED THEN INSERT VALUES (s.order_id, s.customer_id, s.order_ts, s.status, s.amount)
""")
con.execute("""
COPY (SELECT DATE_TRUNC('day', order_ts) AS order_date, SUM(amount) AS daily_gmv FROM fact_orders GROUP BY 1)
TO 'warehouse/daily_gmv' (FORMAT PARQUET, PARTITION_BY (order_date), OVERWRITE_OR_IGNORE 1)
""")

3. Hybride und ergänzende Szenarien

Analysiere SQLite-Daten in DuckDB:

DuckDB kann Daten direkt in einer SQLite-Datenbankdatei abfragen:

import duckdb

# Query a SQLite database via the sqlite_scanner extension
con = duckdb.connect()
con.install_extension("sqlite_scanner")
con.load_extension("sqlite_scanner")

result = con.execute("""
    SELECT customer_id, COUNT(*) AS orders
    FROM sqlite_scan('app_cache.db', 'orders')
    GROUP BY customer_id
    ORDER BY orders DESC
""").fetchdf()

print(result)

Leistung optimieren und Best Practices

Sowohl SQLite als auch DuckDB sind von Grund auf effizient, aber ihre Leistung kann stark variieren, je nachdem, wie Daten eingegeben, abgefragt und verwaltet werden.

1. Massen-Einfügungen und effiziente Datenverarbeitung

SQLite

Bei großen Datenmengen solltest du immer Transaktionen verwenden. Wenn du Zeilen einzeln ohne Transaktion einfügst, muss SQLite jede Zeile einzeln speichern, was die Leistung stark verlangsamt.

import sqlite3

conn = sqlite3.connect("perf.db")
cur = conn.cursor()
cur.execute("CREATE TABLE IF NOT EXISTS logs (id INTEGER, message TEXT)")

# Bulk insert with a single transaction
data = [(i, f"event {i}") for i in range(100000)]
cur.execute("BEGIN TRANSACTION;")
cur.executemany("INSERT INTO logs VALUES (?, ?)", data)
conn.commit()

Wenn du deine Daten wie im Beispiel oben gruppierst, wird die Leistung echt verbessert.

DuckDB

DuckDB kann große Datensätze super effizient verarbeiten, vor allem wenn sie aus externen Dateien kommen. Nutze „ COPY “-Befehle oder direkte Abfragen von Parquet/CSV für schnellere Pipelines.

import duckdb
con = duckdb.connect()
# Bulk load CSV into DuckDB
con.execute(""" CREATE OR REPLACE TABLE logs AS SELECT * FROM read_csv_auto('transactions.csv') """)

2. Techniken zur Abfrageoptimierung

SQLite: 

Um deine Abfragen besser zu optimieren, solltest du Indizes für Suchvorgänge nutzen.

CREATE INDEX idx_customer_id ON orders(customer_id);

Ich würde empfehlen, EXPLAIN QUERY PLAN zu nutzen, um Ausführungspfade zu analysieren und fehlende Indizes zu finden.

Generell solltest du versuchen, Abfragen einfach zu halten und unnötige Verknüpfungen in Umgebungen mit begrenzten Ressourcen zu vermeiden.

DuckDB

Für DuckDB kannst du Spaltenbeschneidung und Prädikat-Pushdown nutzen.

• Spaltenbeschneiden: DuckDB liest nur die Spalten, die deine Abfrage wirklich braucht. Das sorgt für weniger I/O und schnellere Scans – vor allem bei breiten Tabellen oder Parquet-Dateien.
• Prädikat-Pushdown: DuckDB schiebt deine WHERE-Filter runter in den Tabelle-/Dateiscan, damit es Zeilengruppen/Seiten/Dateien überspringen kann, die nicht passen. Dadurch werden viel weniger Bytes gelesen, indem Datei-/Partitionsstatistiken (z. B. Parquet min/max) genutzt werden.

Beispiel für das Kürzen von Spalten:

-- Only reads the 'user_id' and 'amount' columns; other columns aren’t touched
SELECT user_id, SUM(amount)
FROM read_parquet('events/*.parquet')
GROUP BY user_id;

Beispiel für Prädikat-Pushdown (Parquet):

-- Skips row groups/pages whose min/max(order_ts) are entirely outside this range
SELECT *
FROM read_parquet('events/dt=*/events.parquet')
WHERE order_ts >= TIMESTAMP '2025-09-01'
  AND order_ts <  TIMESTAMP '2025-10-01';

3. Wartung und Betrieb

• SQLite: Regelmäßige „ VACUUM “-Operationen, um Speicherplatz freizugeben. Für eingebettete Anwendungen solltest du auf ausreichend Festplatten-E/A achten und den WAL-Modus nutzen, um die Haltbarkeit und den gleichzeitigen Zugriff zu verbessern.
• DuckDB: Optimiert für Analysen; kaum Anpassungen nötig. Organisiere große Datensätze in partitionierte Parquet-Dateien, um die Vorteile von Partition Pruning zu nutzen.Führe regelmäßig Benchmarks für Abfragen anhand von Beispiel-Workloads durch, um die Parallelitätseinstellungen (über PRAGMA-Threads) zu optimieren.

Entwicklung, Integration und Ökosystem

Datenbanken müssen gut integriert sein, damit man leicht auf die Daten zugreifen kann. Jetzt schauen wir uns an, wie jede Datenbank mit anderen Systemen zusammenarbeitet.

1. Unterstützung von Programmiersprachen und APIs

• SQLite: Breite Sprachunterstützung. Bietet eine der umfangreichsten Auswahlen an Sprachbindungen in der Datenbankwelt. Es gibt offizielle und von der Community gepflegte Treiber für Python, Java, C#, C/C++, PHP, Go, Ruby, Rust und mehr als 30 weitere Sprachen.
• DuckDB: Starke Datenwissenschaft-Integrationen. Konzentriert sich auf datenwissenschaftliche Bindungen: offizielle Unterstützung für Python, R und C/C++.

2. Integration von Datenwissenschaft und Analytik

DuckDB: Arbeitet direkt mit Pandas-DataFrames.

Beispiel:

import duckdb 
import pandas as pd

df = pd.DataFrame({"x": [1,2,3], "y": [10,20,30]})
duckdb.query("SELECT AVG(y) FROM df").show()

DuckDB unterstützt auch benutzerdefinierte Funktionen (UDFs) in SQL und Python, was fortgeschrittene Analysen und individuelle Transformationen ermöglicht.

Beispiel (Python-UDF in DuckDB):

import duckdb
import math

con = duckdb.connect()

# Register a Python function as UDF
con.create_function("sqrt_plus", lambda x: math.sqrt(x) + 1)

result = con.execute("SELECT sqrt_plus(16)").fetchall()
print(result)  # [(5.0,)]

3. Cloud- und Infrastruktur-Integration

SQLite

SQLite ist eine lokale Datenbank, die vor allem für den lokalen, eingebetteten Speicher gedacht ist.

Es wird in Cloud-nativen Anwendungen als leichte Persistenzschicht oder Cache genutzt, meistens in Containern. Auch wenn es keine direkten Cloud-Speicher-Anbindungen gibt, sind SQLite-Datenbanken portabel und lassen sich leicht zwischen verschiedenen Umgebungen übertragen.

DuckDB

DuckDB wird immer öfter in der Cloud eingesetzt (Abfragen von S3-Parquet-Dateien), weil es für moderne Datenarchitekturen optimiert ist.

Es bietet auch native Unterstützung für die Abfrage von Cloud-Speicherformaten wie Parquet- und Arrow-Dateien auf AWS S3, Azure Blob Storageoder Google Cloud Storage.

DuckDB passt super in Serverless-Analytics-Szenarien, wo Daten in Objektspeichern abgelegt und bei Bedarf abgefragt werden, ohne dass ein schwerfälliges Warehouse nötig ist.

Einschränkungen und Kompromisse

Trotz ihrer Stärken haben sowohl DuckDB als auch SQLite gewisse Einschränkungen, die mit ihrer Designphilosophie zusammenhängen. 

• Einschränkungen bei Parallelität und Skalierbarkeit:
  • SQLite: Begrenzte Schreibkonkurrenz.
  • DuckDB: Einzelprozess-Parallelitätsmodell.
• Einschränkungen beim Speicher- und Ressourcenmanagement:
  • SQLite: Leicht, aber nicht für richtig große Datensätze geeignet.
  • DuckDB: Kann auf die Festplatte kopiert werden, ist aber nicht für die Transaktionsbeständigkeit in großem Maßstab ausgelegt.
• Funktions- und Leistungslücken:
  • SQLite: Eingeschränkte Analysefunktionen.
  • DuckDB: Eingeschränkte Transaktionsrobustheit.
• Leistungskompromisse und Einschränkungen:
  • SQLite: Schnell für Transaktionen, langsam für Analysen.
  • DuckDB: Schnell für Analysen, langsamer für kleine Schreibvorgänge.

SQLite vs. DuckDB – Abschließende Gedanken

DuckDB und SQLite haben beide wichtige, aber unterschiedliche Aufgaben:

• Entscheide dich für SQLite, wenn du eine einfache, schlanke Transaktionsdatenbank für Apps und eingebettete Systeme brauchst.
• Entscheide dich für DuckDB, wenn du leistungsstarke Analysen direkt in deinen Python/R-Workflows brauchst.

In vielen Fällen ergänzen sie sich gegenseitig: SQLite für die Speicherung und Transaktionen, DuckDB für analytische Abfragen auf diesen Daten. Die richtige Wahl hängt davon ab, ob du mehr OLTP (Transaktionen) oder OLAP (Analysen) machst.

Willst du mehr über Datenbanken wie DuckDB und SQLite erfahren? Schau dir unser Einsteigerhandbuch zum SQLite-Tutorial und unsere Einführung in DuckDB SQL Code-Along-Tutorial an.