DuckDB vs SQLite: Perbandingan Database Lengkap

Dalam pengelolaan data modern, database tertanam yang ringan berperan penting dalam mendukung aplikasi, alur kerja, dan analitik. Dua sistem yang sering dibandingkan adalah DuckDB dan SQLite. 

Keduanya adalah database tertanam, tetapi memiliki tujuan yang berbeda: SQLite unggul untuk beban kerja transaksional, sedangkan DuckDB dioptimalkan untuk kueri analitik.

Dalam artikel perbandingan ini, kita akan melihat bagaimana kedua database ini berbeda satu sama lain.

Sekilas: DuckDB vs SQLite

Berikut tabel perbandingan yang menunjukkan persamaan dan perbedaan antara DuckDB dan SQLite. Untuk detail lengkap, lihat penjelasan sepanjang artikel ini. 

Apa Itu SQLite?

SQLite adalah salah satu database yang paling banyak digunakan di dunia. Dirilis pada tahun 2000, SQLite dirancang sebagai mesin database SQL yang ringan dan tanpa server (serverless).

Berikut beberapa fitur utamanya:

• Mandiri dan tanpa server
• Penyiapan tanpa konfigurasi
• Sepenuhnya sesuai ACID
• Penyimpanan berorientasi baris

Karena arsitekturnya yang ringan, SQLite dapat digunakan pada skenario berikut:

• Aplikasi seluler (Android, iOS)
• Perangkat lunak desktop
• Sistem tertanam seperti perangkat IoT

Kekuatan utama SQLite terletak pada kesederhanaan dan keandalannya. Pengembang dapat menyertakan satu basis data berbasis file bersama aplikasinya tanpa perlu khawatir tentang dependensi eksternal.

Apa Itu DuckDB?

DuckDB sering disebut sebagai SQLite untuk analitik. Diperkenalkan pada 2019, DuckDB dikembangkan di CWI. Tujuan utama penggunaan DuckDB adalah memiliki solusi database OLAP di dalam proses (in-process).

Berikut beberapa fitur utamanya:

• Format penyimpanan kolumnar
• Dioptimalkan untuk beban kerja OLAP
• Eksekusi kueri tervektor
• Desain tertanam dalam proses
• Dukungan langsung untuk format file seperti Parquet dan Arrow

Beberapa use case tipikal meliputi:

• Analitik interaktif
• Alur kerja ilmu data (Python, R, Jupyter)
• Pipeline ETL yang ringan

Poin kunci menggunakan DuckDB adalah ia menghadirkan kekuatan database analitik (seperti Snowflake atau BigQuery) dalam paket tertanam.

DuckDB vs SQLite: Perbedaan dan Persamaan Utama

1. Instalasi dan dependensi

SQLite

SQLite terkenal tanpa dependensi. Ia dikompilasi menjadi satu pustaka C yang dapat dibundel ke hampir semua aplikasi.

Instalasi minimal dan dapat diunduh langsung dari situs web SQLite.

Portabilitas adalah salah satu kekuatan terbesarnya: bekerja sama di Windows, macOS, Linux, iOS, dan Android dengan hampir tanpa usaha tambahan.

DuckDB

DuckDB juga mudah dipasang, tetapi didistribusikan sebagai biner terpisah atau paket Python/R alih-alih terpasang universal sebelumnya.

Ia memiliki beberapa dependensi tambahan, terutama saat mengaktifkan integrasi dengan Apache Arrow, Parquet, atau Pandas.

Jejaknya tetap kecil, namun dibandingkan SQLite, DuckDB memerlukan sedikit lebih banyak penyiapan jika Anda menginginkan fungsi lanjutan seperti konektor penyimpanan cloud atau integrasi alat data science.

2. Format penyimpanan dan arsitektur

SQLite 

Menyimpan data dalam format berbasis baris, dioptimalkan untuk tugas OLTP (Online Transaction Processing) seperti insert, update, dan delete.

Pengambilan satu baris penuh cepat, tetapi kueri analitik yang hanya memindai beberapa kolom di jutaan baris bisa menjadi lambat karena data yang tidak perlu ikut dibaca.

DuckDB

DuckDB menggunakan mesin penyimpanan kolumnar, dibuat khusus untuk OLAP (Online Analytical Processing).

Format kolumnar berarti kueri yang melakukan agregasi pada dataset besar (mis., AVG(sales) atau COUNT(*)) jauh lebih cepat karena hanya kolom yang relevan yang dibaca ke memori.

Juga memungkinkan kompresi yang lebih baik dan eksekusi tervektor untuk kecepatan.

Contoh: Kueri SELECT * FROM sales WHERE customer_id=123 berjalan lebih cepat di SQLite, sedangkan SELECT AVG(amount) FROM sales GROUP BY region jauh lebih cepat di DuckDB.

3. Beban kerja transaksional vs analitik

Kedua database juga berbeda dalam beban kerjanya:

• OLTP (Transaksional): Operasi singkat dan sering (mis., aplikasi perbankan, profil pengguna, sistem point-of-sale). Prioritasnya adalah latensi rendah, integritas data, dan akses konkuren.
• OLAP (Analitik): Kueri kompleks atas dataset besar (mis., dashboard, alat BI, analisis data ad-hoc). Prioritasnya adalah throughput, performa pemindaian, dan kecepatan agregasi.

SQLite

SQLite dioptimalkan untuk OLTP (insert, update, delete, point lookup).

Sebagai contoh:

• Aplikasi seluler yang menyimpan data offline.
• Perangkat IoT yang mencatat interaksi pengguna.
• Cache lokal dalam aplikasi desktop.

DuckDB

DuckDB dioptimalkan untuk OLAP (agregasi, join, scan).

Sebagai contoh:

• Data scientist menjalankan agregasi pada file Parquet/CSV.
• Dashboard BI interaktif yang merangkum jutaan baris.
• Pipeline ETL/ELT yang membutuhkan transformasi ringan di memori.

4. Dukungan dan Sintaks SQL

Selanjutnya, mari lihat sintaks SQL mereka. Keduanya mengimplementasikan sebagian besar standar SQL dengan ekstensi; tidak ada yang sepenuhnya sesuai ANSI.

SQLite

• Mendukung porsi besar standar SQL tetapi menghilangkan konstruksi analitik tingkat lanjut.
• Sangat baik untuk operasi CRUD dan join yang lebih sederhana.
• Mendukung fungsi jendela dan CTE, tetapi kurang pada fitur analitik yang lebih maju seperti GROUPING SETS dan beberapa ekstensi agregat.

Berikut tampilan sintaksnya:

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

DuckDB

• Lebih dekat dengan kepatuhan ANSI SQL, dengan dukungan kuat untuk fungsi jendela, CTE, agregasi, dan operasi himpunan.
• Dirancang agar terasa seperti PostgreSQL ringan untuk analitik.
• Integrasi dengan Arrow dan Pandas memungkinkan menjalankan SQL langsung pada dataset eksternal tanpa perlu impor terlebih dahulu.

Berikut contoh serupa bagaimana sintaks untuk DuckDB:

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

SQLite vs DuckDB: Arsitektur Fundamental dan Falsafah Desain

Dalam hal arsitektur fundamental, SQLite dan DuckDB sama-sama database tertanam dalam proses. Namun, falsafah desain mereka berbeda. 

SQLite memprioritaskan kesederhanaan dan keandalan transaksional, sementara DuckDB dioptimalkan untuk beban kerja analitik dan integrasi ilmu data modern.

1. Arsitektur penyimpanan

Pertama, kedua database berbeda dalam arsitektur penyimpanannya.

SQLite

SQLite berbasis baris, yang sangat baik untuk akses transaksional. Artinya seluruh baris disimpan bersama di disk.

Desain ini menguntungkan beban kerja transaksional (OLTP) karena menyisipkan, memperbarui, atau mengambil satu catatan biasanya hanya membutuhkan akses ke satu baris.

Aplikasi yang membutuhkan akses cepat dan konsisten ke catatan individual, seperti profil pengguna atau detail pesanan, akan berjalan efisien dalam model ini.

DuckDB

DuckDB mengadopsi format kolumnar, yang dirancang untuk memindai miliaran baris dengan cepat. Format kolumnar berarti mengelompokkan nilai dalam kolom yang sama bersama-sama di disk dan memori.

Penyimpanan kolumnar memungkinkan kueri analitik (OLAP) yang sangat efisien, karena agregasi, filter, dan pemindaian sering kali hanya memerlukan akses ke subset kolom.

Teknik kompresi lebih efektif diterapkan pada kolom, mengurangi penggunaan memori dan penyimpanan sekaligus meningkatkan performa pemindaian.

2. Metodologi pemrosesan kueri

Selanjutnya, kita perlu melihat bagaimana masing-masing memproses kueri.

Secara umum, model SQLite disetel untuk kesederhanaan dan ketepatan transaksional, sementara mesin tervektor DuckDB direkayasa untuk throughput dan performa analitik.

SQLite

SQLite menggunakan model tradisional berbasis iterator, memproses satu baris pada satu waktu melalui pipeline kueri.

Pendekatan eksekusi per-baris ini ringan dan selaras dengan beban kerja transaksional, di mana kueri sering melibatkan dataset kecil dan insert atau update yang sering.

Namun, bottleneck performa muncul saat kueri harus memindai dataset besar, karena evaluasi per-baris menambah overhead.

DuckDB

DuckDB menggunakan eksekusi kueri tervektor, memproses batch baris (vektor) sekaligus alih-alih satu per satu.

Pendekatan ini meminimalkan overhead CPU, memaksimalkan penggunaan cache CPU modern, dan memungkinkan paralelisme SIMD (Single Instruction, Multiple Data).

Eksekusi tervektor sangat menguntungkan untuk analitik: operasi seperti agregasi, join, dan filter berjalan jauh lebih cepat pada volume data besar.

Di DuckDB, kueri berikut mendapat manfaat dari penyimpanan kolumnar dan pemrosesan tervektor, sehingga jauh lebih cepat.

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

3. Arsitektur database dalam proses

Terakhir, SQLite dan DuckDB adalah database tertanam, artinya berjalan di dalam proses aplikasi host, bukan sebagai server database terpisah.

Arsitektur ini menghilangkan latensi jaringan, menyederhanakan deployment, dan mengurangi beban operasional dalam mengelola layanan eksternal.

Hal ini membuat keduanya:

• Mudah didistribusikan
• Mudah di-deploy
• Latensi rendah (tanpa overhead klien-server)

SQLite 

SQLite memelopori gagasan sebagai database “tanpa server”. Ini berarti aplikasi Anda menautkan langsung ke pustakanya, dan semua kueri dieksekusi di dalam aplikasi itu sendiri.

DuckDB 

DuckDB mengikuti desain dalam proses yang serupa tetapi menerapkannya pada konteks analitik.

Untuk menghindari overhead menjalankan mesin analitik eksternal, DuckDB memanfaatkan lingkungan ilmu data (Python, R, atau bahkan notebook Jupyter) dengan menjalankan kueri di dalamnya.

Analisis Performa dan Benchmarking DuckDB vs SQLite

Performa adalah salah satu pembeda terpenting antara DuckDB dan SQLite. Meskipun keduanya adalah database tertanam, prioritas desain mereka memengaruhi perilaku di berbagai beban kerja. 

Secara umum, SQLite memiliki performa kuat untuk use case transaksional, sementara DuckDB unggul dalam konteks analitik.

1. Performa kueri analitik

DuckDB:

• Mengungguli SQLite untuk agregasi, join, group-by.
• Dapat mengkueri file Parquet/Arrow secara langsung.
• DuckDB dibangun untuk eksekusi kueri analitik, dan secara rutin mengungguli SQLite saat memproses dataset besar.

Mari lihat bagaimana ini dapat diuji melalui kueri agregasi.

Misalkan kita memiliki dataset penjualan (sales.csv) dengan 10 juta baris berisi order_id, customer_id, amount, dan date.

SQLite (Python):

Untuk menjalankan kueri ini di SQLite menggunakan Python, kita perlu memuat CSV ke dalam dataframe lalu menuliskannya ke koneksi database SQLite3, dan menjalankan kueri SQL di dalamnya.

Berikut contoh kodenya:

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

Untuk menjalankan kueri serupa menggunakan DuckDB di Python, langkahnya lebih sedikit. Dataframe tidak diperlukan.

Berikut contoh kodenya:

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. Performa beban kerja transaksional

Dalam beban kerja transaksional, masing-masing database memiliki use case yang khas.

SQLite dioptimalkan untuk beban kerja transaksi dan kueri titik (point-query). Ia menangani operasi INSERT, UPDATE, dan DELETE yang sering dengan overhead sangat rendah, menjadikannya ideal untuk sistem transaksional tertanam.

SQLite mendukung insert massal secara efisien menggunakan transaksi dan berkinerja baik saat pembaruan kecil diperlukan secara sering.

Sebaliknya, DuckDB berfokus pada kueri analitik setelah data diambil, bukan pada pembaruan transaksional berfrekuensi tinggi.

3. Skalabilitas dan pemanfaatan sumber daya

SQLite

SQLite ringan dan sering digunakan untuk dataset kecil hingga menengah. Satu kueri dijalankan pada satu thread dan SQLite menggunakan model satu penulis dengan pembacaan konkuren; ia tidak memparalelkan satu SELECT, yang dapat membatasi throughput analitik.

DuckDB

DuckDB mendukung paralelisme multi-core dan kueri yang lebih besar dari memori. Ia menskalakan dengan memanfaatkan eksekusi paralel dan dapat spill ke disk saat diperlukan, memungkinkan analitik out-of-core

Ini memungkinkannya menganalisis dataset yang jauh melebihi memori sistem sambil mempertahankan performa yang mendekati eksekusi di memori.

4. Format file dan performa I/O

SQLite

SQLite menyimpan data dalam format proprietary berbasis baris, yang portabel dan stabil tetapi kurang interoperabilitas langsung dengan format analitik modern. Data sering perlu diimpor ke SQLite sebelum kueri dapat dijalankan, menambah overhead I/O.

DuckDB

DuckDB secara native mendukung banyak format file, termasuk Parquet, Arrow, dan CSV, memungkinkannya mengkueri data secara langsung tanpa konversi (misalnya, SELECT … FROM 'file.parquet').

Ini menghilangkan overhead ETL dan mempercepat analitik dengan hanya membaca data yang diperlukan dari format kolumnar seperti Parquet.

Ingesti Data dan Interoperabilitas pada DuckDB vs SQLite

Database umum digunakan untuk mengimpor (ingest) data dalam jumlah besar. Selanjutnya, kita akan melihat bagaimana masing-masing unggul dalam kemampuan ingesti dan interoperabilitas.

1. Format file yang didukung dan ingesti

DuckDB

DuckDB menawarkan ingesti native untuk Parquet, Arrow, dan CSV. Ia dapat menjalankan kueri SQL langsung pada Parquet tanpa mengimpornya ke dalam file database.

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 memerlukan impor data eksternal ke format penyimpanannya sebelum kueri dapat dijalankan.

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. Integrasi dengan alat ilmu data

DuckDB

DuckDB memiliki integrasi erat dengan pandas, R, dan Jupyter, serta terintegrasi langsung dengan pandas DataFrame, memungkinkan Anda memperlakukannya seperti tabel SQL:

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 bekerja dengan banyak bahasa pemrograman, tetapi kurang berpusat pada ilmu data.

Sebagai contoh, SQLite juga dapat berinteraksi dengan pandas, tetapi biasanya membutuhkan boilerplate lebih banyak.

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. Binding bahasa dan API

SQLite

SQLite telah ada sejak 2000, sehingga binding-nya sangat matang. Karena hanya pustaka C kecil, sebagian besar bahasa memiliki dukungan resmi atau komunitas.

Beberapa contohnya: C, Python (sqlite3), Java, PHP, dan lainnya.

DuckDB

DuckDB jauh lebih muda, namun dirancang dengan alur kerja data science + analitik. Binding-nya lebih sedikit tetapi sangat ramah untuk ilmu data.

Beberapa contohnya: Python, R, C++, binding JavaScript.

Use Case dan Domain Aplikasi

Meskipun SQLite dan DuckDB sama-sama database tertanam yang ringan, keduanya melayani tujuan yang sangat berbeda. 

SQLite unggul dalam konteks aplikasi tingkat transaksional, sementara DuckDB dioptimalkan untuk beban kerja analitik dalam ilmu data dan business intelligence. Dalam beberapa kasus, keduanya bahkan dapat saling melengkapi.

Mari lihat beberapa contoh spesifik di bawah ini:

1. Skenario aplikasi SQLite

SQLite sangat ringan, sehingga sangat cocok untuk:

• Penyimpanan aplikasi seluler: SQLite adalah database default untuk aplikasi Android dan iOS, menyediakan penyimpanan lokal persisten tanpa memerlukan backend server.
• Perangkat IoT: Perangkat IoT ringan sering mengandalkan SQLite karena jejaknya minimal dan tidak memerlukan konfigurasi.
• Caching peramban: SQLite umum digunakan sebagai lapisan cache dalam sistem terdistribusi atau sebagai penyimpanan perantara saat mentransfer data antar sistem.

2. Aplikasi analitik DuckDB

DuckDB sangat terkait dengan alur kerja analitik seperti pipeline ETL. Berikut contoh bagaimana ia dapat diimplementasikan dalam Python.

Menggunakan DuckDB CLI:

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

Sekarang jalankan file di terminal:

duckdb -c ".read etl.sql"

Sebagai alternatif, Anda juga dapat menggunakan DuckDB di dalam Python untuk alur kerja analitik data yang lebih ringkas.

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. Skenario hibrida dan saling melengkapi

Menganalisis data SQLite di DuckDB:

DuckDB dapat langsung mengkueri data di dalam file database SQLite:

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)

Optimalisasi Performa dan Praktik Terbaik

Baik SQLite maupun DuckDB efisien secara desain, tetapi performanya dapat sangat bervariasi bergantung pada cara data diimpor, diquery, dan dipelihara.

1. Insert massal dan penanganan data efisien

SQLite

Untuk pemuatan data besar, selalu gunakan transaksi. Menyisipkan baris satu per satu tanpa transaksi memaksa SQLite melakukan commit tiap baris secara individual, memperlambat performa secara drastis.

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

Melakukan batching data seperti contoh di atas meningkatkan performa secara signifikan.

DuckDB

DuckDB menangani ingesti dataset besar secara efisien, terutama dari file eksternal. Gunakan perintah COPY atau kueri langsung ke Parquet/CSV untuk pipeline yang lebih cepat.

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. Teknik optimalisasi kueri

SQLite: 

Untuk optimalisasi kueri yang lebih baik, gunakan indeks untuk lookup.

CREATE INDEX idx_customer_id ON orders(customer_id);

Saya menyarankan menggunakan EXPLAIN QUERY PLAN untuk menganalisis jalur eksekusi dan mengidentifikasi indeks yang hilang juga.

Secara umum, usahakan kueri tetap sederhana dan hindari join yang tidak perlu di lingkungan dengan sumber daya terbatas.

DuckDB

Untuk DuckDB, Anda dapat memanfaatkan column pruning dan predicate pushdown.

• Column pruning: DuckDB hanya membaca kolom yang benar-benar dibutuhkan kueri Anda. Ini menghasilkan I/O lebih sedikit, pemindaian lebih cepat—terutama pada tabel lebar atau file Parquet.
• Predicate pushdown: DuckDB mendorong filter WHERE ke tahap pemindaian tabel/file sehingga dapat melewati grup baris/halaman/file yang pasti tidak cocok. Ini membuat pembacaan jauh lebih sedikit byte dengan menggunakan statistik file/partisi (mis., min/maks Parquet).

Contoh column pruning:

-- 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;

Contoh predicate 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. Pertimbangan perawatan dan operasional

• SQLite: Operasi VACUUM rutin untuk mereklamasi ruang. Untuk aplikasi tertanam, pastikan I/O disk memadai dan gunakan mode WAL untuk daya tahan dan akses konkuren yang lebih baik.
• DuckDB: Dioptimalkan untuk analitik; penyetelan minimal diperlukan. Susun dataset besar ke dalam file Parquet terpartisi untuk memanfaatkan pruning partisi.Secara berkala benchmark kueri terhadap beban kerja contoh untuk menyetel pengaturan paralelisme (melalui PRAGMA threads).

Pengembangan, Integrasi, dan Ekosistem

Database perlu terintegrasi dengan baik agar data dapat diakses dengan mudah. Sekarang kita akan melihat bagaimana masing-masing database berintegrasi dengan sistem lain.

1. Dukungan bahasa pemrograman dan API

• SQLite: Dukungan bahasa yang luas. Menawarkan salah satu jangkauan binding bahasa terluas di dunia database. Driver resmi dan komunitas tersedia untuk Python, Java, C#, C/C++, PHP, Go, Ruby, Rust, dan lebih dari 30 lainnya.
• DuckDB: Integrasi ilmu data yang kuat. Berfokus pada binding berorientasi ilmu data: dukungan resmi untuk Python, R, dan C/C++.

2. Integrasi ilmu data dan analitik

DuckDB: Bekerja langsung dengan pandas DataFrame.

Contoh:

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 juga mendukung user-defined function (UDF) dalam SQL dan Python, memungkinkan analitik lanjutan dan transformasi kustom.

Contoh (UDF Python di 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. Integrasi cloud dan infrastruktur

SQLite

SQLite adalah database yang mengutamakan lokal, terutama dirancang untuk penyimpanan lokal tertanam.

Ia digunakan dalam aplikasi cloud-native sebagai lapisan persistensi ringan atau cache, sering kali di dalam container. Meskipun tidak memiliki konektor penyimpanan cloud langsung, database SQLite bersifat portabel dan mudah dipindahkan lintas lingkungan.

DuckDB

DuckDB semakin diadopsi di cloud (mengkueri file Parquet di S3) karena optimal untuk arsitektur data modern.

Ia juga menawarkan dukungan native untuk mengkueri format penyimpanan cloud seperti file Parquet dan Arrow di AWS S3, Azure Blob Storage, atau Google Cloud Storage.

DuckDB sangat cocok untuk skenario analitik serverless, di mana data disimpan di object storage dan diquery on-demand tanpa memerlukan gudang data yang berat.

Keterbatasan dan Trade-Off

Terlepas dari kekuatannya, baik DuckDB maupun SQLite memiliki keterbatasan yang melekat pada falsafah desain mereka. 

• Keterbatasan Konkruensi dan Skalabilitas:
  • SQLite: Konkruensi penulisan terbatas.
  • DuckDB: Model konkruensi satu proses.
• Keterbatasan Memori dan Manajemen Sumber Daya:
  • SQLite: Ringan, tetapi tidak dapat diskalakan ke dataset yang sangat besar.
  • DuckDB: Dapat spill ke disk, tetapi tidak dirancang untuk ketahanan transaksional skala besar.
• Kesenjangan Fitur dan Fungsionalitas:
  • SQLite: Fitur analitik terbatas.
  • DuckDB: Ketangguhan transaksional terbatas.
• Trade-Off dan Keterbatasan Performa:
  • SQLite: Cepat untuk transaksi, lambat untuk analitik.
  • DuckDB: Cepat untuk analitik, lebih lambat untuk penulisan kecil.

SQLite vs DuckDB: Pemikiran Akhir

DuckDB dan SQLite sama-sama memiliki peran yang berharga namun berbeda:

• Pilih SQLite jika Anda memerlukan database transaksional yang sederhana dan ringan untuk aplikasi dan sistem tertanam.
• Pilih DuckDB jika Anda membutuhkan analitik berkinerja tinggi langsung di dalam alur kerja Python/R Anda.

Dalam banyak skenario, keduanya saling melengkapi: SQLite untuk penyimpanan dan transaksi, DuckDB untuk kueri analitik di atas data tersebut. Pilihan yang tepat bergantung pada apakah beban kerja Anda lebih bersifat OLTP (transaksi) atau OLAP (analitik).

Ingin mengeksplorasi lebih lanjut tentang database seperti DuckDB dan SQLite? Lihat Panduan Pemula untuk SQLite dan tutorial Code-Along Pengantar DuckDB SQL kami.