Tessera’s 1,802× result is real within its test—but it measures a deliberately hostile plan shape

The result

Tessera, a new skew-aware join-aggregate operator, reports a 5.8× to 18.8× speedup over the fastest existing system on full products and 2.8× to 4.3× on 8,192-value heavy blocks. Its largest number is 1,802× over DuckDB on a gene matrix: the paper reports 1.0 second for Tessera versus 30 minutes for the engine plan. On a New York Times word-co-occurrence workload, Tessera takes 2.9 seconds, compared with 54.3 seconds for SPALM and 8.6 minutes for the engine.[^1]

Those numbers come from a concrete evaluation rather than an abstract-only claim. The authors test on one socket of a dual-Xeon Silver 4514Y server, using 16 cores, 128 GB of NUMA-local memory and a 100 GB per-engine memory limit. Times are medians of five runs after warm-up, except runs longer than one minute, which are measured once.[^1]

What the benchmark actually rewards

The workloads are join-aggregates over skewed, sparse relations: word co-occurrence, recommendation-style pairs and graph common-neighbor counting. A conventional database plan materializes joined rows before aggregation. Tessera instead computes a sparse product directly over engine rows, emits only nonzero cells and prunes values that cannot satisfy a threshold before multiplication. It sends only a dense core of frequent values to a CPU matrix accelerator.[^1]

That distinction explains why the 1,802× figure should not be read as a general DuckDB speedup. It is the maximum on a workload where the paper says DuckDB’s ordinary plan processes every joined row, while Tessera executes a specialized operator tailored to this query family. The broader comparison is more informative: against the fastest available alternative selected per DuckDB query—including SPALM where applicable—Tessera still reports 2.8× to 18.8× gains.[^1]

The paper also tests PostgreSQL, Spark and SQLite. Tessera beats those engines’ plans by 44× to 394× across the reported queries; in SQLite’s single-thread tests, the range is 95× to 253×. For thresholded top-k queries on the news data, Tessera stays under one second across the tested k values, while the engine takes 226 seconds because filtering happens after aggregation.[^1]

The caveat

This is strong systems evidence, but not yet independent reproduction. The study uses one Intel server configuration, and runs exceeding one minute receive a single timing rather than five-run medians. Some comparisons are also structurally unavailable: SPALM cannot accept the paper’s a.x < b.x pruned-query form and is omitted there; full dense results for PubMed and graph workloads would require 148 GB to multiple terabytes, so those datasets are tested only on heavy blocks.[^1]

The defensible conclusion is narrower than the biggest number: on the paper’s skewed sparse join-aggregate suite, a specialized sparse-first operator consistently beats both conventional plans and the tested matrix alternatives. Whether the same margins survive other CPUs, data distributions and independent implementations remains open.

[^1]: Tessera paper, arXiv:2610.40620, submitted Oct. 29, 2026