Auditing Our Own Claims Found a Real Bug
Checking a 4-month-old blog post's memory claim against real measurement turned up two things: the claim was wrong, and the honest re-measurement exposed a live silent-data-corruption bug in eight places across the query engine.
Chasing qsv: What It Takes to Close a Single-Thread Parsing Gap
csvql started 1.9x behind qsv's Rust CSV parser on raw single-thread throughput. Two targeted fixes closed it to parity, one plausible-sounding optimization made things worse, and a bad first reading almost led to the wrong conclusion.
For Structured Data, Retrieval Accuracy Isn't a Model Problem
The AI industry is spending real money on reranking and hybrid search to push retrieval accuracy up a few points. For a table, exact SQL already gets you 100%, for free.
Closing the Loop: 18 of 19 Bugs Fixed, One Filed Honestly
The differential-testing bug hunt that started with one blog comment is done for now. 19 issues filed, 18 fixed and shipped across five point releases, one narrow gap filed rather than hidden.
When Does Converting a CSV to Parquet Actually Pay Off?
Converting to Parquet makes every later query faster, but the conversion itself isn't free. Measured the real breakeven point: 20 to 50 queries against the same file before that upfront cost pays for itself.
csvql vs pandas: Querying a CSV Without Loading It First
pandas needs to load the whole file into a DataFrame before you can ask it anything. csvql doesn't. That's 17 to 24x tuned, 50 to 76x against how most pandas code is actually written, plus about 4x less memory.
One Comment on a Benchmark Post Turned Into 18 Filed Bugs
A reader suggested adversarial CSV testing against DuckDB instead of trusting the happy path. It found 18 real bugs in csvql, 12 already fixed and shipped.
The Token Economics of Querying a CSV Instead of Pasting It
Pasting an 8 GB CSV into an LLM costs 230 million tokens and still doesn't fit. Querying it costs about 560 tokens, flat, regardless of file size.
Why csvql joins beat DuckDB by 50x while aggregates only beat it by 8x
Two query types, two different bottlenecks. What the parallel join probe actually changed, and why the same trick doesn't move the needle on a plain COUNT(*).
I Benchmarked My CSV Engine Against DuckDB on Its Own Dataset. It Found Two Bugs in Mine.
csvql queries raw CSV about 2.8x faster than DuckDB on an 8 GB file, using about 6x less memory and zero extra disk. The benchmark that proved it also surfaced two real bugs.