DuckDB vs SQLite: Kapsamlı Bir Veritabanı Karşılaştırması

Günümüz veri yönetiminde, hafif gömülü veritabanları uygulamaları, iş akışlarını ve analitiği güçlendirmede kritik bir rol oynar. Sıklıkla karşılaştırılan iki sistem DuckDB ve SQLite’tır. 

Her ikisi de gömülü veritabanlarıdır ancak farklı amaçlara hizmet eder: SQLite işlemsel iş yüklerinde öne çıkarken, DuckDB analitik sorgular için optimize edilmiştir.

Bu karşılaştırma yazısında, iki veritabanının birbirinden nasıl ayrıştığına bakacağız.

Genel Bakış: DuckDB vs SQLite

DuckDB ve SQLite arasındaki benzerlikleri ve farkları gösteren bir karşılaştırma tablosu aşağıdadır. Tüm ayrıntılar için makale boyunca yer alan açıklamalara bakın. 

SQLite Nedir?

SQLite dünyanın en yaygın kullanılan veritabanlarından biridir. 2000 yılında yayınlanan SQLite, hafif, sunucusuz bir SQL veritabanı motoru olarak tasarlanmıştır.

Bazı temel özellikleri şunlardır:

• Kendine yeterli ve sunucusuz
• Sıfır yapılandırma kurulumu
• Tamamen ACID uyumlu
• Satır odaklı depolama

Hafif mimarisi sayesinde şu kullanım senaryolarında tercih edilir:

• Mobil uygulamalar (Android, iOS)
• Masaüstü yazılımları
• IoT cihazları gibi gömülü sistemler

SQLite’ın temel gücü sadelik ve güvenilirliktir. Geliştiriciler, harici bağımlılıklar konusunda endişelenmeden uygulamalarıyla tek dosyalık bir veritabanı gönderebilir.

DuckDB Nedir?

DuckDB genellikle analitik için SQLite olarak anılır. 2019’da tanıtılan DuckDB, CWI’de geliştirildi. DuckDB’nin kullanılmasındaki temel amaç, süreç içi bir OLAP veritabanı çözümüne sahip olmaktı.

Bazı temel özellikleri şunlardır:

• Sütun bazlı depolama formatı
• OLAP iş yükleri için optimize
• Vektörleştirilmiş sorgu yürütme
• Süreç içi gömülü tasarım
• Parquet ve Arrow gibi dosya formatlarına doğrudan destek

Tipik kullanım senaryoları şunlardır:

• Etkileşimli analitik
• Veri bilimi iş akışları (Python, R, Jupyter)
• Hafif ETL hatları

DuckDB’nin kullanılmasındaki kilit nokta, analitik veritabanlarının (Snowflake veya BigQuery gibi) gücünü gömülü bir paket içinde sunmasıdır.

DuckDB vs SQLite: Temel Farklar ve Benzerlikler

1. Kurulum ve bağımlılıklar

SQLite

SQLite efsanevi şekilde bağımlılıksızdır. Neredeyse her uygulamaya gömülebilen tek bir C kütüphanesine derlenir.

Kurulum asgaridir ve basitçe SQLite web sitesinden indirilebilir.

Taşınabilirlik en büyük güçlü yanlarından biridir: Windows, macOS, Linux, iOS ve Android’de neredeyse hiçbir ek çaba olmadan aynı şekilde çalışır.

DuckDB

DuckDB de kolay kurulabilir, ancak evrensel olarak önceden kurulu olmak yerine ayrı ikili dosyalar veya Python/R paketleri olarak dağıtılır.

Özellikle Apache Arrow, Parquet veya Pandas ile entegrasyonları etkinleştirirken birkaç ek bağımlılığı vardır.

Ayak izi hâlâ küçüktür, ancak bulut depolama bağlayıcıları veya veri bilimi aracı entegrasyonu gibi gelişmiş işlevler istiyorsanız SQLite’a kıyasla biraz daha fazla kurulum gerekir.

2. Depolama formatları ve mimari

SQLite 

Verileri, ekleme, güncelleme ve silme gibi OLTP (Çevrimiçi İşlem İşleme) görevleri için optimize edilmiş satır tabanlı bir formatta depolar.

Tam bir satırı getirmek hızlıdır, ancak milyonlarca satır arasında yalnızca birkaç sütunu tarayan analitik sorgular yavaşlayabilir çünkü gereksiz veri okunur.

DuckDB

DuckDB, OLAP (Çevrimiçi Analitik İşleme) için özel olarak oluşturulmuş sütun bazlı bir depolama motoru kullanır.

Sütun bazlı format, büyük veri kümeleri üzerinde toplama yapan sorguların (ör. AVG(sales) veya COUNT(*)) çok daha hızlı olmasını sağlar; çünkü yalnızca ilgili sütunlar belleğe alınır.

Ayrıca sıkıştırmayı ve hız için vektörleştirilmiş yürütmeyi de mümkün kılar.

Örnek: SELECT * FROM sales WHERE customer_id=123 sorgusu SQLite’ta daha hızlı çalışırken, SELECT AVG(amount) FROM sales GROUP BY region DuckDB’de çok daha hızlı çalışır.

3. İşlemsel ve analitik iş yükleri

İki veritabanı iş yükleri açısından da farklılık gösterir:

• OLTP (İşlemsel): Kısa ve sık işlemler (ör. bankacılık uygulamaları, kullanıcı profilleri, satış noktası sistemleri). Öncelikler düşük gecikme, veri bütünlüğü ve eşzamanlı erişimdir.
• OLAP (Analitik): Büyük veri kümeleri üzerinde karmaşık sorgular (ör. panolar, BI araçları, ad-hoc veri analizi). Öncelikler aktarım hızı, tarama performansı ve toplama hızıdır.

SQLite

SQLite, OLTP için optimize edilmiştir (ekleme, güncelleme, silme, noktasal sorgular).

Örneğin:

• Çevrimdışı veri depolayan mobil uygulamalar.
• Kullanıcı etkileşimlerini kaydeden IoT cihazları.
• Masaüstü uygulamalarında yerel önbellekler.

DuckDB

DuckDB, OLAP için optimize edilmiştir (toplamalar, birleştirmeler, taramalar).

Örneğin:

• Parquet/CSV dosyalarında toplamalar çalışan veri bilimcileri.
• Sorguların milyonlarca satırı özetlediği etkileşimli BI panoları.
• ETL/ELT hatları için hafif, bellek içi dönüşümler.

4. SQL Desteği ve Söz Dizimi

Şimdi SQL söz dizimlerine bakalım. Her ikisi de uzantılarla birlikte SQL standartlarının büyük bir alt kümesini uygular; hiçbiri tam anlamıyla ANSI uyumlu değildir.

SQLite

• SQL standardının büyük bir bölümünü destekler ancak gelişmiş analitik yapıları dışarıda bırakır.
• CRUD işlemleri ve daha basit birleştirmeler için idealdir.
• Pencere fonksiyonları ve CTE’leri destekler, ancak GROUPING SETS ve bazı toplu genişletmeler gibi daha ileri düzey analitik özellikler sınırlıdır.

Söz dizimi şu şekildedir:

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

DuckDB

• ANSI SQL uyumluluğuna çok daha yakındır; pencere fonksiyonları, CTE’ler, toplamalar ve küme işlemleri için güçlü destek sunar.
• Analitik için hafif bir PostgreSQL gibi hissettirecek şekilde tasarlanmıştır.
• Arrow ve Pandas ile entegrasyon, verileri önce içe aktarmadan doğrudan harici veri kümeleri üzerinde SQL çalıştırmayı sağlar.

DuckDB için benzer bir söz dizimi örneği:

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

SQLite vs DuckDB: Temel Mimari ve Tasarım Felsefesi

Temel mimari açısından, SQLite ve DuckDB her ikisi de gömülü, süreç içi veritabanlarıdır. Yine de tasarım felsefeleri farklıdır. 

SQLite, işlemsel sadelik ve güvenilirliği önceliklendirirken DuckDB, analitik iş yükleri ve modern veri bilimi entegrasyonu için optimize edilmiştir.

1. Depolama mimarisi

Öncelikle iki veritabanı depolama mimarilerinde farklılık gösterir.

SQLite

SQLite satır tabanlıdır; bu da işlemsel erişim için idealdir. Bu, tüm satırların diskte birlikte saklandığı anlamına gelir.

Bu tasarım, işlemsel iş yüklerine (OLTP) fayda sağlar çünkü tek bir kaydın eklenmesi, güncellenmesi veya alınması genellikle yalnızca bir satıra erişim gerektirir.

Bireysel kayıtlara hızlı ve tutarlı erişim gerektiren uygulamalar (ör. kullanıcı profilleri veya sipariş detayları) bu modelde verimli çalışır.

DuckDB

DuckDB, milyarlarca satırı hızla taramak üzere tasarlanmış sütun bazlı bir format benimser. Sütun bazlı format, aynı sütunun değerlerini disk ve bellekte bir araya getirir.

Sütun bazlı depolama, toplamalar, filtreler ve taramaların genellikle yalnızca sütunların bir alt kümesine erişim gerektirmesi nedeniyle analitik sorguları (OLAP) son derece verimli hale getirir.

Sıkıştırma teknikleri sütunlar arasında daha etkili uygulanır; bu da bellek ve depolama kullanımını azaltırken tarama performansını artırır.

2. Sorgu işleme yöntemleri

Sırada her birinin sorguları nasıl işlediğine bakalım.

Genel olarak SQLite’ın modeli, sadelik ve işlemsel doğruluk için ayarlanmıştır; DuckDB’nin vektörleştirilmiş motoru ise aktarım ve analitik performans için tasarlanmıştır.

SQLite

SQLite geleneksel yineleyici tabanlı bir model kullanır; sorgu hattında verileri satır satır işler.

Bu satır-bazlı yürütme yaklaşımı hafiftir ve sorguların sıklıkla küçük veri kümelerini ve sık ekleme/güncellemeleri içerdiği işlemsel iş yükleriyle uyumludur.

Ancak sorgular büyük veri kümelerini taramak zorunda kaldığında performans darboğazları ortaya çıkar; çünkü satır satır değerlendirme ek yük yaratır.

DuckDB

DuckDB, tek seferde bir satır yerine bir seferde bir grup satırı (vektörleri) işleyen vektörleştirilmiş sorgu yürütmesi kullanır.

Bu yaklaşım CPU ek yükünü en aza indirir, modern CPU önbelleklerini daha iyi kullanır ve SIMD (Tek Komut, Çoklu Veri) paralelliğine olanak tanır.

Vektörleştirilmiş yürütme, analitik için özellikle avantajlıdır: toplama, birleştirme ve filtreleme gibi işlemler büyük veri hacimleri üzerinde belirgin şekilde daha hızlı çalışır.

DuckDB’de aşağıdaki sorgu, sütun bazlı depolama ve vektörleştirilmiş işlemden faydalanarak önemli ölçüde daha hızlıdır.

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

3. Süreç içi veritabanı mimarisi

Son olarak, SQLite ve DuckDB gömülü veritabanlarıdır; yani ayrı bir veritabanı sunucusu olarak değil, ana uygulamanın süreci içinde çalışırlar.

Bu mimari ağ gecikmesini ortadan kaldırır, dağıtımı basitleştirir ve harici hizmetlerin yönetilmesine ilişkin operasyonel yükü azaltır.

Bu da onları şu açılardan iyi kılar:

• Dağıtımı kolay
• Kurulumu basit
• Düşük gecikme (istemci-sunucu ek yükü yok)

SQLite 

SQLite, “sunucusuz” veritabanı fikrinin öncüsüdür. Bu, uygulamalarınızın doğrudan kütüphanesine bağlandığı ve tüm sorguların uygulamanın içinde yürütüldüğü anlamına gelir.

DuckDB 

DuckDB benzer bir süreç içi tasarımı izler ancak bunu analitik bağlamlara uygular.

Harici analitik motorları ayağa kaldırmanın ek yükünden kaçınmak için DuckDB, sorguları Python, R veya hatta Jupyter not defterleri gibi veri bilimi ortamlarında çalıştırarak bu ortamları kullanır.

DuckDB vs SQLite Performans Analizi ve Kıyaslama

Performans, DuckDB ile SQLite arasındaki en önemli ayırt edici unsurlardan biridir. Her ikisi de gömülü veritabanları olmasına rağmen, tasarım öncelikleri farklı iş yüklerinde nasıl davrandıklarını etkiler. 

Genel olarak SQLite, işlemsel kullanım senaryolarında güçlü performans gösterirken DuckDB analitik bağlamlarda başarılıdır.

1. Analitik sorgu performansı

DuckDB:

• Toplamalar, birleştirmeler, grup bazlı işlemlerde SQLite’tan daha iyi performans gösterir.
• Parquet/Arrow dosyalarını doğrudan sorgulayabilir.
• DuckDB analitik sorgu yürütme için inşa edilmiştir ve büyük veri kümelerini işlerken SQLite’ı rutin olarak geride bırakır.

Bunu bir toplama sorgusuyla nasıl test edebileceğimize bakalım.

10 milyon satır içeren (sales.csv) bir satış veri kümesine sahip olduğumuzu varsayalım; içinde order_id, customer_id, amount ve date alanları bulunsun.

SQLite (Python):

Bu sorguyu Python kullanarak SQLite’ta çalıştırmak için CSV’yi bir dataframe’e yüklememiz, bunu bir SQLite3 bağlantı veritabanına yazmamız ve SQL sorgumuzu bunun içinde çalıştırmamız gerekir.

İşte bir kod örneği:

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())Altyapı:

DuckDB (Python):

Benzer bir sorguyu Python’da DuckDB ile çalıştırmak için daha az adım gerekir. Bir dataframe’e ihtiyaç yoktur.

İşte bir kod örneği:

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

2. İşlemsel iş yükü performansı

İşlemsel iş yükü açısından her veritabanının kendine özgü kullanım alanları vardır.

SQLite, işlem yoğunluklu ve noktasal sorgu iş yükleri için optimize edilmiştir. Sık INSERT, UPDATE ve DELETE işlemlerini çok düşük ek yükle gerçekleştirir; bu da onu gömülü işlemsel sistemler için ideal kılar.

SQLite, işlemler kullanılarak toplu eklemeleri verimli bir şekilde destekler ve küçük güncellemelerin sık gerektiği durumlarda iyi performans gösterir.

Buna karşılık DuckDB, yüksek frekanslı işlemsel güncellemelerden ziyade veri alımından sonraki analitik sorgulara odaklanır.

3. Ölçeklenebilirlik ve kaynak kullanımı

SQLite

SQLite hafiftir ve genellikle küçük-orta ölçekli veri kümeleri için kullanılır. Tek bir sorgu tek iş parçacığında yürütülür ve SQLite eşzamanlı okumalarla tek-yazıcı modeli kullanır; tek bir SELECT’i paralelleştirmez; bu da analitik aktarım hızını sınırlayabilir.

DuckDB

DuckDB çok çekirdekli paralellik ve bellekten büyük sorguları destekler. Paralel yürütmeden yararlanarak ölçeklenir ve gerektiğinde diske dökebilir; bu da çekirdek dışı analitiği mümkün kılar

Bu sayede sistem belleğini fazlasıyla aşan veri kümelerini analiz ederken, bellek içi yürütmeye yakın performans korunur.

4. Dosya formatı ve G/Ç performansı

SQLite

SQLite verileri, taşınabilir ve istikrarlı olan ancak modern analitik formatlarla doğrudan birlikte çalışabilirlikten yoksun, kendine özgü satır tabanlı formatında depolar. Sorgular çalıştırılmadan önce verilerin sıklıkla SQLite’a aktarılması gerekir; bu da ek G/Ç ek yükü getirir.

DuckDB

DuckDB, Parquet, Arrow ve CSV dahil olmak üzere birden fazla dosya formatını yerel olarak destekler; böylece verileri dönüştürmeden doğrudan sorgulayabilir (örneğin SELECT … FROM 'file.parquet').

Bu, ETL ek yükünü ortadan kaldırır ve Parquet gibi sütun bazlı formatlardan yalnızca gerekli verileri okuyarak analitiği hızlandırır.

DuckDB vs SQLite’ta Veri Alımı ve Birlikte Çalışabilirlik

Veritabanları sıklıkla büyük miktarda veriyi almak için kullanılır. Şimdi her birinin veri alım yetenekleri ve birlikte çalışabilirlik açısından nasıl performans gösterdiğine bakalım.

1. Desteklenen dosya formatları ve veri alımı

DuckDB

DuckDB, Parquet, Arrow ve CSV’yi yerel olarak içe alır. Parquet üzerinde, bir veritabanı dosyasına aktarmadan doğrudan SQL sorguları çalıştırabilir.

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

SQLite

SQLite, sorgular çalıştırılmadan önce harici verilerin kendi depolama formatına aktarılmasını gerektirir.

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())Altyapı:

2. Veri bilimi araçlarıyla entegrasyon

DuckDB

DuckDB, pandas, R ve Jupyter ile sıkı entegrasyona sahiptir ve pandas DataFrame’leriyle doğrudan entegre olur; bunları SQL tabloları gibi elemenize olanak tanır:

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

SQLite

SQLite birçok programlama diliyle çalışır ancak veri bilimi odaklılığı daha düşüktür.

Örneğin SQLite, pandas ile de etkileşebilir ancak genellikle daha fazla kalıp kod gerektirir.

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

3. Dil bağlayıcıları ve API’ler

SQLite

SQLite 2000’den beri hayatımızda olduğu için bağlayıcıları son derece olgundur. Sadece küçük bir C kütüphanesi olduğundan, çoğu dilde resmi veya topluluk desteği vardır.

Bazı örnekler: C, Python (sqlite3), Java, PHP ve daha fazlası.

DuckDB

DuckDB çok daha gençtir ancak veri bilimi + analitik iş akışlarını göz önünde bulundurarak tasarlanmıştır. Bağlayıcıları daha azdır fakat veri bilimi dostudur.

Bazı örnekler: Python, R, C++, JavaScript bağlayıcıları.

Kullanım Alanları ve Uygulama Alanları

SQLite ve DuckDB her ikisi de hafif, gömülü veritabanları olsa da çok farklı amaçlara hizmet eder. 

SQLite, işlemsel ve uygulama düzeyi bağlamlarda başarılı olurken DuckDB, veri bilimi ve iş zekâsında analitik iş yükleri için optimize edilmiştir. Bazı durumlarda birbirlerini tamamlayabilirler.

Aşağıda bazı somut örneklere bakalım:

1. SQLite uygulama senaryoları

SQLite son derece hafiftir; bu da onu şunlar için mükemmel kılar:

• Mobil uygulama depolaması: SQLite, hem Android hem iOS uygulamaları için varsayılan veritabanıdır; sunucu arkayüzü gerektirmeden kalıcı yerel depolama sağlar.
• IoT cihazları: Hafif IoT cihazları, minimum ayak izi ve sıfır yapılandırma gereksinimleri nedeniyle sıklıkla SQLite’a güvenir.
• Tarayıcı önbellekleme: SQLite, dağıtık sistemlerde yaygın olarak bir önbellek katmanı olarak veya sistemler arasında veri aktarılırken ara depo olarak kullanılır.

2. DuckDB analitik uygulamaları

DuckDB, ETL hatları gibi analitik iş akışlarıyla sıkı sıkıya bağlantılıdır. Python’da nasıl uygulanabileceğine dair bir örnek aşağıdadır.

DuckDB CLI kullanarak:

-- 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);Altyapı:

Şimdi dosyayı terminalde çalıştırın:

duckdb -c ".read etl.sql"Altyapı:

Alternatif olarak, DuckDB’yi Python içinde kullanarak yalın bir veri analitiği iş akışı da kurabilirsiniz.

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)
""")Altyapı:

3. Hibrit ve tamamlayıcı senaryolar

DuckDB ile SQLite verilerini analiz edin:

DuckDB, bir SQLite veritabanı dosyasındaki verileri doğrudan sorgulayabilir:

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

Performansın Optimize Edilmesi ve En İyi Uygulamalar

Hem SQLite hem de DuckDB tasarım gereği verimlidir; ancak performans, verilerin nasıl alındığı, sorgulandığı ve bakımı yapıldığına bağlı olarak büyük ölçüde değişebilir.

1. Toplu eklemeler ve verimli veri işleme

SQLite

Büyük veri yükleri için her zaman işlemleri kullanın. Satırları işlem olmadan tek tek eklemek, SQLite’ın her satırı ayrı ayrı işlemesine yol açar ve performansı ciddi şekilde yavaşlatır.

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()Altyapı:

Yukarıdaki gibi veriyi toplu hale getirmek performansı önemli ölçüde artırır.

DuckDB

DuckDB, özellikle harici dosyalardan büyük veri kümelerinin alımını verimli şekilde yönetir. Daha hızlı hatlar için COPY komutlarını veya Parquet/CSV’nin doğrudan sorgulanmasını kullanın.

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') """)Altyapı:

2. Sorgu optimizasyon teknikleri

SQLite: 

Sorgularınızı daha iyi optimize etmek için arama işlemlerinde indeks kullanın.

CREATE INDEX idx_customer_id ON orders(customer_id);Altyapı:

Ayrıca, yürütme yollarını analiz etmek ve eksik indeksleri belirlemek için EXPLAIN QUERY PLAN kullanmanızı öneririm.

Genel olarak, kaynakları sınırlı ortamlarda sorguları basit tutmaya ve gereksiz birleştirmelerden kaçınmaya çalışın.

DuckDB

DuckDB için sütun budama ve öngenelleme itimi (predicate pushdown) kullanabilirsiniz.

• Sütun budama: DuckDB yalnızca sorgunuzun gerçekten ihtiyaç duyduğu sütunları okur. Bu, daha az G/Ç, daha hızlı taramalar sağlar—özellikle geniş tablolar veya Parquet dosyalarıyla.
• Öngenelleme itimi: DuckDB, WHERE filtrelerinizi tablo/dosya taramasına iter; böylece eşleşme ihtimali olmayan satır gruplarını/sayfaları/dosyaları atlayabilir. Bu, dosya/bölüm istatistiklerini (ör. Parquet min/max) kullanarak çok daha az bayt okunmasına yol açar.

Sütun budama örneği:

-- 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;Altyapı:

Öngenelleme itimi (Parquet) örneği:

-- 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';Altyapı:

3. Bakım ve operasyonel hususlar

• SQLite: Alanı geri kazanmak için düzenli VACUUM işlemleri. Gömülü uygulamalarda yeterli disk G/Ç’si sağlanmalı ve daha iyi dayanıklılık ve eşzamanlı erişim için WAL modu kullanılmalıdır.
• DuckDB: Analitik için optimize edilmiştir; minimum ayar gerektirir. Büyük veri kümelerini bölümlemeli Parquet dosyalarına düzenleyin ki bölüm budamadan faydalanılsın. Paralellik ayarlarını hassaslaştırmak için (PRAGMA threads üzerinden) sorguları örnek iş yüklerine karşı düzenli olarak kıyaslayın.

Geliştirme, Entegrasyon ve Ekosistem

Verilere kolay erişim için veritabanlarının iyi entegre olması gerekir. Şimdi her veritabanının diğer sistemlerle nasıl entegre olduğuna bakalım.

1. Programlama dili desteği ve API’ler

• SQLite: Geniş dil desteği. Veritabanı dünyasında en geniş dil bağlayıcı yelpazelerinden birini sunar. Python, Java, C#, C/C++, PHP, Go, Ruby, Rust ve 30’dan fazla diğer dil için resmi ve topluluk tarafından bakım yapılan sürücüler vardır.
• DuckDB: Güçlü veri bilimi entegrasyonları. Veri bilimi odaklı bağlayıcılara yoğunlaşır: Python, R ve C/C++ için resmi destek.

2. Veri bilimi ve analitik entegrasyonu

DuckDB: pandas DataFrame’lerle doğrudan çalışır.

Örnek:

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()Altyapı:

DuckDB ayrıca SQL ve Python’da kullanıcı tanımlı fonksiyonları (UDF) destekler; bu da ileri analitik ve özel dönüşümlere imkân verir.

Örnek (DuckDB’de Python UDF):

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,)]Altyapı:

3. Bulut ve altyapı entegrasyonu

SQLite

SQLite, öncelikle yerel, gömülü depolama için tasarlanmış yerel-öncelikli bir veritabanıdır.

Bulut yerel uygulamalarda genellikle kapsayıcılar içinde hafif bir kalıcılık katmanı veya önbellek olarak kullanılır. Doğrudan bulut depolama bağlayıcıları olmasa da SQLite veritabanları taşınabilirdir ve ortamlar arasında kolayca aktarılabilir.

DuckDB

DuckDB, modern veri mimarilerine yönelik optimizasyonları nedeniyle (S3’teki Parquet dosyalarını sorgulama) artan bir bulut benimsemesi görüyor.

Ayrıca AWS S3, Azure Blob Storage veya Google Cloud Storage üzerindeki Parquet ve Arrow dosyaları gibi bulut depolama formatlarını sorgulamak için yerel destek sunar.

DuckDB, verilerin nesne depolamada tutulduğu ve ağır bir ambar gerektirmeden talep üzerine sorgulandığı sunucusuz analitik senaryolara iyi uyar.

Sınırlamalar ve Tavizler

Güçlü yönlerine rağmen hem DuckDB hem de SQLite, tasarım felsefelerine bağlı doğuştan gelen kısıtlamalarla gelir. 

• Eşzamanlılık ve Ölçeklenebilirlik Kısıtları:
  • SQLite: Sınırlı yazma eşzamanlılığı.
  • DuckDB: Tek süreçli eşzamanlılık modeli.
• Bellek ve Kaynak Yönetimi Kısıtları:
  • SQLite: Hafif olmakla birlikte çok büyük veri kümelerine ölçeklenemez.
  • DuckDB: Diske dökebilir, ancak büyük ölçekte işlemsel dayanıklılık için tasarlanmamıştır.
• Özellik ve İşlevsellik Boşlukları:
  • SQLite: Sınırlı analitik özellikler.
  • DuckDB: Sınırlı işlemsel sağlamlık.
• Performans Tavizleri ve Sınırlamalar:
  • SQLite: İşlemler için hızlı, analitik için yavaş.
  • DuckDB: Analitik için hızlı, küçük yazmalarda daha yavaş.

SQLite vs DuckDB Son Düşünceler

DuckDB ve SQLite her ikisi de değerli ancak farklı roller üstlenir:

• Uygulamalar ve gömülü sistemler için basit, hafif, işlemsel bir veritabanına ihtiyacınız varsa SQLite’ı seçin.
• Python/R iş akışlarınız içinde doğrudan yüksek performanslı analitiğe ihtiyacınız varsa DuckDB’yi seçin.

Birçok senaryoda birbirlerini tamamlarlar: depolama ve işlemler için SQLite, bunun üzerindeki verilerde analitik sorgular için DuckDB. Doğru seçim, iş yükünüzün daha çok OLTP (işlemler) mi yoksa OLAP (analitik) mı olduğuna bağlıdır.

DuckDB ve SQLite gibi veritabanları hakkında daha fazla keşfetmek ister misiniz? SQLite’a Başlangıç Kılavuzu eğitimimize ve DuckDB SQL’e Giriş Uygulamalı eğitimimize göz atın.