Text-to-SQL has recently achieved impressive progress, yet remains difficult to apply effectively in real-world scenarios. This gap stems from the reliance on single static workflows, fundamentally limiting scalability to out-of-distribution and long-tail scenarios. Instead of requiring users to select suitable methods through extensive experimentation, we attempt to enable systems to adaptively construct workflows at inference time. Through theoretical and empirical analysis, we demonstrate that optimal dynamic policies consistently outperform the best static workflow, with performance gains fundamentally driven by heterogeneity across candidate workflows. Motivated by this, we propose SquRL, a reinforcement learning framework that enhances LLMs' reasoning capability in adaptive workflow construction. We design a rule-based reward function and introduce two effective training mechanisms: dynamic actor masking to encourage broader exploration, and pseudo rewards to improve training efficiency. Experiments on widely-used Text-to-SQL benchmarks demonstrate that dynamic workflow construction consistently outperforms the best static workflow methods, with especially pronounced gains on complex and out-of-distribution queries. The codes are available at https://github.com/Satissss/SquRL
Figures & tables
Figure 1: Oracle dynamic workflow (red star) vs. static workflows.
Figure 2: Overview of the SquRL framework. Traditional approaches rely on a single fixed workflow to handle diverse query tasks. In contrast, SquRL dynamically constructs workflows tailored to each query, enabling more flexible, accurate, and robust SQL prediction.
Methods
Spider-Dev
Spider-Test
Bird-Dev
SynSQL
Easy
Moderate
Complex
Highly Complex
All
DIN-SQL
83.14
82.07
59.62
68.11
42.19
36.21
29.57
44.17
MAC-SQL
82.07
82.53
61.77
77.41
51.16
45.18
37.87
53.08
LinkAlign
81.94
81.79
59.75
65.12
47.51
46.18
32.26
47.92
RSL-SQL
84.30
83.74
65.82
78.01
61.46
50.83
38.54
57.42
CHESS
79.20
79.56
63.10
72.51
45.08
39.35
28.90
48.03
Table 1: Performance comparison across different Text-to-SQL benchmarks. For each query, we generate five workflows and select the final SQL result through majority voting based on the execution results.
Methods
Accuracy (%)
DIN-SQL + GPT-4o
1.46
CHESS + GPT-4o
3.83
DailSQL + GPT-4o
5.68
LinkAlign + Deepseek-R1
33.09
RSL-SQL + Deepseek-R1
33.09
SquRL-7B + Deepseek-R1
49.18
Table 2: Performance Comparison of Different Methods on Spider2.0-Lite benchmark.
API Backbone
Spider-Dev
Spider-Test
Bird-dev
Qwen-Plus
85.10
84.83
64.47
Qwen-Turbo
83.25
83.97
61.69
GLM-4.7
83.56
82.78
63.14
Deepseek-V3.2
85.80
85.95
63.10
Table 3: Impact of backend models on SquRL performance. We use Qwen2.5-1.5B-Instruct as the policy model with different backend models executing the generated workflows during training.
Figure 3: Performance comparison with and without Dynamic Actor Masking (DAM) across different retention rates.
Methods
Spider-Dev
Bird-Dev
True Only
82.71
63.61
10% Pseudo
85.10
64.47
30% Pseudo
80.30
61.50
Table 4: Performance comparison with different p ratios.
Method
Acc.(%)
Format Err.(%)
Time(s)
All
83.27
0.29
4.41
w/o SFT
78.94
1.26
5.26
w/o RL
77.37
3.87
10.51
w/o both
18.47
77.37
7.19
Table 5: Ablation study isolating the contributions of SFT and RL in SquRL. Removing either component degrades performance, with the combined removal reducing the system to a generic instruction-following model.
Appendix figures & tables2 assets
Supplementary material from the paper’s appendix.
Appendix
Figure 4: Pairwise distance matrix between different workflows.
Figure 5: Performance metrics across task difficulty levels. (Left) Max/min execution times versus task difficulty (measured by number of capable workflows). (Right) Case distribution and time reduction by difficulty. Easier tasks (left) show greater time variation and more samples, while harder tasks (right) demonstrate convergent execution times.
Text-to-SQL enables users to access relational databases via natural language, but real-world settings remain challenging due to coordinated reasoning over complex database environments. Existing systems often use multi-stage pipelines or reasoning models specialized for individual stages. However, fixed pipelines rely on predefined stage orders, limiting their adaptivity to query demands and intermediate evidence. Recent orchestration-based methods provide flexibility by composing specialized modules for each query, but typical plan-then-execute approaches still commit to a complete workflow before execution and cannot adapt to intermediate artifacts and feedback. In this paper, we propose SQLConductor, a step-wise orchestration learning framework for Text-to-SQL. SQLConductor formulates Text-to-SQL subtasks as specialized actions for workflow composition and trains a policy model to select the next action based on intermediate artifacts and feedback. To learn this policy, SQLConductor introduces Search-to-Policy Learning, which uses Monte Carlo Tree Search to explore candidate workflows and stability estimation to identify robust supervision. The policy model is trained with Stability-weighted Supervised Fine-tuning to prioritize high-quality orchestration patterns and further enhanced through Curriculum Reinforcement Learning. This transforms offline workflow search into a deployable policy for step-wise orchestration at inference time. Experiments on BIRD-Dev and out-of-distribution datasets show that SQLConductor achieves superior execution accuracy and strong generalization, reaching 73.2% EX on BIRD-Dev with a compact orchestration policy coordinating frozen larger action models, outperforming prior methods that directly train comparable or larger Text-to-SQL backbones. Further analyses show that the learned policy adapts orchestration to diverse query demands.
Large Language Models (LLMs) have recently improved Text-to-SQL generation, but their computational cost can hinder deployment in resource-constrained settings. This paper evaluates the Text-to-SQL capabilities of small and medium open-source LLMs (1B-8B parameters) under a controlled inference budget, focusing on how model specialization and prompt formulation affect performance. Using the Spider benchmark, we compare multiple prompt representations and assess the accuracy of generated queries. Our results show that SQL-specialized models are consistently more reliable than general-purpose and chat-oriented models at small scales, and that performance can vary substantially depending on the prompt used. To reduce this variability without resorting to larger models, we introduce three lightweight inference workflows that automatically retry with alternative prompts and/or models when failures occur, including an optional syntax-correction step. These workflows significantly improve end-to-end success rates, with a trade-off in additional inference calls. These results demonstrate a practical path to stronger Text-to-SQL performance with small LLMs, by trading modest additional inference cost for higher reliability.
Large language models have achieved remarkable progress on Text-to-SQL through reasoning-enhanced fine-tuning, yet existing approaches predominantly rely on massive instruction corpora under the assumption that scale drives performance. We challenge this paradigm by investigating a fundamental question: what is the minimal data requirement for effective Text-to-SQL instruction tuning? We propose LIMIT(Less Is More for Instruction Tuning in Text-to-SQL), a data-centric framework that demonstrates strong database reasoning can emerge from an extremely compact training set when examples are strategically selected. LIMIT operates through four stages: difficulty-aware filtering that identifies samples within the model's learning frontier, chain-of-thought synthesis with consistency-based selection, multi-dimensional quality scoring via LLM-as-judge, and genetic algorithm optimization that jointly maximizes schema coverage and sample quality. On the BIRD and Spider benchmark, LIMIT selects only 796 and 863 samples while achieving 100% table coverage, enabling Qwen3-8B to reach 69.1% and 88.9% execution accuracy.This result surpasses methods trained on 20 times more data and establishes a new state-of-the-art among open-source approaches. Our findings suggest that careful data curation, rather than scale, is the key to efficient Text-to-SQL learning.