DuckDB inside OLTP databases
Report talk-sf100: scale factor 100, measured 2026-11-03 13:10 to 2026-11-09 17:44 UTC (6 d 4 h 33 min). Only this campaign's records are shown. All results

Charts

Every measure for every system. Same data, same container limits, same query text apart from published mechanical dialect translation. The sections down to integration overhead use tables stored in the database; Parquet entry points, at the end, is a separate workload over Parquet files, never drawn on the same chart.

Marks on charts and tables: ✗ wrong result (never drawn as a bar), T/O timeout, E error, C crashed, ! failed to run, – n/a. Hover a mark for the reason.

Query speed

Per-query time (s, log scale)

One bar per system and query. Warm median of three warm runs, or the cold first run; toggle above.

Load and storage

Load time (s)

Bulk path is each system's fastest documented loader. Convert path starts from row-store tables and converts them; the staging load is in the tooltip.

Storage after load (bytes)

Total data directory, with redo or WAL counted and replication logs excluded.

Concurrency

Throughput vs concurrent streams (qph)

Warm cache; each stream runs the 22 queries once in its own order.

Query latency vs concurrent streams (p95, s)

95th percentile over the successful queries.

SQL compatibility

A fixed probe suite of statements an OLTP application would try. The row-store baselines build the expected results, so only the integrations are shown. A probe that fails, or returns the same wrong result, on a plain row-store table of the same server is n/a (the host server itself does not support it), for every system alike; hover a cell for the reason.

Probe outcomes per system

Each probe gets exactly one class. Share of probes.

Probe by probe

Letters repeat the colour: D ran in DuckDB, F row-path fallback, E error, ✗ wrong result, ? pushdown unobservable, ✓ DML/DDL ok (not scored), – n/a.

Silent slow paths

Share of statements that quietly ran on the row path

TPC-H queries and probes. A system that cannot show whether DuckDB ran a statement has no share (n/a), never 0%.

Integration overhead

Per-query ratio to plain DuckDB at the same version (log scale)

1x means as fast as plain DuckDB of the same version. n/a where no plain run exists at that version.

Parquet entry points

VillageSQL's vsql_duckdb is not a storage engine. It adds functions, duckdb_query(sql) and duckdb_scalar(sql), that run DuckDB SQL verbatim over external files (Parquet, CSV, JSON) and return the result as a JSON string. Ordinary SQL on MySQL tables is never routed to DuckDB, and DuckDB cannot read InnoDB tables. Results are capped by max_result_bytes and KILL QUERY does not reach the embedded DuckDB. So the table-based measures above are n/a for it.

That is a different design, not a lesser one, so it is measured on its own workload: TPC-H as local Parquet files, the 22 queries sent through each system's raw DuckDB entry point, plus four hybrid joins of DuckDB results over Parquet with tables in the server's row store: VillageSQL's documented JSON_TABLE pattern over InnoDB, and pg_duckdb's read_parquet() joined to heap tables. On the same files: plain DuckDB, pg_duckdb duckdb.query() and MariaDB run_in_duckdb(). These results are not compared with the table-based ones.

Total query time over Parquet, common queries (s)

Sum of warm medians over the queries every entry point ran correctly.

Per-query time over Parquet (s, log scale)

Same layout as above. The join_innodb items run only on VillageSQL and pg_duckdb, each in its own documented pattern.

Throughput over Parquet vs concurrent streams (qph)

The 22 queries over Parquet; each stream runs them once in its own order. The joins are not part of it.