Benchmarks

KoldStore is a storage lifecycle tool — not a universal query accelerator. The primary published wins are footprint and whole-table maintenance after flush. DML and cold-path lookups are contextual single samples, not release guarantees.

Source sample: 10M wide rows, hot_row_limit = 100000, local PostgreSQL 16.13 (release-pg), 2026-08-01, single wiped pgrx instance per side. Foreground INSERT uses equalized WAL retention so it is not marketed as a speedup. Full tables live in the repo: docs/benchmarks/RESULTS.md .

Product page summary: /koldstore.

pgrx benchmark report archive

The repository keeps browser-ready pgrx benchmark reports by PostgreSQL version and UTC date-hour. Browse the benchmark results archive or open its HTML index .

Storage and maintenance wins

Result	Before → after flush	Trade-off
Total footprint (hot + cold)	5.85 GiB → 671 MiB	89% smaller
Hot in PostgreSQL (heap + `__cl`)	5.85 GiB → 72 MiB	99% smaller
Cold Parquet	— → ~599 MiB	Outside the database
Indexes (hot + `__cl`)	415 MiB → 11.5 MiB	97% smaller
`VACUUM (FULL, ANALYZE)`	158.7 s → 3.24 s	~49× faster

The VACUUM timing is specifically VACUUM (FULL, ANALYZE) — a whole-table rewrite. Routine autovacuum was disabled for the benchmark and is not covered by that number. Managed PostgreSQL sizes include the hot heap and koldstore.<table>__cl plus its indexes.

DML and query path (contextual)

Foreground DML and PK lookups are not guaranteed to improve. Mirror apply is reported separately as catch-up.

Operation	PostgreSQL only	KoldStore (WAL)	Notes
INSERT	100,809 ops/s	100,818 ops/s	≈ identical (fair WAL-retention seed)
UPDATE	81,791 ops/s	55,164 ops/s	Single sample; ~33% lower
DELETE	130,331 ops/s	145,691 ops/s	Do not claim faster from one sample
Hot-only PK lookup	3,851 ops/s	4,076 ops/s	≈ same (pre-flush full heap)
Hot+cold PK lookup	3,997 ops/s	1,055 ops/s	~74% slower vs full-heap baseline
Cold-only PK lookup	4,032 ops/s	662 ops/s	~84% slower vs full-heap baseline

Async insert mirror catch-up was ~32.7k ops/s in this run. Cold-path lookups compare Parquet merge against a full-heap PostgreSQL baseline.

How to run the benchmark yourself

The harness is scripts/run-storage-comparison.sh in the koldstore repository . It needs a local pgrx PostgreSQL (lab default pg16) and cargo-nextest.

Pick a row count with --rows:

BASH

1# Clone and enter the repo (source lives on GitHub)2git clone https://github.com/kalamdb/koldstore.git3cd koldstore4 5# Smoke (≈ minutes)6scripts/run-storage-comparison.sh --all-sides \7  --rows 100000 --hot-limit 10000 --dml-sample 10008 9# Medium10scripts/run-storage-comparison.sh --all-sides \11  --rows 1000000 --hot-limit 50000 --dml-sample 1000012 13# Published RESULTS scale (long)14scripts/run-storage-comparison.sh --all-sides --repetitions 1 \15  --rows 10000000 --hot-limit 100000 --dml-sample 50000

Flag	Meaning	Default
`--rows N`	Timed seed row count	`100000`
`--hot-limit N`	Rows kept hot after flush	`10000`
`--dml-sample N`	UPDATE/DELETE sample size	`1000`
`--all-sides`	Measure `pg` then `async` (isolated)	required with `--side` alternative
`--side pg\|async`	One column only
`--update-results`	Write `docs/benchmarks/RESULTS.md`
`--pg-version N`	pgrx major	`16`

Each side wipes ~/.pgrx/data-<ver> and re-initdbs so leftover WAL cannot skew insert timing. Methodology detail: docs/benchmarks/README.md in the repo.

How to read the numbers

Lead with storage + VACUUM when explaining the product
Do not market INSERT as faster than vanilla PostgreSQL
Expect cold PK latency until cold lookup work lands on the roadmap
Results vary by schema, hardware, storage backend, and workload