💬 NLP

Learning When to Reason for Text-to-SQL via SFT and DPO

The paper proposes AutoThinkSQL, a framework that integrates Supervised Fine-Tuning and Direct Preference Optimization to enable Text-to-SQL models to dynamically decide when to invoke Chain-of-Thought reasoning based on query complexity, thereby achieving higher accuracy on benchmarks like Spider and BIRD while significantly reducing inference overhead compared to forced reasoning approaches.

Original authors: Soohyuk Jang, Jiheum Yeom, Nohil Park, Sang Hun Kim, Yoonyoung Choi, Kiwook Bae, Sungroh Yoon

Published 2026-07-28

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Soohyuk Jang, Jiheum Yeom, Nohil Park, Sang Hun Kim, Yoonyoung Choi, Kiwook Bae, Sungroh Yoon

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a super-smart robot how to talk to a giant library of information. This field is called "Text-to-SQL," where you ask a question in plain English, and the robot translates it into a special code (SQL) that the database understands to find the answer. For a long time, the best way to teach these robots was to force them to "think out loud" before answering. They would write down a long, step-by-step logic chain, like a student showing all their math work on a test. This method, known as Chain-of-Thought (CoT), is great for solving tricky, complex puzzles. However, it's also slow and wasteful. If you ask the robot a simple question like "What is the capital of France?", making it write a whole essay on geography just to say "Paris" is a huge waste of time and energy. It's like using a sledgehammer to crack a peanut.

The big question researchers have been asking is: Can we teach a robot to know the difference between a peanut and a boulder? Can it learn to skip the long thinking process for easy questions and only use its heavy brainpower when it really needs to? This is exactly what the paper "Learning When to Reason for Text-to-SQL via SFT and DPO" tackles. The authors, a team from Seoul National University and Samsung Electronics, built a new system called AutoThinkSQL. Instead of forcing the robot to think every single time, they taught it to be a smart manager that decides, "Do I need to think hard for this, or can I just give the answer?"

Here is how they did it and what they found. They trained their robot using a two-step process. First, they used a method called Supervised Fine-Tuning (SFT). Imagine showing the robot thousands of examples of questions and answers. For the easy ones, they showed it the answer without any thinking steps. For the hard ones, they showed it the answer with the thinking steps. Crucially, they taught the robot to look at the question first and decide which style to use. Then, they used a second step called Direct Preference Optimization (DPO). This is like a coach giving feedback: "Good job skipping the thinking on that easy one!" or "You should have thought harder on that tricky one!" This helped the robot get even better at knowing when to switch modes.

The results were impressive. When they tested their new AutoThinkSQL robot on two major benchmarks (Spider and BIRD), it didn't just get better at answering; it got faster and used less energy. Compared to robots that were forced to "think out loud" for every single question, AutoThinkSQL reduced the number of words it had to generate by 24.6% on the Spider test and 18.3% on the BIRD test. Because it wrote less, it also finished its tasks faster, cutting the waiting time (latency) by 17.1% and 11.5% respectively.

Most importantly, the robot didn't sacrifice accuracy. It still got the right answers just as often as the slow, over-thinking robots. The team analyzed the robot's behavior and found that it had truly learned to match its effort to the difficulty of the question. On easy questions, it almost always skipped the thinking steps. As the questions got harder, it started using the "think out loud" method more often. It's like a student who knows when to just write down the answer for a simple addition problem but knows to pull out a calculator and show their work for a complex algebra equation.

The paper suggests that this "adaptive" approach is the future. It argues that forcing a model to always reason is wasteful and can even introduce errors on simple tasks. By teaching the model to choose its own strategy, AutoThinkSQL proves that you can have the best of both worlds: high accuracy for complex problems and lightning-fast speed for simple ones. The authors note that while this works great on the datasets they tested, there is still more to explore with different types of databases and even larger robot brains. But for now, they've shown that knowing when to think is just as important as knowing how to think.

Technical Summary: Learning When to Reason for Text-to-SQL via SFT and DPO

Problem Statement

Recent advancements in Text-to-SQL have heavily relied on reasoning-centric paradigms, particularly Chain-of-Thought (CoT) prompting and Reinforcement Learning (RL). While these methods bridge the semantic gap between complex user intents and intricate database schemas, yielding substantial accuracy gains on challenging benchmarks, they introduce a critical inference-time bottleneck. A significant portion of real-world Text-to-SQL queries are simple lookups or single-table aggregations that can be resolved via straightforward schema linking without multi-step deduction. Forcing models to generate verbose reasoning traces for such simple queries wastes inference budget, increases latency, and can introduce syntactic noise or hallucinations. Current fine-tuning approaches generally lack the ability to adaptively decide when to invoke reasoning, often applying CoT uniformly regardless of query difficulty.

Methodology: AutoThinkSQL

The authors propose AutoThinkSQL, a framework that integrates an adaptive "auto-thinking" mechanism into both Supervised Fine-Tuning (SFT) and Direct Preference Optimization (DPO). The core objective is to equip Large Language Models (LLMs) with the intrinsic ability to bypass CoT for simple queries while reserving deep reasoning for complex tasks.

1. Problem Formulation

The task involves generating a valid SQL query ( $y$ ) given a natural language question, database schema, and external knowledge ( $x$ ). The framework utilizes mode-specific format prompts:

$p_{NC}$ (No-CoT): Instructs direct SQL generation.
$p_{C}$ (CoT): Requires step-by-step reasoning before SQL generation.
$p_{Auto}$ (Auto-Think): Instructs the model to first assess query complexity and then choose between direct generation or a reasoning chain.

2. Two-Stage Training Pipeline

Stage 1: Auto-thinking SFT

Data Construction: For each training instance, the model generates 16 independent rollouts under both $p_{NC}$ and $p_{C}$ .
Mode Assignment: A training mode $m^*$ $m^{*}$ is assigned based on the success of these rollouts:
- If all 16 No-CoT rollouts are correct ( $N_{NC}=16$ ), the instance is labeled as No-CoT.
- If No-CoT fails but at least one CoT rollout succeeds ( $N_{NC}<16 \land N_C>0$ ), the instance is labeled as CoT.
- Otherwise, the instance is discarded.
Training: The model is fine-tuned on pairs of $(x, p_{Auto}, y_{m^*})$ , where $y_{m^*}$ is a sampled correct response from the assigned mode. This teaches the model to autonomously select the appropriate output style based on the input prompt.

Stage 2: Auto-thinking DPO

Data Construction: Using the SFT-trained model, new rollouts are collected under $p_{NC}$ $p_{N C}$ and $p_{C}$ $p_{C}$ . Preference pairs $(y_w, y_l)$ $(y_{w}, y_{l})$ are constructed based on mutually exclusive rules regarding the correctness of No-CoT ( $N_{NC}$ $N_{N C}$ ) and CoT ( $N_C$ $N_{C}$ ) rollouts:
- If $N_{NC}=16$ and $N_C < 16$ , No-CoT is preferred over CoT to discourage unnecessary reasoning.
- If both modes succeed ( $N_{NC}=16, N_C=16$ ), No-CoT is preferred to minimize token usage.
- If only one mode succeeds, the successful response is preferred.
- If both fail or both succeed with equal difficulty, pairs are sampled or discarded to maintain balance.
Training: The model is optimized using the standard DPO objective to align with these preferences, further refining the decision boundary between reasoning and non-reasoning modes.

Key Contributions

Consistent Performance Gains: AutoThinkSQL achieves strong execution accuracy on both the Spider and BIRD benchmarks across different decoding regimes (Greedy and Majority Voting). Unlike single-mode baselines (CoT-only or No-CoT-only) which show clear weaknesses in specific settings, AutoThinkSQL remains robust.
Inference Efficiency: The framework significantly reduces computational costs. Compared to CoT-only generation, AutoThinkSQL reduces average output tokens by 24.6% (Spider) and 18.3% (BIRD), and reduces average latency by 17.1% (Spider) and 11.5% (BIRD), without sacrificing accuracy.
Adaptive Routing Analysis: The authors verify that the model learns to align its reasoning decisions with query difficulty. Analysis shows a monotonic trend where the CoT trigger rate increases as query difficulty rises (from Easy to Extra Hard), confirming that efficiency gains stem from meaningful behavioral alignment rather than random skipping.

Experimental Results

Evaluated on the Qwen3-Coder-30B-A3B backbone:

Accuracy: AutoThinkSQL (SFT+DPO) achieved the highest execution accuracy in three of four evaluation settings (Spider Greedy: 86.20%, BIRD Greedy: 58.23%, BIRD Maj@8: 60.27%). On Spider Maj@8, it reached 86.78%, comparable to the best CoT-only baseline (87.07%).
Efficiency: The model substantially lowered inference-time costs. For instance, on the Spider dev set, AutoThinkSQL SFT+DPO used 24.9% fewer tokens than the CoT-only SFT+DPO counterpart.
Generalization: The method generalized consistently across benchmarks with different difficulty distributions (Spider's balanced difficulty vs. BIRD's heavy skew and external knowledge requirements).

Significance and Claims

The paper claims to present the first Text-to-SQL framework to integrate auto-thinking mechanisms into both SFT and DPO. The authors argue that by learning when to invoke CoT, AutoThinkSQL resolves the trade-off between the high accuracy of reasoning-heavy methods and the efficiency of direct generation. The work demonstrates that single-mode training (forcing CoT or No-CoT) creates decoding-dependent limitations, whereas adaptive routing allows models to remain competitive across diverse evaluation settings.

The authors note limitations, including the focus on specific benchmarks (Spider, BIRD) and the use of rollout-based supervision for mode assignment, suggesting future work could explore more lightweight heuristics and cross-family generalization to other code-specialized LLMs. They also highlight potential risks where the auto-thinking mechanism might incorrectly bypass reasoning for queries deemed simple, potentially reducing interpretability and making error detection harder, recommending human review for high-stakes deployments.