Text-to-SQL: Natural Language to SQL Mapping

Updated 18 January 2026

Text-to-SQL is the process of converting natural language into valid SQL queries, enabling non-experts to interact with relational databases.
State-of-the-art approaches use pre-trained language models, graph-based encoders, and ensemble techniques to manage complex schema linking and SQL composition.
Evaluation metrics like Exact Match and Execution Accuracy, along with benchmarks such as Spider, drive robust improvements and practical deployment in varied domains.

The Text-to-SQL task is the automatic mapping of natural language utterances into executable Structured Query Language (SQL) queries over relational databases. This capability underpins natural language interfaces to structured data, crucial for non-expert access to information across scientific, business, and domain-specific contexts. State-of-the-art approaches leverage large pre-trained LLMs, neural schema linking, graph-based encoders, structured prompt engineering, and post-processing mechanisms to address the considerable challenges posed by varied schemas, complex SQL composition, and cross-domain generalization.

1. Problem Definition, Benchmarks, and Core Evaluation Metrics

Formally, the task is to learn a mapping from a natural language input $x$ (single utterance or conversational context) to the correct SQL query $y$ , possibly conditioned on an explicit database schema $D$ , maximizing $P(y \mid x, D)$ (Qin et al., 2022). The output must be grammatically valid, executable SQL that, when run on the target database, returns the expected answer.

Benchmark Datasets:

Spider: Cross-domain, 10k+ multi-table queries, hundreds of unique schemas, mixes nested queries, aggregations, diverse SQL constructs.
BIRD: Large-scale (~12k instances), real-world databases, high schema and linguistic complexity, targets reasoning and scalability (Xie et al., 19 Feb 2025).
Domain-Specific: PT-EN process mining (text-2-SQL-4-PM) (Yamate et al., 18 Aug 2025), EHRSQL for clinical QA (Lee et al., 2024), finance (Song et al., 2023), and others.

Primary evaluation metrics:

Exact Match (EM): Syntactic match of predicted and gold SQL.
Execution Accuracy (EX): Semantic match (identical DB results).
Test-suite accuracy (TS): Coverage via execution of multiple test cases.
Domain-specific: Reliability Score (RS), Valid Efficiency Score (VES), static similarity metrics (e.g., Tree Similarity Edit Distance, TSED) for non-executable settings (Song et al., 2023).

SQL query hardness is annotated on benchmarks like Spider, stratifying simple to extra-hard queries by number of clauses, JOINs, and nesting (Yi et al., 2023).

2. Key Subtasks: Schema Linking, SQL Generation, and Error Mitigation

Schema Linking and Representation

Accurate mapping between linguistic entities in the question and database elements (tables, columns, values) is critical. Techniques include:

Embedding-based similarity scoring for schema elements, with cosine or Poincaré distance metrics (Guo et al., 2023, Piao et al., 10 Oct 2025).
Graph-based schema representations (heterogeneous graphs, relational GNNs) incorporating database structure (primary/foreign keys), text, and question tokens, for robust multi-hop relational reasoning (Li et al., 2023).
View-based schemas, collapsing multi-table JOINs into virtual views to reduce complexity and token noise (You et al., 2024).
Semantic-enhanced schemas, directly exposing representative column values in prompts (Li et al., 2024).
Dynamic filtered schema extraction using retrieval and selection pipelines. Filtering balances context length against coverage and influences downstream accuracy (Liu et al., 7 Jul 2025, Piao et al., 10 Oct 2025).

SQL Generation (Modeling and Prompting)

Approaches span:

End-to-end autoregressive sequence models, often pre-trained (T5, BART, Qwen2.5-Coder, LLaMA) and fine-tuned on NL→SQL pairs.
Constrained decoding to ensure SQL grammar validity and logical correctness (e.g., PICARD).
Chain-of-thought (CoT) prompting and intermediate "SQL-Like" skeleton generation, guiding models to reason about the intent and structure before producing valid SQL (Xie et al., 19 Feb 2025).
Multi-stage or multi-agent architectures for progressive refinement, with explicit modules for extraction, generation, and verification (Liu et al., 7 Jul 2025, Xie et al., 19 Feb 2025, Tripathi et al., 8 Aug 2025).
Ensemble and reranking: Multi-generator frameworks output multiple candidates, with learned or rule-driven selection over execution-equivalent clusters (Liu et al., 7 Jul 2025, Zeng et al., 2022).

Post-Processing and Error Handling

Post-generation techniques address:

Bias-elimination: Targeting systematic model tendencies (e.g., casing, JOIN style) via dedicated bias eliminators or EPIs (error-prevention instructions) (Liu et al., 2024, Li et al., 2024).
Adaptive refinement: Execution-based self-correction, either via explicit agent loops or reinforcement-trained models, yielding significant gains in EX with minimal increase in inference cost (Li et al., 2024, Piao et al., 10 Oct 2025).
Fallback strategies: Iteratively expanding schema portions in prompts (from filtered to full schema) upon failure, bounded to avoid infinite loops (Guo et al., 2023).
Consistency alignment and voting: Mechanisms to resolve ambiguous cases, hallucinations, or low-confidence predictions using agent alignment modules or answer clustering (Xie et al., 19 Feb 2025).

3. Modeling Advances: Graph-Based, Reward-Driven, and Modular Architectures

Recent progress capitalizes on architectural and algorithmic innovations:

Graph-Neural and Hybrid Models

Graphix-T5 augments the encoder with relational graph attention layers, tightly coupling semantic and structural representations to boost multi-hop schema linking and compositional SQL generation. Ablations demonstrate superior robustness to schema perturbations compared to baseline transformers and naïve encoder-GNN hybrids (Li et al., 2023).

Multi-Stage Specialization and Decoupling

Specialist routing: Hardness-aware decoupling routes each query to a specialist generator, decomposing the multi-hardness task into single-hardness submodels and reducing parsing load, especially effective for extra-hard queries (Yi et al., 2023).
View-based abstraction: V-SQL's staged approach—sketch generation over simplified (view) schemas, followed by expansion to original schemas—effectively reduces join hallucinations and supports challenging multi-table queries (You et al., 2024).

RL and Reward-Based Optimization

Partial reward sets: Beyond binary execution, hybrid reward signals (schema linking, n-gram, syntax, AI-judgment) provide dense credit assignment, enabling fine-grained policy optimization that encourages explicit decomposition and strong generalization (Pourreza et al., 29 Mar 2025, Stoisser et al., 23 Apr 2025).
GRPO: Group relative policy optimization shapes model behavior by leveraging candidate-wise relative rewards within sampled groups, yielding stable improvements over pure SFT and standard PPO (Pourreza et al., 29 Mar 2025, Stoisser et al., 23 Apr 2025).

Multi-Agent and Ensemble Pipelines

XiYan-SQL demonstrates that schema filtering, style-diverse generator ensembles, and candidate reorganization with execution-based clustering and learned selection deliver new state-of-the-art accuracy on challenging real-world benchmarks (Liu et al., 7 Jul 2025).
OpenSearch-SQL establishes a robust agent-based protocol emphasizing modular alignment, structured CoT, and self-consistency voting to systematically reduce hallucinations and instruction-following failures (Xie et al., 19 Feb 2025).

Error-Prevention and Consistency Testing

EPI-SQL leverages error-prevention instructions (EPIs) mined from systematic model failures, both general and contextualized, to regularize prompt-driven generation and approach few-shot SOTA performance in a purely zero-shot regime (Liu et al., 2024).
Metamorphic testing (MT-Teql) leverages semantics-preserving transformations on NL queries and schemas to expose and reduce model inconsistency, providing rigorous invariance-based QA and data augmentation for greater robustness (Ma et al., 2020).

4. Domain Adaptation, Robustness, and Reliability

Cross-Domain and Task-Specific Adaptation

Datasets tailored for process mining (Yamate et al., 18 Aug 2025), financial systems (Song et al., 2023), and electronic health records (Lee et al., 2024) stress generalization to non-standard schemas, domain-specific vocabulary, and complex analytical tasks (e.g., temporal constraints, conformance checking).
For domains with stability, privacy, or latency constraints, resource-efficient open-source models (e.g., Qwen2.5-Coder 7B in LitE-SQL) plus vector-based schema retrieval systems have achieved accuracy on par with massively larger LLMs, reducing dependency on proprietary APIs (Piao et al., 10 Oct 2025).

Robustness to Linguistic and Schema Variation

Systematic rephrasing of inputs (via LLM paraphrasers) can increase execution match by >10% on competitive models, highlighting surface-form sensitivity (Song et al., 2023).
Multi-turn and conversational parsing approaches (e.g., CQR-SQL) leverage schema-grounded recursive reformulation to resolve coreference and ellipsis without full pipeline decoupling, achieving new bests on SParC and CoSQL (Xiao et al., 2022).
Metamorphic testing with formalized relations (e.g., prefix operations, schema normalization/shuffling) uncovers 40%+ of latent model inconsistencies that traditional metrics miss (Ma et al., 2020).

Safety, Abstention, and Reliability Metrics

EHRSQL introduces abstention-aware evaluation (Reliability Score), incentivizing models to "know when not to answer" and abstain when questions are unanswerable or likely to be wrongly answered, crucial for clinical deployments (Lee et al., 2024).

5. Cost, Practical Integration, and Assessment

Cost-Efficiency and Practical Deployment

SEA-SQL demonstrates that adaptive bias elimination, semantic-enhanced schemas, and dynamic execution refinement enable GPT-3.5 to approach (and sometimes exceed) GPT-4 accuracy at 1–5% of cost (Li et al., 2024).
Modular agent and selection-based ensembles within frameworks such as XiYan-SQL and OpenSearch-SQL, when coupled with schema filtering, control memory and latency by balancing prompt length with recall (Liu et al., 7 Jul 2025, Xie et al., 19 Feb 2025).

Candidate Reranking and Self-Consistency

N-best reranking leverages query-planning and schema-linking heuristics for an absolute 2–3% gain in execution accuracy, with oracle upper bounds ≥7% above single-best baselines (Zeng et al., 2022).
Contextual voting strategies and multiple self-correction rounds are integrated in OpenSearch-SQL, XiYan-SQL, and LitE-SQL pipelines, with ablations revealing that candidate diversity and reranking mechanisms are critical to closing the gap to oracle accuracy (Liu et al., 7 Jul 2025, Piao et al., 10 Oct 2025).

Evaluation and Metric Innovations

For production scenarios lacking DB access, structural similarity metrics such as TSED (tree similarity edit distance) and SQAM (clause-wise matching), grounded in formal parse tree comparisons, offer evaluation highly correlated (PCC ≈ 0.95) with true execution correctness (Song et al., 2023).

6. Challenges, Limitations, and Emerging Directions

Despite rapid progress, significant challenges persist:

Complex schema linking: Errors in mapping question tokens to schema elements remain the leading cause of failure, especially for large or denormalized databases (Li et al., 2024, Piao et al., 10 Oct 2025).
Scalability and token budgets: Prompt-based approaches are constrained by LLM context windows, driving the need for ever more aggressive schema filtering and summarization (Guo et al., 2023, Liu et al., 7 Jul 2025).
Abstention and real-world safety: No current system achieves error-free operation under maximal-penalty reliability metrics in clinical or safety-critical domains (Lee et al., 2024).
Cross-model and task transfer: Open challenges remain in aligning error-prevention or bias-elimination pipelines to unrelated LLMs or code-generation tasks.
Analysis and error diagnosis: Many recognized errors (e.g., redundant columns, JOIN misplacement, compositional ambiguities) evade detection by traditional EM or EX metrics, motivating richer test-suite evaluations and robust rule-mining (Zeng et al., 2022, Song et al., 2023).

Current research trajectories focus on:

Deeper integration of symbolic planners and execution-guided decoding to further reduce hallucination and logical invalidity (Guo et al., 2023).
Automatic schema summarization and view discovery for more scalable, context-efficient prompting (You et al., 2024).
Automated reward design and meta-learning for continuous adaptation of RL-based frameworks (e.g., adaptive weighting of partial rewards in Reasoning-SQL) (Pourreza et al., 29 Mar 2025).
Expansion to multi-modal and multi-database settings, where automated target database selection and multi-agent error correction pipelines are critical (Tripathi et al., 8 Aug 2025).
Unified frameworks for error prevention, knowledge-augmented prompting, and robust abstention to meet the reliability requirements of real-world applications.

7. Summary Table: Representative Modeling Paradigms and Benchmarks

Approach	Main Principle/Innovation	Key Result(s) (%)
Graphix-T5 (Li et al., 2023)	Graph-aware encoder, pre-trained transformer	+6.6 EX Spider-dev over T5-large
OpenSearch-SQL (Xie et al., 19 Feb 2025)	Multi-agent modularity, SQL-Like skeleton	72.28 EX (BIRD), SOTA at submission
XiYan-SQL (Liu et al., 7 Jul 2025)	Ensemble, schema filtering, learned selector	75.63 EX (BIRD), 89.65 EX (Spider)
V-SQL (You et al., 2024)	View-based, two-stage prompt/expansion	45.4–56.0 EX (Bird mini-dev), matched TA-SQL
SEA-SQL (Li et al., 2024)	Semantic schema, bias elimination, exec. adj.	83.6 EX (Spider), 56.13 ACC (BIRD), <5% GPT-4 cost
LitE-SQL (Piao et al., 10 Oct 2025)	Vector DB schema retrieval, lightweight LLM	88.45 EX (Spider), 72.10 EX (BIRD) on 7B model
Reasoning-SQL (Pourreza et al., 29 Mar 2025)	RL w/ partial rewards, GRPO	72.78 EX (BIRD test, 14B), superior to o3-mini
SQL-o1 (Lyu et al., 17 Feb 2025)	MCTS self-reward agent search	66.7 EX (BIRD-dev, Qwen2.5-7B), SOTA
EPI-SQL (Liu et al., 2024)	Contextual error-prevention instructions	85.1 EX, 77.9 TS (Spider-dev, GPT-4, zero-shot)

These results confirm that advances in neural modeling, prompt engineering, schema abstraction, RL-driven optimization, and structured post-processing have collectively reshaped the landscape of Text-to-SQL, with modular systems delivering transparent, high-accuracy performance across diverse and challenging domains. Continued progress will require tighter integration across these paradigms, stronger learning under guidance from task-specific feedback, and rigorous assessment tailored to real-world reliability requirements.