EGREFINE: An Execution-Grounded Optimization Framework for Text-to-SQL Schema Refinement
:::info Stub — Full Engineering Breakdown Coming This paper was auto-fetched from arXiv on 2026-05-04. A full breakdown with production viability rating, implementation notes, and honest limitations is being written. Subscribe to AI Letters → :::
| Authors | Jiaqian Wang et al. |
| Year | 2026 |
| Field | AI / ML |
| arXiv | 2605.00628 |
| Download | |
| Categories | cs.DB, cs.CL |
Abstract
Text-to-SQL enables non-expert users to query databases in natural language, yet real-world schemas often suffer from ambiguous, abbreviated, or inconsistent naming conventions that degrade model accuracy. Existing approaches treat schemas as fixed and address errors downstream. In this paper, we frame schema refinement as a constrained optimization problem: find a renaming function that maximizes downstream Text-to-SQL execution accuracy while preserving query equivalence through database views. We analyze the computational hardness of this problem, which motivates a column-wise greedy decomposition, and instantiate it as EGRefine: a four-phase pipeline that screens ambiguous columns, generates context-aware candidate names, verifies them through execution-grounded feedback, and materializes the result as non-destructive SQL views. The pipeline carries two structural properties: column-local non-degradation, ensured by the conservative selection rule in the verification phase, and database-level query equivalence, ensured by the view-based materialization phase. Together they make the resulting refinement safe by construction at the column level, with cross-column and prompt-level interactions handled empirically rather than analytically. Across controlled schema-degradation, real-world, and enterprise benchmarks, EGRefine recovers accuracy lost to schema naming noise where applicable and correctly abstains where the underlying task exceeds current Text-to-SQL capabilities, with refined schemas transferring across model families to enable refine-once, serve-many-models deployment. Code and data are publicly available at https://github.com/ai-jiaqian/EGRefine.
Engineering Breakdown
Plain English
This paper tackles a real production problem: text-to-SQL models fail when database schemas have confusing column names (abbreviations, inconsistent conventions, etc.). Rather than fixing queries after they're wrong, the authors flip the approach—they automatically rename schema columns to make them clearer, using a four-phase pipeline that generates candidate names, tests them against actual database execution, and ensures queries still produce the same results via database views.
Key Engineering Insight
The insight is treating schema refinement as an optimization problem with hard constraints (query equivalence must be preserved) rather than a heuristic rename task. By grounding verification in actual query execution rather than heuristics, they get concrete feedback on whether a rename actually improves model accuracy.
Why It Matters for Engineers
In production, database schemas are often poorly named legacy systems you can't easily change. This approach lets you automatically improve schema clarity without touching the actual database—you present cleaner names to the model via views while keeping the backend unchanged. That's pragmatic: it works with real messy data.
Research Context
Prior work treated schema as fixed and tried to make models smarter about bad names. This paper inverts that: keep the models standard, fix the schema representation instead. It advances text-to-SQL from purely downstream error correction to upstream data preparation, opening a new optimization frontier where you can systematically improve the input to any SQL-generation model.
:::tip Subscribe Get weekly breakdowns of papers like this in AI Letters - the newsletter for engineers building production AI systems. :::