DuckDB vs SQLite: So sánh cơ sở dữ liệu toàn diện

Trong quản trị dữ liệu hiện đại, các cơ sở dữ liệu nhúng nhẹ đóng vai trò then chốt trong việc vận hành ứng dụng, quy trình làm việc và phân tích. Hai hệ thống thường được đem ra so sánh là DuckDB và SQLite. 

Cả hai đều là cơ sở dữ liệu nhúng, nhưng phục vụ mục đích khác nhau: SQLite vượt trội ở khối lượng công việc giao dịch, trong khi DuckDB được tối ưu cho truy vấn phân tích.

Trong bài so sánh này, chúng ta sẽ xem hai cơ sở dữ liệu khác nhau như thế nào.

Tổng quan nhanh: DuckDB vs SQLite

Dưới đây là bảng so sánh những điểm tương đồng và khác biệt giữa DuckDB và SQLite. Để biết chi tiết đầy đủ, xem phần giải thích xuyên suốt bài viết. 

SQLite là gì?

SQLite là một trong những cơ sở dữ liệu được triển khai rộng rãi nhất trên thế giới. Ra mắt năm 2000, SQLite được thiết kế như một động cơ cơ sở dữ liệu SQL nhẹ, không máy chủ (serverless).

Một số tính năng chính:

• Tự chứa và không máy chủ
• Thiết lập không cần cấu hình
• Tuân thủ ACID đầy đủ
• Lưu trữ định hướng hàng

Nhờ kiến trúc nhẹ, nó phù hợp với các trường hợp sử dụng sau:

• Ứng dụng di động (Android, iOS)
• Phần mềm máy tính để bàn
• Hệ thống nhúng như thiết bị IoT

Thế mạnh chủ đạo của SQLite nằm ở sự đơn giản và độ tin cậy. Nhà phát triển có thể đóng gói một cơ sở dữ liệu dạng tệp duy nhất cùng ứng dụng của họ mà không phải lo về các phụ thuộc bên ngoài.

DuckDB là gì?

DuckDB thường được ví như SQLite dành cho phân tích. Giới thiệu năm 2019, DuckDB được phát triển tại CWI. Mục tiêu chính khi dùng DuckDB là có một giải pháp cơ sở dữ liệu OLAP trong tiến trình.

Một số tính năng chính:

• Định dạng lưu trữ theo cột
• Tối ưu cho khối lượng công việc OLAP
• Thực thi truy vấn dạng vector
• Thiết kế nhúng trong tiến trình
• Hỗ trợ trực tiếp các định dạng tệp như Parquet và Arrow

Một số trường hợp sử dụng điển hình:

• Phân tích tương tác
• Quy trình khoa học dữ liệu (Python, R, Jupyter)
• Pipeline ETL nhẹ

Điểm cốt lõi khi dùng DuckDB là nó mang sức mạnh của các cơ sở dữ liệu phân tích (như Snowflake hoặc BigQuery) trong một gói nhúng.

DuckDB vs SQLite: Khác biệt và tương đồng chính

1. Cài đặt và phụ thuộc

SQLite

SQLite nổi tiếng là không có phụ thuộc. Nó biên dịch thành một thư viện C đơn có thể đóng gói vào hầu như mọi ứng dụng.

Việc cài đặt tối giản và có thể tải trực tiếp từ trang web SQLite.

Tính di động là một trong những điểm mạnh nhất: hoạt động giống nhau trên Windows, macOS, Linux, iOS và Android gần như không cần nỗ lực bổ sung.

DuckDB

DuckDB cũng dễ cài đặt, nhưng được phân phối dưới dạng nhị phân riêng hoặc các gói Python/R thay vì được cài sẵn phổ biến.

Nó có thêm một vài phụ thuộc, đặc biệt khi bật tích hợp với Apache Arrow, Parquet hoặc Pandas.

Dấu chân vẫn nhỏ, nhưng so với SQLite, DuckDB cần thiết lập nhiều hơn đôi chút nếu bạn muốn các chức năng nâng cao như kết nối lưu trữ đám mây hoặc tích hợp công cụ khoa học dữ liệu.

2. Định dạng lưu trữ và kiến trúc

SQLite 

Lưu dữ liệu theo định dạng dựa trên hàng, tối ưu cho các tác vụ OLTP (Xử lý giao dịch trực tuyến) như chèn, cập nhật và xóa.

Truy xuất toàn bộ một hàng nhanh, nhưng truy vấn phân tích chỉ quét vài cột trên hàng triệu hàng có thể chậm do phải đọc dữ liệu không cần thiết.

DuckDB

DuckDB sử dụng động cơ lưu trữ theo cột, được xây dựng có chủ đích cho OLAP (Xử lý phân tích trực tuyến).

Định dạng theo cột nghĩa là các truy vấn tổng hợp trên bộ dữ liệu lớn (ví dụ, AVG(sales) hoặc COUNT(*)) nhanh hơn nhiều vì chỉ các cột liên quan được nạp vào bộ nhớ.

Cũng cho phép nén tốt hơn và thực thi vector hóa để tăng tốc.

Ví dụ: Truy vấn SELECT * FROM sales WHERE customer_id=123 chạy nhanh hơn trên SQLite, trong khi SELECT AVG(amount) FROM sales GROUP BY region chạy nhanh hơn nhiều trên DuckDB.

3. Khối lượng công việc giao dịch so với phân tích

Hai cơ sở dữ liệu cũng khác nhau về loại khối lượng công việc:

• OLTP (Giao dịch): Các thao tác ngắn, thường xuyên (ví dụ, ứng dụng ngân hàng, hồ sơ người dùng, hệ thống điểm bán). Ưu tiên: độ trễ thấp, toàn vẹn dữ liệu và truy cập đồng thời.
• OLAP (Phân tích): Truy vấn phức tạp trên bộ dữ liệu lớn (ví dụ, bảng điều khiển, công cụ BI, phân tích dữ liệu ad-hoc). Ưu tiên: thông lượng, hiệu suất quét và tốc độ tổng hợp.

SQLite

SQLite được tối ưu cho OLTP (chèn, cập nhật, xóa, tra cứu điểm).

Ví dụ:

• Ứng dụng di động lưu dữ liệu ngoại tuyến.
• Thiết bị IoT ghi nhật ký tương tác người dùng.
• Bộ nhớ đệm cục bộ trong ứng dụng máy tính để bàn.

DuckDB

DuckDB được tối ưu cho OLAP (tổng hợp, nối, quét).

Ví dụ:

• Nhà khoa học dữ liệu chạy tổng hợp trên tệp Parquet/CSV.
• Các bảng điều khiển BI tương tác nơi truy vấn tóm tắt hàng triệu hàng.
• Pipeline ETL/ELT cần biến đổi trong bộ nhớ nhẹ.

4. Hỗ trợ và cú pháp SQL

Tiếp theo, hãy xem cú pháp SQL của chúng. Cả hai đều triển khai một phần lớn tiêu chuẩn SQL với các phần mở rộng; không bên nào tuân thủ ANSI hoàn toàn.

SQLite

• Hỗ trợ phần lớn tiêu chuẩn SQL nhưng thiếu các cấu trúc phân tích nâng cao.
• Tốt cho thao tác CRUD và các phép nối đơn giản.
• Hỗ trợ hàm cửa sổ và CTE, nhưng thiếu một số tính năng phân tích cao cấp như GROUPING SETS và một số phần mở rộng tổng hợp.

Cú pháp trông như sau:

CREATE TABLE sales (
    id INTEGER PRIMARY KEY,
    product TEXT,
    amount REAL,
    sale_date TEXT
);Được hỗ trợ bởi

DuckDB

• Gần với tuân thủ ANSI SQL hơn nhiều, hỗ trợ mạnh các hàm cửa sổ, CTE, tổng hợp và phép toán tập hợp.
• Được thiết kế để mang lại cảm giác như PostgreSQL nhẹ cho phân tích.
• Tích hợp với Arrow và Pandas cho phép chạy SQL trực tiếp trên bộ dữ liệu bên ngoài mà không cần nhập trước.

Ví dụ tương tự về cú pháp của DuckDB:

CREATE TABLE sales (
    id INTEGER,
    product VARCHAR,
    amount DOUBLE,
    sale_date DATE
);Được hỗ trợ bởi

SQLite vs DuckDB: Kiến trúc nền tảng và triết lý thiết kế

Về kiến trúc nền tảng, SQLite và DuckDB đều là cơ sở dữ liệu nhúng, chạy trong tiến trình. Tuy nhiên, triết lý thiết kế của chúng khác nhau. 

SQLite ưu tiên sự đơn giản và độ tin cậy giao dịch, trong khi DuckDB được tối ưu cho khối lượng công việc phân tích và tích hợp khoa học dữ liệu hiện đại.

1. Kiến trúc lưu trữ

Trước hết, hai cơ sở dữ liệu khác nhau về kiến trúc lưu trữ.

SQLite

SQLite dựa trên hàng, rất phù hợp cho truy cập giao dịch. Điều này có nghĩa toàn bộ hàng được lưu cùng nhau trên đĩa.

Thiết kế này có lợi cho khối lượng công việc giao dịch (OLTP) vì chèn, cập nhật hoặc truy xuất một bản ghi thường chỉ cần truy cập một hàng.

Các ứng dụng cần truy cập nhanh, nhất quán tới từng bản ghi như hồ sơ người dùng hoặc chi tiết đơn hàng sẽ hoạt động hiệu quả với mô hình này.

DuckDB

DuckDB dùng định dạng theo cột, được thiết kế để quét hàng tỷ hàng nhanh chóng. Định dạng theo cột nghĩa là nhóm các giá trị của cùng một cột lại với nhau trên đĩa và trong bộ nhớ.

Lưu trữ theo cột cho phép truy vấn phân tích (OLAP) hiệu quả cao, vì các phép tổng hợp, lọc và quét thường chỉ cần truy cập một tập con cột.

Kỹ thuật nén áp dụng hiệu quả hơn theo cột, giảm sử dụng bộ nhớ và lưu trữ đồng thời tăng hiệu suất quét.

2. Phương pháp xử lý truy vấn

Tiếp theo, chúng ta cần xem mỗi hệ thống xử lý truy vấn như thế nào.

Nhìn chung, mô hình của SQLite được tinh chỉnh cho sự đơn giản và tính đúng đắn giao dịch, trong khi động cơ vector hóa của DuckDB được thiết kế cho thông lượng và hiệu năng phân tích.

SQLite

SQLite sử dụng mô hình dựa trên bộ lặp truyền thống, xử lý từng hàng một qua pipeline truy vấn.

Cách thực thi từng hàng này nhẹ và phù hợp với khối lượng giao dịch, nơi truy vấn thường liên quan dữ liệu nhỏ và chèn/cập nhật thường xuyên.

Tuy nhiên, nút thắt hiệu năng xuất hiện khi truy vấn phải quét bộ dữ liệu lớn, vì đánh giá từng hàng gây thêm chi phí.

DuckDB

DuckDB áp dụng thực thi truy vấn dạng vector, xử lý theo lô các hàng (vector) cùng lúc thay vì từng hàng.

Cách tiếp cận này giảm thiểu chi phí CPU, tận dụng tốt bộ nhớ đệm CPU hiện đại và cho phép SIMD (Single Instruction, Multiple Data) song song.

Thực thi vector đặc biệt hữu ích cho phân tích: các thao tác như tổng hợp, nối và lọc chạy nhanh hơn đáng kể trên khối lượng dữ liệu lớn.

Trong DuckDB, truy vấn sau hưởng lợi từ lưu trữ theo cột và xử lý vector, giúp nhanh hơn đáng kể.

SELECT region, AVG(amount)
FROM sales
GROUP BY region;Được hỗ trợ bởi

3. Kiến trúc cơ sở dữ liệu trong tiến trình

Cuối cùng, SQLite và DuckDB là cơ sở dữ liệu nhúng, nghĩa là chúng chạy trong tiến trình của ứng dụng chủ thay vì như một máy chủ CSDL riêng.

Kiến trúc này loại bỏ độ trễ mạng, đơn giản hóa triển khai và giảm gánh nặng vận hành các dịch vụ bên ngoài.

Điều này khiến chúng:

• Dễ phân phối
• Dễ triển khai
• Độ trễ thấp (không có chi phí client-server)

SQLite 

SQLite tiên phong cho ý tưởng cơ sở dữ liệu “không máy chủ”. Nghĩa là ứng dụng của bạn liên kết trực tiếp tới thư viện của nó, và mọi truy vấn đều thực thi trong chính ứng dụng.

DuckDB 

DuckDB theo thiết kế trong tiến trình tương tự nhưng áp dụng vào bối cảnh phân tích.

Để tránh chi phí khởi chạy các động cơ phân tích bên ngoài, DuckDB tận dụng môi trường khoa học dữ liệu (Python, R, hoặc cả sổ tay Jupyter) bằng cách chạy truy vấn ngay trong đó.

Phân tích hiệu năng và benchmark DuckDB vs SQLite

Hiệu năng là một trong những yếu tố phân biệt quan trọng giữa DuckDB và SQLite. Dù cả hai đều là cơ sở dữ liệu nhúng, ưu tiên thiết kế ảnh hưởng tới cách chúng hoạt động dưới các khối lượng công việc khác nhau. 

Nhìn chung, SQLite có hiệu năng mạnh cho trường hợp sử dụng giao dịch, trong khi DuckDB làm tốt trong bối cảnh phân tích.

1. Hiệu năng truy vấn phân tích

DuckDB:

• Vượt trội so với SQLite cho tổng hợp, nối, group-by.
• Có thể truy vấn trực tiếp tệp Parquet/Arrow.
• DuckDB được xây dựng cho thực thi truy vấn phân tích, và thường xuyên vượt SQLite khi xử lý bộ dữ liệu lớn.

Hãy xem cách kiểm thử qua một truy vấn tổng hợp.

Giả sử chúng ta có bộ dữ liệu bán hàng (sales.csv) với 10 triệu hàng chứa order_id, customer_id, amount và date.

SQLite (Python):

Để chạy truy vấn này trong SQLite bằng Python, chúng ta cần nạp CSV vào dataframe rồi ghi vào cơ sở dữ liệu kết nối SQLite3, và chạy truy vấn SQL trong đó.

Ví dụ mã:

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())Được hỗ trợ bởi

DuckDB (Python):

Để chạy truy vấn tương tự bằng DuckDB trong Python, các bước ít hơn. Không cần dataframe.

Ví dụ mã:

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)Được hỗ trợ bởi

2. Hiệu năng khối lượng công việc giao dịch

Về khối lượng công việc giao dịch, mỗi cơ sở dữ liệu có các trường hợp sử dụng riêng.

SQLite được tối ưu cho khối lượng công việc nhiều giao dịch, truy vấn điểm. Nó xử lý thao tác INSERT, UPDATE và DELETE thường xuyên với chi phí rất thấp, lý tưởng cho hệ thống giao dịch nhúng.

SQLite hỗ trợ chèn hàng loạt hiệu quả bằng giao dịch và hoạt động tốt khi cần cập nhật nhỏ thường xuyên.

Ngược lại, DuckDB tập trung vào truy vấn phân tích sau khi nạp dữ liệu hơn là cập nhật giao dịch tần suất cao.

3. Khả năng mở rộng và sử dụng tài nguyên

SQLite

SQLite nhẹ và thường dùng cho bộ dữ liệu nhỏ đến trung bình. Một truy vấn chạy trên một luồng và SQLite dùng mô hình một luồng ghi với đọc đồng thời; nó không song song hóa một truy vấn SELECT, điều này có thể giới hạn thông lượng phân tích.

DuckDB

DuckDB hỗ trợ song song đa lõi và truy vấn lớn hơn bộ nhớ. Nó mở rộng bằng cách tận dụng thực thi song song và có thể tràn ra đĩa khi cần, cho phép phân tích out-of-core

Điều này cho phép phân tích bộ dữ liệu vượt xa bộ nhớ hệ thống trong khi vẫn giữ hiệu năng gần với thực thi trong bộ nhớ.

4. Định dạng tệp và hiệu năng I/O

SQLite

SQLite lưu dữ liệu trong định dạng dựa trên hàng độc quyền, có tính di động và ổn định nhưng thiếu khả năng tương tác trực tiếp với các định dạng phân tích hiện đại. Dữ liệu thường cần nhập vào SQLite trước khi chạy truy vấn, làm tăng chi phí I/O.

DuckDB

DuckDB hỗ trợ gốc nhiều định dạng tệp, bao gồm Parquet, Arrow và CSV, cho phép truy vấn dữ liệu trực tiếp không cần chuyển đổi (ví dụ, SELECT … FROM 'file.parquet').

Điều này loại bỏ chi phí ETL và tăng tốc phân tích bằng cách chỉ đọc dữ liệu cần thiết từ các định dạng dạng cột như Parquet.

Nạp dữ liệu và khả năng tương tác trong DuckDB vs SQLite

Cơ sở dữ liệu thường được dùng để nạp lượng lớn dữ liệu. Tiếp theo, chúng ta sẽ xem mỗi hệ thống thể hiện thế nào ở khả năng nạp và tương tác.

1. Định dạng tệp hỗ trợ và nạp dữ liệu

DuckDB

DuckDB cung cấp khả năng nạp gốc Parquet, Arrow và CSV. Nó có thể chạy truy vấn SQL trực tiếp trên Parquet mà không cần nhập vào tệp cơ sở dữ liệu.

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)Được hỗ trợ bởi

SQLite

SQLite yêu cầu nhập dữ liệu ngoài vào định dạng lưu trữ của mình trước khi có thể chạy truy vấn.

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())Được hỗ trợ bởi

2. Tích hợp với công cụ khoa học dữ liệu

DuckDB

DuckDB tích hợp chặt chẽ với pandas, R và Jupyter, và tích hợp trực tiếp với pandas DataFrame, cho phép bạn coi chúng như bảng 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)Được hỗ trợ bởi

SQLite

SQLite làm việc với nhiều ngôn ngữ lập trình, nhưng ít tập trung vào khoa học dữ liệu hơn.

Ví dụ, SQLite cũng có thể tương tác với pandas, nhưng thường cần nhiều mã khuôn mẫu hơn.

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)Được hỗ trợ bởi

3. Ràng buộc ngôn ngữ và API

SQLite

SQLite tồn tại từ năm 2000, vì vậy các ràng buộc của nó cực kỳ trưởng thành. Do chỉ là thư viện C nhỏ, hầu hết ngôn ngữ đều có hỗ trợ chính thức hoặc cộng đồng.

Một số ví dụ: C, Python (sqlite3), Java, PHP, v.v.

DuckDB

DuckDB trẻ hơn nhiều, nhưng được thiết kế cho quy trình khoa học dữ liệu + phân tích. Các ràng buộc ít hơn nhưng rất thân thiện với khoa học dữ liệu.

Một số ví dụ: Python, R, C++, ràng buộc JavaScript.

Trường hợp sử dụng và miền ứng dụng

Dù cả SQLite và DuckDB đều là cơ sở dữ liệu nhúng, nhẹ, chúng phục vụ mục đích rất khác nhau. 

SQLite phát huy trong bối cảnh ứng dụng cấp giao dịch, trong khi DuckDB được tối ưu cho khối lượng công việc phân tích trong khoa học dữ liệu và BI. Ở một số trường hợp, chúng thậm chí có thể bổ trợ cho nhau.

Hãy xem một số ví dụ cụ thể dưới đây:

1. Kịch bản ứng dụng SQLite

SQLite rất nhẹ, khiến nó hoàn hảo cho:

• Lưu trữ ứng dụng di động: SQLite là cơ sở dữ liệu mặc định cho cả ứng dụng Android và iOS, cung cấp lưu trữ cục bộ bền vững mà không cần backend máy chủ.
• Thiết bị IoT: Thiết bị IoT nhẹ thường dựa vào SQLite nhờ dấu chân tối thiểu và không cần cấu hình.
• Bộ nhớ đệm trình duyệt: SQLite thường dùng như lớp cache trong hệ thống phân tán hoặc làm kho trung gian khi chuyển dữ liệu giữa các hệ thống.

2. Ứng dụng phân tích với DuckDB

DuckDB gắn chặt với quy trình phân tích như pipeline ETL. Đây là ví dụ triển khai bằng Python.

Sử dụng 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);Được hỗ trợ bởi

Giờ chạy tệp trong terminal:

duckdb -c ".read etl.sql"Được hỗ trợ bởi

Ngoài ra, bạn cũng có thể dùng DuckDB trong Python để có quy trình phân tích dữ liệu tinh gọn.

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)
""")Được hỗ trợ bởi

3. Kịch bản lai và bổ trợ

Phân tích dữ liệu SQLite trong DuckDB:

DuckDB có thể truy vấn trực tiếp dữ liệu bên trong tệp cơ sở dữ liệu 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)Được hỗ trợ bởi

Tối ưu hiệu năng và thực hành tốt nhất

Cả SQLite và DuckDB đều hiệu quả theo thiết kế, nhưng hiệu năng có thể khác biệt lớn tùy cách dữ liệu được nạp, truy vấn và bảo trì.

1. Chèn hàng loạt và xử lý dữ liệu hiệu quả

SQLite

Với tải dữ liệu lớn, luôn dùng giao dịch. Chèn từng hàng mà không có giao dịch buộc SQLite cam kết từng hàng, làm chậm hiệu năng nghiêm trọng.

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()Được hỗ trợ bởi

Gộp dữ liệu theo lô như ví dụ trên cải thiện hiệu năng đáng kể.

DuckDB

DuckDB xử lý nạp bộ dữ liệu lớn hiệu quả, đặc biệt từ tệp ngoài. Dùng lệnh COPY hoặc truy vấn trực tiếp Parquet/CSV cho pipeline nhanh hơ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') """)Được hỗ trợ bởi

2. Kỹ thuật tối ưu truy vấn

SQLite: 

Để tối ưu truy vấn tốt hơn, hãy dùng chỉ mục cho tra cứu.

CREATE INDEX idx_customer_id ON orders(customer_id);Được hỗ trợ bởi

Tôi khuyến nghị dùng EXPLAIN QUERY PLAN để phân tích đường thực thi và xác định chỉ mục còn thiếu.

Nói chung, cố gắng giữ truy vấn đơn giản và tránh các phép nối không cần thiết trong môi trường hạn chế tài nguyên.

DuckDB

Với DuckDB, bạn có thể dùng tỉa cột (column pruning) và đẩy điều kiện (predicate pushdown).

• Tỉa cột: DuckDB chỉ đọc các cột truy vấn thực sự cần. Điều này dẫn tới ít I/O hơn, quét nhanh hơn — đặc biệt với bảng rộng hoặc tệp Parquet.
• Đẩy điều kiện: DuckDB đẩy bộ lọc WHERE xuống tới bước quét bảng/tệp để có thể bỏ qua các nhóm hàng/trang/tệp không thể khớp. Điều này giúp đọc ít byte hơn nhờ dùng thống kê tệp/phân vùng (ví dụ, min/max trong Parquet).

Ví dụ tỉa cột:

-- Chỉ đọc cột 'user_id' và 'amount'; các cột khác không bị đụng tới
SELECT user_id, SUM(amount)
FROM read_parquet('events/*.parquet')
GROUP BY user_id;Được hỗ trợ bởi

Ví dụ đẩy điều kiện (Parquet):

-- Bỏ qua các group/trang có min/max(order_ts) hoàn toàn ngoài khoảng này
SELECT *
FROM read_parquet('events/dt=*/events.parquet')
WHERE order_ts >= TIMESTAMP '2025-09-01'
  AND order_ts <  TIMESTAMP '2025-10-01';Được hỗ trợ bởi

3. Bảo trì và lưu ý vận hành

• SQLite: Thực hiện VACUUM định kỳ để thu hồi dung lượng. Với ứng dụng nhúng, đảm bảo I/O đĩa đủ tốt và dùng chế độ WAL để tăng độ bền và truy cập đồng thời.
• DuckDB: Tối ưu cho phân tích; cần tinh chỉnh tối thiểu. Tổ chức bộ dữ liệu lớn thành các tệp Parquet phân vùng để tận dụng tỉa phân vùng.Thường xuyên benchmark truy vấn với khối lượng mẫu để tinh chỉnh cài đặt song song (qua PRAGMA threads).

Phát triển, tích hợp và hệ sinh thái

Cơ sở dữ liệu cần được tích hợp tốt để đảm bảo dữ liệu được truy cập dễ dàng. Giờ chúng ta sẽ xem mỗi cơ sở dữ liệu tích hợp với hệ thống khác ra sao.

1. Hỗ trợ ngôn ngữ lập trình và API

• SQLite: Hỗ trợ ngôn ngữ rộng. Cung cấp một trong những dải ràng buộc ngôn ngữ rộng nhất trong thế giới cơ sở dữ liệu. Có driver chính thức và do cộng đồng duy trì cho Python, Java, C#, C/C++, PHP, Go, Ruby, Rust và hơn 30 ngôn ngữ khác.
• DuckDB: Tích hợp khoa học dữ liệu mạnh. Tập trung vào ràng buộc hướng khoa học dữ liệu: hỗ trợ chính thức cho Python, R và C/C++.

2. Tích hợp khoa học dữ liệu và phân tích

DuckDB: Làm việc trực tiếp với pandas DataFrame.

Ví dụ:

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()Được hỗ trợ bởi

DuckDB cũng hỗ trợ hàm do người dùng định nghĩa (UDF) trong SQL và Python, cho phép phân tích nâng cao và biến đổi tùy chỉnh.

Ví dụ (UDF Python trong 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,)]Được hỗ trợ bởi

3. Tích hợp đám mây và hạ tầng

SQLite

SQLite là cơ sở dữ liệu ưu tiên cục bộ, chủ yếu được thiết kế cho lưu trữ nhúng, cục bộ.

Nó được dùng trong ứng dụng cloud-native như lớp lưu trữ nhẹ hoặc bộ nhớ đệm, thường bên trong container. Dù thiếu kết nối lưu trữ đám mây trực tiếp, các cơ sở dữ liệu SQLite có tính di động và dễ chuyển giữa môi trường.

DuckDB

DuckDB đang được đón nhận nhiều hơn trên đám mây (truy vấn các tệp Parquet trên S3) nhờ tối ưu cho kiến trúc dữ liệu hiện đại.

Nó cũng cung cấp hỗ trợ gốc để truy vấn các định dạng lưu trữ đám mây như tệp Parquet và Arrow trên AWS S3, Azure Blob Storage hoặc Google Cloud Storage.

DuckDB phù hợp với kịch bản phân tích serverless, nơi dữ liệu lưu trong object storage và được truy vấn theo nhu cầu mà không cần kho dữ liệu nặng.

Hạn chế và đánh đổi

Bất chấp điểm mạnh, cả DuckDB và SQLite đều đi kèm các ràng buộc vốn có gắn với triết lý thiết kế của chúng. 

• Ràng buộc đồng thời và khả năng mở rộng:
  • SQLite: Đồng thời ghi bị hạn chế.
  • DuckDB: Mô hình đồng thời một tiến trình.
• Ràng buộc bộ nhớ và quản lý tài nguyên:
  • SQLite: Nhẹ nhưng không thể mở rộng tới bộ dữ liệu rất lớn.
  • DuckDB: Có thể tràn ra đĩa, nhưng không được thiết kế cho độ bền giao dịch ở quy mô lớn.
• Khoảng trống tính năng và chức năng:
  • SQLite: Tính năng phân tích hạn chế.
  • DuckDB: Độ vững giao dịch hạn chế.
• Đánh đổi và hạn chế hiệu năng:
  • SQLite: Nhanh cho giao dịch, chậm cho phân tích.
  • DuckDB: Nhanh cho phân tích, chậm hơn cho ghi nhỏ.

Kết luận về SQLite vs DuckDB

DuckDB và SQLite đều phục vụ những vai trò giá trị nhưng khác biệt:

• Chọn SQLite nếu bạn cần cơ sở dữ liệu giao dịch đơn giản, nhẹ cho ứng dụng và hệ thống nhúng.
• Chọn DuckDB nếu bạn cần phân tích hiệu năng cao trực tiếp trong quy trình làm việc Python/R của mình.

Trong nhiều kịch bản, chúng bổ trợ lẫn nhau: SQLite cho lưu trữ và giao dịch, DuckDB cho truy vấn phân tích trên dữ liệu đó. Lựa chọn đúng phụ thuộc vào việc khối lượng công việc của bạn là OLTP (giao dịch) hay OLAP (phân tích).

Muốn khám phá thêm về các cơ sở dữ liệu như DuckDB và SQLite? Hãy xem hướng dẫn SQLite cho người mới bắt đầu và Giới thiệu về DuckDB SQL qua bài hướng dẫn Code-Along.