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.