Performance¶
The October 30, 2026 benchmark compares Flight SQL via ADBC, Flight SQL via JDBC, native Flight RPC, redis-py, and direct Redis ADBC on the Redis ADBC driver's sample dataset. All 310 timed trials completed and passed result validation. These results describe local, warm, single-client runs of the recorded server revision and environment.
Full-data read comparison¶
Each path reads the same 100,000 sales rows and all 10 columns. Times include execution and complete result consumption. The table reports five timed repetitions after one warm-up, with connection setup excluded.
| Path | Rows | Median ms | Min–max ms | Rows/s |
|---|---|---|---|---|
| Direct Redis ADBC | 100,000 | 792.38 | 789.37–809.98 | 126,202 |
| Flight SQL via ADBC | 100,000 | 896.32 | 886.10–918.58 | 111,567 |
| Flight SQL via JDBC | 100,000 | 940.25 | 936.82–961.03 | 106,355 |
| Native Flight RPC (stored dataset) | 100,000 | 37.81 | 28.90–46.56 | 2,644,864 |
| redis-py + Arrow conversion | 100,000 | 3,611.29 | 3,556.56–3,657.23 | 27,691 |
Flight SQL ADBC and JDBC full-scan medians were within 5% of each other.
Direct Redis ADBC read the complete SQL table in 792.38 ms; Flight SQL via ADBC
took 1.13× that time in this run. ADBC returned an Arrow table; JDBC materialized
every cell through ResultSet.getObject.
Native Flight retrieved a separately uploaded Arrow dataset through
GetFlightInfo and all DoGet endpoints, using 10,000-row batches. Its stored
Arrow IPC path avoids SQL execution and Redis HASH decoding. The native Flight
result therefore reflects a different storage and execution path as well as
transport overhead.
The redis-py baseline used RESP2 SCAN with a COUNT hint of 1,000 and one
HMGET pipeline per page, decoded all ten fields, and built a typed Arrow table. It used the
pure Python RESP parser without hiredis. SCAN traversed the shared database
keyspace with the benchmark prefix filter and de-duplicated keys. Its timings
include client decoding and Arrow construction. Dataset upload and SQL table
loading are excluded from every read timing.
SQL query comparison¶
Direct Redis ADBC, Flight SQL ADBC and Flight SQL JDBC ran all 20 queries from
the Redis ADBC driver's
sample benchmark.
The generator uses seed 42, 100,000 sales rows, 10 columns and 50 customers.
SQL preserves the upstream queries with unique fixture names; nine sales
columns are indexed and notes uses NOINDEX. The labels below are retained
from the upstream benchmark. Native Flight datasets and redis-py do not execute
this SQL suite; their comparison above covers complete data reads.
| Query | Rows | Direct Redis ADBC ms | Flight SQL ADBC ms | Flight SQL JDBC ms | Flight ADBC / direct |
|---|---|---|---|---|---|
| point lookup by __rowid | 1 | 6.02 | 10.58 | 15.04 | 1.76× |
| indexed filter + top 10 | 10 | 53.02 | 62.07 | 59.18 | 1.17× |
| indexed range COUNT | 1 | 7.60 | 14.15 | 10.36 | 1.86× |
| LIKE prefix COUNT | 1 | 46.87 | 45.91 | 40.28 | 0.98× |
| interval range COUNT | 1 | 4.69 | 12.52 | 6.35 | 2.67× |
| GROUP BY, index reduce | 6 | 266.81 | 258.05 | 254.07 | 0.97× |
| GROUP BY, driver (AVG double) | 6 | 561.15 | 543.15 | 540.04 | 0.97× |
| GROUP BY expression, driver | 5 | 645.74 | 617.75 | 617.34 | 0.96× |
| GROUP BY DATE_TRUNC, driver | 12 | 682.02 | 595.00 | 631.27 | 0.87× |
| non-indexed filter (scan) | 1 | 131.46 | 96.03 | 92.49 | 0.73× |
| fetch 10% of rows | 10,000 | 75.06 | 83.49 | 93.19 | 1.11× |
| full scan, all columns | 100,000 | 792.38 | 896.32 | 940.25 | 1.13× |
| selective join (index lookup) | 8 | 29.58 | 39.22 | 37.02 | 1.33× |
| unfiltered join (hash join) | 6 | 443.12 | 441.31 | 450.45 | 1.00× |
| correlated subquery (50 rows) | 50 | 41.88 | 46.77 | 48.97 | 1.12× |
| IN (SELECT …), half the rows | 1 | 915.42 | 841.07 | 841.15 | 0.92× |
| correlated EXISTS (semi-join) | 1 | 1,111.00 | 1,083.69 | 1,054.75 | 0.98× |
| correlated EXISTS, no inner rows | 1 | 11.88 | 15.68 | 13.72 | 1.32× |
| UNION of two filters | 1,750 | 98.92 | 92.59 | 88.70 | 0.94× |
| view with pushed filter | 1 | 12.78 | 27.03 | 24.48 | 2.11× |
The ratio is Flight SQL ADBC time divided by direct Redis ADBC time. Above 1 means the Flight SQL path took longer; below 1 means it took less time. The client suites ran sequentially, so ratios also reflect host load and runtime warm-up. Small-query differences should be interpreted with the raw min/max timings and this limitation.
Recorded environment¶
| Component | Configuration |
|---|---|
| Flight server | Community build, commit 4c0eba6e73777ebf3fb25f33512207a2460f09cc |
| Redis ADBC module | v0.0.18, revision 2f053d3affad |
| Redis | Redis Software 8.6.2, one shard, 1 GiB database, no replication or persistence |
| Query Performance Factor | Active at 4×; verified through the Software REST API before timing |
| Python | 3.14.10, PyArrow 26.0.0, Flight SQL/ADBC manager 1.12.0, redis-py 8.1.0 |
| Direct Redis ADBC | v0.0.18, same 2f053d3affad source revision, compiled with Go 1.26.10 for Linux arm64 |
| Java | Flight SQL JDBC 19.0.0, Temurin 25.0.4.1 |
| Host | macOS 26.7.2 arm64; Docker Desktop with 18 CPUs and 25,421,033,472 bytes RAM |
| Placement | Python/Java clients and Redis in Linux arm64 containers; Flight server native on macOS |
| Network | Clients reach Flight or Redis through Docker Desktop host forwarding |
| Timing | One client, warmed persistent connections, one warm-up plus five timed runs per case |
The direct-driver baseline was a follow-up run after the initial four paths. It restored the exact archived source fixture, SQL and index definitions on the same database, reverified active 4× QPF, and fetched Arrow results through the ADBC driver manager without a Flight server. The direct shared library uses Go 1.26.10 on Linux; the Flight server uses Go 1.27.2 on macOS. Runtime, placement and host-load differences prevent attributing the whole timing difference to Flight overhead. Redis command statistics are database-wide and can include unrelated activity on this shared server.
The benchmark used the driver's sample performance suite. It did not run ClickBench, concurrent clients, cold-cache tests or a remote network workload. The laptop and containers share resources with other applications. The results do not establish production capacity or memory usage.
Validation, raw results and reproduction¶
DuckDB 2.0.0 independently computed SQL references from the generated fixture. Every Flight SQL ADBC and direct Redis ADBC warm-up and timed result, all 100 timed JDBC results, and all native Flight and redis-py full scans passed value and row-count checks. Unordered results preserve multiplicity; numbers are normalized to nine significant digits. Top-10 ties accept any valid set of ten unique rows at the correct threshold. These checks validate result contents rather than ORDER BY output order. Validation, logging and Redis INFO sampling occur outside the timers.
The benchmark report and reproduction commands include the harness, exact SQL, dependency pins, source hashes and cleanup record. The summary JSON contains min/median/max timings for every case. Individual trials are available in the Python results, JDBC results, and direct Redis ADBC results. The environment record identifies the tested binary and effective QPF configuration. Source data and JDBC result values are retained in a compressed archive with SHA256 hashes. All benchmark tables, the view, dataset and temporary processes were removed; existing Redis data was preserved.