hari-krishna-ai/enterprise-text-to-sql-benchmark

Enterprise Text-to-SQL Benchmark

3,087 natural-language questions paired with executable PostgreSQL, over a 12-table enterprise schema (sales, catalogue, logistics, HR).

Built to answer one question honestly: does fine-tuning actually improve text-to-SQL? On this benchmark, a QLoRA fine-tune of Qwen3-8B took strict execution accuracy from 43.71 % to 68.43 %, and 70.86 % with a self-correction loop — and the benchmark is designed so that number cannot be inflated by leakage or by string-matching.

split	rows	templates
train	2,175	79
validation	459	52
test	453	48

This is version 2 of the benchmark. Version 1 had a flaw worth understanding before you use either: many of its questions — "Show orders placed in 2023" — never say which columns to return, so a model that found exactly the right rows scored zero for picking a different column list. That made the v1 base model look far worse than it was (10.82 %) and the fine-tuning gain look far larger than it was (+40 pp).

v2 fixes this by five documented rules: whole row (SELECT *) when no columns are named, consistent money and month conventions, one ambiguous paraphrase reworded, and five train-only templates covering PARTITION BY and day arithmetic. The test split is pinned to v1 — same 453 ids, same 48 templates, 445 of 453 questions byte-identical — so the two versions are directly comparable and v2 is not an easier test set.

All three splits share zero templates with each other — 74 / 52 / 48, no overlap in any pair. Splitting is by template equivalence group, never by row, so the test set measures generalisation to query patterns the model has never seen, not to new slot values inside familiar ones.

from datasets import load_dataset

ds = load_dataset("hari-krishna-ai/enterprise-text-to-sql-benchmark")
print(ds["test"][0]["question"])   # "Show orders placed in 2023."
print(ds["test"][0]["sql"])        # SELECT order_id, customer_id, ...

---

Why this exists

Most text-to-SQL benchmarks score by comparing SQL strings. That is wrong in both directions: it marks correct queries wrong for cosmetic differences, and it cannot tell you whether a query would actually run.

These two are different strings and identical in meaning, and any sane benchmark must count both as correct:

SELECT COUNT(*)           FROM customers WHERE country = 'India';
SELECT COUNT(customer_id) FROM customers WHERE country = 'India';

So every example here ships an execution fingerprint — an MD5 over the sorted, stringified rows the gold query returned against the reference database. Correctness means your query returns the same result set, not that it looks similar.

---

Fields

field	type	meaning
id	string	stable identifier, e.g. bench-000322
question	string	the natural-language question
sql	string	gold PostgreSQL query
difficulty	string	easy / medium / hard / very_hard / enterprise
domain	string	sales, catalogue, logistics, hr
template_id	string	generating template — the unit splits are made on
phrasing_index	int	which paraphrase of the template this is
slot_values	dict	the values substituted into the template
referenced_tables	list	tables the gold query touches
execution	dict	row_count, columns, fingerprint, latency_ms
split	string	train / validation / test

The execution.fingerprint is what makes execution-based scoring possible without shipping a database dump.

Difficulty tiers

tier	n (test)	what it exercises
easy	126	SELECT, WHERE, ORDER BY, LIMIT
medium	63	GROUP BY, HAVING, COUNT/SUM/AVG
hard	144	joins, multiple joins, subqueries, CTEs
very_hard	36	window functions, nested aggregation, date arithmetic
enterprise	84	ambiguous terminology, NULL handling, business rules

---

The database

schema.sql rebuilds it; schema_context.txt is the rendered schema that was put in the model's prompt (fingerprint d03619e711661bc5, 5,455 characters).

12 tables, ~328,000 rows, all synthetic — no real personal data. Generation uses a fixed seed, so the database is reproducible, which is what makes the execution fingerprints meaningful.

table	rows		table	rows
customers	12,000		order_items	154,069
orders	55,000		payments	57,088
products	2,500		shipments	40,850
categories	120		inventory	6,266
suppliers	250		employees	500
warehouses	15		departments	12

Dates are anchored to a fixed DATA_AS_OF constant rather than NOW(), so questions like "orders in the last 90 days" have a stable answer instead of one that changes overnight.

---

Results on this benchmark

Qwen3-8B, evaluated by execution against the reference database. Five configurations, same questions, same harness — only the named component changes.

metric	base	fine-tuned	FT + repair
strict execution accuracy	43.71 %	68.43 %	70.86 %
projection-tolerant	47.68 %	68.43 %	70.86 %
executable SQL	95.58 %	94.48 %	98.23 %
schema hallucination	0.22 %	3.75 %	0.66 %

What that gain is, stated honestly. Replaying the v1 pipeline's predictions against this benchmark's gold gives 40.18 % strict, against 70.86 % for the v2 pipeline — but wrong_rows, the count of genuinely wrong answers, goes 85 → 84 and row-level accuracy holds at ~78 %. The headline moved 30 points because the benchmark and the prompt stopped disagreeing about what a correct answer looks like, not because the SQL got better. If you benchmark a model here, report projection-tolerant accuracy alongside strict or you will draw the same wrong conclusion v1 did.

Adapter: hari-krishna-ai/qwen3-8b-text2sql-qlora

A property of this benchmark worth knowing before you use it

35 % of the test set does not specify which columns to return. "Show orders placed in 2023" never says whether you want the order id alone or five columns. So a model can retrieve exactly the right rows and still fail a strict result-set comparison.

That is why two accuracy figures are reported. Projection-tolerant accuracy wraps the prediction in a subquery and asks it for the gold columns, isolating "wrong columns" from "wrong rows":

failure mode	base model	fine-tuned
right rows, wrong columns	159	0
genuinely wrong rows	240	203

Reporting strict accuracy alone would have made fine-tuning look like a reasoning breakthrough. It is mostly the model learning this database's column conventions — a real thing to learn, and not the same thing. If you benchmark on this dataset, report both numbers.

---

How it was built

1. Templates — parameterised question/SQL pairs across four domains and five difficulty tiers, each with multiple natural paraphrasings.
2. Slot values sampled from the live database, using interior quantiles so thresholds land inside the real data distribution. A benchmark full of predicates that match zero rows measures nothing.
3. Every gold query executed against the reference database; the result set is fingerprinted and stored. Queries that error are rejected, not shipped.
4. Validation — 3,087 of 3,087 examples pass parse, schema-grounding and execution checks.
5. Split by template equivalence group. All paraphrases and all slot variants of one template land in the same split, which is what makes the zero-template-overlap guarantee hold.

Deliberate inclusions: some questions correctly return zero rows, so a model cannot assume every answer is non-empty.

---

Limitations

Stated plainly, because they bound what a score on this dataset means.

• Template-generated, not human-written. Questions come from 74 / 52 / 48 templates with paraphrasing. Real users write abbreviations, typos and genuinely ambiguous requests. This is the largest caveat: a high score here does not establish robustness to real phrasing.
• One schema, 12 tables. Small for an enterprise database. Schema-retrieval techniques that pay off at 200 tables hurt here — measured, twice.
• Synthetic data. Realistic distributions, but not real business data.
• Single gold query per question. Where several correct formulations exist, execution-fingerprint matching handles them; where a question is genuinely ambiguous about columns, use the projection-tolerant metric.
• English only.

Intended use

Evaluating and fine-tuning text-to-SQL models where executability and result correctness matter more than surface similarity. Also usable as SFT data — the chat rendering used to train the adapter above is reproducible from these files plus the prompt template, and is not shipped separately because it would duplicate the 5.5 KB schema into every one of 2,133 records.

Licence

Apache 2.0. All data synthetic; no personal information.