SLM-SQL: An Exploration of Small Language Models for Text-to-SQL

Lei Sheng; Shuai-Shuai Xu

REVIEW 4 major objections 6 minor 25 references

SLM-SQL: An Exploration of Small Language Models for Text-to-SQL

T0 review · 4 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Small language models post-trained on synthetic reasoning data can match or surpass 7B–32B models on the BIRD text-to-SQL benchmark.

desk verdict Plausible and useful if true, but the paper's own tables contradict each other on the main result, so the headline BIRD numbers are not yet established. read the letter →

arxiv 2507.22478 v1 pith:N3HB53PL submitted 2025-07-30 cs.CL

Lei Sheng , Shuai-Shuai Xu This is my paper

classification cs.CL

keywords Text-to-SQLsmalllanguagemodelssupervisedfine-tuningreinforcementlearningGRPOcorrectiveself-consistencyBIRDbenchmarkSpiderdataset

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper tries to establish that small language models with 0.5B to 1.5B parameters can be turned into competitive Text-to-SQL systems through post-training, not by scaling up. The recipe it proposes is supervised fine-tuning on 916K synthetic chain-of-thought samples, reinforcement learning with execution-based rewards, and a corrective self-consistency stage at inference. On the BIRD development set, the five tested models gain on average 31.4 points in execution accuracy, with the 0.5B model reaching 56.87% and the 1.5B model 67.08%, both numbers above several 7B–32B baselines. The same BIRD-trained models transfer to Spider with test-set gains of 24.98 points on average, which the paper offers as evidence of generalizability. A sympathetic reader would care because the claim, if correct, means edge-sized models can do database-querying work that has been reserved for models tens of times larger.

What carries the argument

The load-bearing mechanism is a two-dataset post-training pipeline followed by corrective self-consistency at inference. From the open-source SynSQL-2.5M dataset, the authors filter and re-tag 916K samples into SynSQL-Think-916K, where each question is paired with a <think>...</think> chain of thought and a <answer>...</answer> SQL query; a separate 310K merge-revision dataset is synthesized by generating eight candidate SQLs with a 7B teacher model, grouping them by execution result, and keeping the two highest-vote groups as drafts. The SQL generation model is SFT on the first dataset, then RL-trained with GRPO on BIRD; the merge revision model learns to compare two draft SQLs and their execution results and pick the correct one. At inference, the generator samples 64 SQLs, votes by execution result, and only when votes disagree does the revision model choose between the two leading drafts; the corrective gain is that this second stage repairs errors that self-consistency alone would keep.

What would settle it

On BIRD development, for each question check whether a correct SQL appears among the 64 sampled candidates and whether it appears in the top two execution-vote groups; if the top-two groups are correct on only a small fraction of the questions the final answer gets right, the merge stage cannot be making the claimed repairs. Alternatively, run the merge revision model without the instruction that one draft SQL is correct and see whether the roughly five-point execution-accuracy gain disappears.

Watch

Extended reading notes

Core claim

The central claim is that a sub-2B model trained to generate SQL via an explicit reasoning chain can outperform much larger models on the same benchmark, provided the training data is reorganized into two synthetic sets and inference is run with corrective self-consistency. On the BIRD development set, SLM-SQL-1.5B achieves 67.08% execution accuracy and SLM-SQL-0.5B achieves 56.87%, after training on SynSQL-Think-916K and SynSQL-Merge-Think-310K with SFT followed by GRPO-based reinforcement learning. The same models, trained only on BIRD, transfer to Spider with 79.06% test execution accuracy for the 1.5B model and 73.5% for the 0.5B model, which the paper reads as evidence that the method generalizes. Ablations attribute the gains to all three components: synthetic SFT (worth up to 21.9 points on the 0.5B model), RL (about 4–5 points), and the merge-revision step (about 5 points).

Load-bearing premise

The merge-revision step assumes that at least one of the two highest-vote draft SQLs is correct—the training prompt literally tells the model this—so the roughly five-point corrective gain and the headline 67.08% hold only when the sampling budget almost always puts a correct query in the top two vote groups.

Editorial extensions

If this is right

A 1.5B model reaching 67.08% on BIRD development surpasses several 7B, 15B, and 32B open-source baselines, so parameter count alone is not the binding constraint for text-to-SQL once post-training is right.
The same BIRD-trained models transfer to Spider without additional RL (79.06% test execution accuracy for 1.5B), suggesting the recipe induces general SQL skill rather than benchmark-specific memorization.
Inference cost is small in absolute terms: at $0.26 per hour GPU rental, 64 samples cost $0.00046 per question on BIRD development, so the performance is attainable on commodity hardware.
Increasing test-time samples monotonically improves the SLM-SQL pipeline (pass@64 = 0.8264), meaning the bottleneck is partly sampling budget, not raw model capability.
Removing SFT, RL, or corrective self-consistency each drops accuracy by roughly 4–22 points, so the paper claims all three components are necessary for the reported results.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

One testable extension is to remove the prompt instruction that one of the draft SQLs is correct and allow the merge model to write a fresh SQL; if the roughly five-point gain persists, the revision step learns genuine correction rather than selection between two candidates.
Because the method's pass@64 is 0.8264 while final execution accuracy is 67.08%, the gap suggests the revision stage is the current ceiling; improving candidate diversity or allowing the model to combine fragments could push small models further.
The same SFT-on-synthetic, RL-with-execution-rewards, corrective-consistency recipe is a natural fit for other code-generation tasks such as Python generation, where execution-based rewards exist, so the contribution may generalize beyond SQL.
If the method is as data-efficient as reported, 0.5B models could plausibly serve on-device database interfaces, where 56.87% execution accuracy at low cost may be a usable trade-off; the paper does not measure end-to-end latency.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

The thing to know: this paper's headline numbers — 56.87 and 67.08 BIRD dev EX for 0.5B and 1.5B models — are plausible and, if they survive scrutiny, genuinely useful for edge Text-to-SQL. But the paper as submitted does not yet establish them. The evidence is internally inconsistent: Table 6 lists SLM-SQL-1.5B "SFT + RL" at 50.59 EX (All), the same value as the 0.5B row, while Table 4's "w/o Corrective Self-Consistency" row — the same SFT+RL condition — reports 61.95. The paper says every setting is averaged over three runs, but no variance is given, so both numbers cannot be correct averages. That is not a minor typo; it sits in the same evaluation pipeline as the headline.

What is genuinely new: the two derived datasets (SynSQL-Think-916K, SynSQL-Merge-Think-310K), and the demonstration that the SFT-then-GRPO recipe, which has worked at 7B+, transfers to 0.5-1.5B models when combined with corrective self-consistency. If the BIRD dev numbers are real, that is a legitimately useful result for edge deployment. The ablation logic is sound — every component removal hurts, and the SFT effect is large.

The soft spots, in order of severity. First, the Table 6/Table 4 contradiction above. Second, the Spider generalization claim: SynSQL-2.5M includes Spider training data, so Table 3 is not a clean cross-dataset test; the paper should say this plainly. Third, the merge-revision assumption: Appendix F.2 tells the model one draft SQL is correct, so when both top-vote drafts are wrong the model can only choose the less-wrong query. The authors don't hide this, and it's a known property of self-consistency, but it means the 5-point CSC gain depends on the sampling budget almost always producing a correct candidate. Fourth, no BIRD test-set numbers and no error bars, despite claiming three runs. Code, data, and models are withheld until after review, so nothing is independently reproducible yet.

Bottom line: this deserves a serious referee, not a desk reject. The core claim is important enough and the methodology is coherent enough to warrant the time. The referee should demand a corrected Table 6, variance estimates, an explicit statement about Spider overlap, and release of artifacts before acceptance. I would not cite it until those are out, but I'd be glad to see the revised version.

Referee Report

4 major / 6 minor

Summary. The paper proposes SLM-SQL, a post-training recipe for small language models (0.5B-1.5B) on Text-to-SQL. It constructs two derived datasets from SynSQL-2.5M (SynSQL-Think-916K for SQL generation and SynSQL-Merge-Think-310K for merge revision), applies SFT and GRPO-based RL to both the generation and merge-revision models, and performs inference with the corrective self-consistency (CSC) procedure from CSC-SQL. On the BIRD development set it reports 56.87% EX for a 0.5B model and 67.08% EX for a 1.5B model, with an average gain of 31.4 points over five base models, and it also reports large gains when these models are evaluated on Spider. The central empirical claims are not yet fully supported because of internal numerical inconsistencies, training-data overlap in the Spider generalization experiment, and missing uncertainty quantification.

Significance. If the headline results are correct, they would be notable: sub-2B models outperforming several 7B-32B open-source systems and even GPT-4-based methods on the BIRD development set. The paper's main contribution is an assembly of existing components—CSC-SQL, SQL-R1, and Think2SQL—plus two newly derived datasets and a systematic evaluation across five small models. The planned release of datasets, models, and code is valuable. However, the manuscript currently withholds code and models until after review, reports no error bars despite claiming three runs per setting, and contains an internal contradiction between Table 6 and Table 4. The empirical claims therefore cannot be independently verified as written.

major comments (4)

[Appendix D.2 / Section 3.3] Table 6 and Table 4 report mutually incompatible numbers for the same condition. In Table 4, the "w/o Corrective Self-Consistency" row for SLM-SQL-1.5B is 61.95 EX on the BIRD dev set; this condition is exactly "SFT + RL". In Table 6, the "SFT + RL" row for the same model reports All = 50.59. Table 6 also lists All = 50.59 for SLM-SQL-0.5B SFT + RL, identical to the 1.5B value, while Table 4 gives 50.96 for the 0.5B w/o-CSC condition. Appendix B states that each setting is averaged over three runs, but no variance or per-run values are reported, so both cannot be valid averages. Because the headline BIRD numbers (56.87 and 67.08) come from the same experimental pipeline, this inconsistency must be resolved before the empirical claims can be accepted.
[Section 2 / Section 3.2] The claimed cross-dataset generalization to Spider is not supported because the SFT training data overlap with the Spider evaluation data. Section 2 states that SynSQL-2.5M "also includes the Spider and BIRD training sets", and SynSQL-Think-916K is derived from SynSQL-2.5M. The SQL generation model is SFT-trained on SynSQL-Think-916K, so it has seen Spider training questions during SFT. Section 3.2 then describes "directly tested models trained on the BIRD dataset" on Spider and interprets the gains as generalization. The paper should either exclude all Spider-derived samples from SFT, or explicitly report an evaluation on a truly unseen split, before drawing the generalization conclusion.
[Appendix F.2 / Section 3.3] The merge revision step relies on the prompt-level assumption that at least one of the two highest-vote draft SQLs is correct, and the prompt explicitly forbids constructing a new SQL. If both drafts are wrong, the merge model can only select the less incorrect query. The paper does not measure how often this precondition holds (e.g., the coverage of the top-two vote groups as a function of k), although Appendix D.1 reports pass@64 = 0.8264 for SLM-SQL-1.5B, which implies that for roughly 17% of questions no sampled SQL is correct. The roughly 5-point CSC gain in Table 4 therefore depends on an unverified assumption; a coverage analysis is needed to interpret the ablation.
[Appendix B] The paper states "We report the average performance over three independent runs for each experimental setting," but no standard deviation, confidence interval, or per-run numbers appear in any table or figure. Since several comparisons are decided by small margins (e.g., 1.5B SFT+RL vs w/o RL in Table 4 differ by 0.96 points), the absence of variance information leaves the reported differences unquantified. At minimum, the authors should add standard deviations to the main tables or provide per-run results in an appendix.

minor comments (6)

[Figure 3] The x-axis labels appear as "22 23 24 25 26" rather than 2^2, 2^3, ... or 4, 8, ...; please fix the typography for readability.
[Table 1] The table uses "SynsQL-Think-916k" and "SynsQL-Merge-Think-310k" while the text uses "SynSQL"; please unify the capitalization.
[References] Several reference-list entries are malformed; for example, the DeepSeek-Coder entry begins with a concatenated author string ("Dejian Yang Zhenda Xie Kai Dong Wentao Zhang...") rather than a proper citation format.
[Abstract / Section 6] The abstract says "We will release our dataset, model, and code to github", while Section 6 says release will happen "after the review process"; please specify the intended timeline and repository status.
[Table 2] SLM-SQL rows list Test EX as "-"; if BIRD test results are not reported, the paper should state that the comparison is development-set-only, since many baseline rows include test numbers.
[Table 3 / Appendix B] The caption and appendix should clarify which merge revision model is used for each base model; the statement that one 0.5B merge model is used for several architectures is easy to miss and is important for reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No circular derivation: SLM-SQL's headline numbers are empirical benchmark results, and its reliance on CSC-SQL is method inheritance rather than self-referential proof.

full rationale

The paper's claimed derivation chain is empirical and is evaluated against external benchmarks (BIRD dev and Spider), not derived from its own fitted inputs. The headline numbers (56.87 EX for 0.5B, 67.08 EX for 1.5B, and the 31.4-point average improvement) are measured execution accuracies after SFT on SynSQL-Think-916K, RL on BIRD Train, and corrective self-consistency inference; none of these quantities is defined in terms of the others, and the target metric is not used as a training signal in a way that would make the result true by construction. The merge-revision component is inherited from CSC-SQL by the same first author, but it is used as a concrete method and dataset, not as an authority, uniqueness theorem, or hidden ansatz; its contribution is empirically ablated in Table 4 on the external BIRD dev set. The merge prompt's instruction that one of the draft SQLs is correct is a stated modeling assumption and not a formal reduction of the reported gain. A genuine concern is the internal numerical inconsistency: Table 6 reports SFT+RL All EX = 50.59 for SLM-SQL-1.5B, while Table 4 reports the same condition (w/o Corrective Self-Consistency) as 61.95, and Appendix B says results are averaged over three runs but no variance is reported. This is a correctness and reproducibility problem, not a circularity problem, so it does not raise the circularity score.

Assumptions & free parameters 6 free parameters · 5 assumptions · 0 invented entities

The method is an empirical recipe; the axioms are dataset quality, reward validity, the one-correct-draft assumption, and the assumption that RL on BIRD train transfers to dev. The free parameters are the training and inference choices (sample counts, epochs, reward weight, filtering thresholds) that the reported numbers depend on. No new physical or theoretical entities are introduced.

free parameters (6)

Number of SQL generation samples at inference (k=64) = 64
Chosen by authors; ablation shows 16 vs 64 changes BIRD dev EX by 3.64 and 2.24 points (Table 4, Figure 3). Central numbers depend on this computational budget.
Number of merge revision samples (8) = 8
Fixed across experiments; merge sampling budget affects final EX but no ablation is reported for this value.
GRPO reward weighting for format reward (0.1) = 0.1
Equation (3) weights RFormat by 0.1; chosen by hand.
SFT epochs (2) and GRPO epochs (1) = 2 SFT / 1 GRPO
Selected training schedule with no sensitivity analysis reported.
Prompt length filter and heuristic SQL filters = 7000 tokens; SELECT presence; unique CoT occurrence; no '--' comments
Heuristic rules in Section 2 define SynSQL-Think-916K; different thresholds would change training data.
Merge revision model base for larger models = Qwen2.5-Coder-0.5B-Instruct
Appendix B says one 0.5B merge model is used for Qwen3-0.6B, Llama-3.2-1B, and DeepSeek-Coder-1.3B; this choice is not ablated.

assumptions (5)

domain assumption SQLite execution accuracy on BIRD and Spider is a valid measure of Text-to-SQL correctness.
Used as the sole metric and reward; errors in execution environment, nondeterminism, or ambiguous gold queries could distort results. Section 3.1.
domain assumption SynSQL-2.5M is high quality and its CoT annotations are correct enough for SFT.
The entire SynSQL-Think-916K training set is filtered from SynSQL-2.5M without human verification; Section 2.
ad hoc to paper The two draft SQLs with highest execution-vote counts contain at least one correct SQL.
The merge revision prompt in Appendix F.2 instructs the model that one of the draft SQLs is correct; if all drafts are wrong, the final SQL cannot be correct.
domain assumption GRPO RL on BIRD train with execution reward improves generalization to unseen BIRD dev questions.
The RL training set is only 9,428 examples (Table 1); distribution shift to dev is assumed manageable.
ad hoc to paper Spider results can be attributed to cross-dataset generalization despite SynSQL-2.5M including Spider training data.
Section 2 states SynSQL-2.5M includes Spider and BIRD training sets; Section 3.2 presents Spider as a generalization test.

how reviews work

0 comments

Cite this review

Pith. "Pith review of SLM-SQL: An Exploration of Small Language Models for Text-to-SQL." pith.science (2026). https://pith.science/paper/N3HB53PL

@misc{pith2026250722478,
  author       = {Pith},
  title        = {Pith review of: SLM-SQL: An Exploration of Small Language Models for Text-to-SQL},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/N3HB53PL}},
  note         = {Machine review of arXiv:2507.22478}
}

read the original abstract

Large language models (LLMs) have demonstrated strong performance in translating natural language questions into SQL queries (Text-to-SQL). In contrast, small language models (SLMs) ranging from 0.5B to 1.5B parameters currently underperform on Text-to-SQL tasks due to their limited logical reasoning capabilities. However, SLMs offer inherent advantages in inference speed and suitability for edge deployment. To explore their potential in Text-to-SQL applications, we leverage recent advancements in post-training techniques. Specifically, we used the open-source SynSQL-2.5M dataset to construct two derived datasets: SynSQL-Think-916K for SQL generation and SynSQL-Merge-Think-310K for SQL merge revision. We then applied supervised fine-tuning and reinforcement learning-based post-training to the SLM, followed by inference using a corrective self-consistency approach. Experimental results validate the effectiveness and generalizability of our method, SLM-SQL. On the BIRD development set, the five evaluated models achieved an average improvement of 31.4 points. Notably, the 0.5B model reached 56.87\% execution accuracy (EX), while the 1.5B model achieved 67.08\% EX. We will release our dataset, model, and code to github: https://github.com/CycloneBoy/slm_sql.

Figures

Figures reproduced from arXiv: 2507.22478 by the authors.

**Figure 2.** Overview of the proposed SLM-SQL framework. Our SLM-SQL framework is illustrated in Figure 2 and comprises three main components: dataset construction, model training, and inference. Dataset Construction:: We use the SynSQL2.5M dataset (Li et al., 2025b) as the primary data source. This large-scale, high-quality, and diverse synthetic dataset was specifically developed for the Text-to-SQL task. It also includes t… view at source ↗

**Figure 3.** Trend chart of various metrics of SLM-SQL [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

25 extracted references · 20 canonical work pages

[1]

**Identify the relevant tables**: We need to access data from the ‘frpm‘ table for the SAT scores and the ‘satscores‘ table for the eligibility rates

work page
[2]

**Determine the join condition**: Since the ‘frpm‘ table and the ‘satscores‘ table share the common column ‘cds‘, we will join these two tables on this column

work page
[3]

**Filter the data for schools with an SAT excellence rate over 0.3**: We will use a WHERE clause to filter the rows where the ‘Excellence rate‘ is greater than 0.3

work page
[4]

arXiv preprint

Next-Generation Database Interfaces: A Sur- vey of LLM-based Text-to-SQL. arXiv preprint . ArXiv:2406.08426 [cs] version: 1. Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. Lora: Low-rank adap- tation of large language models. arXiv preprint arXiv:2106.09685. Binyuan Hui, Jian Yang, Zeyu ...

arXiv 2021
[5]

The VLDB Journal, 32(4):905–936

A survey on deep learning approaches for text- to-SQL. The VLDB Journal, 32(4):905–936. Dongjun Lee, Choongwon Park, Jaehyuk Kim, and Heesoo Park. 2024. MCS-SQL: Leveraging Multiple Prompts and Multiple-Choice Selection For Text-to- SQL Generation. arXiv preprint. ArXiv:2405.07467 [cs] version: 1. Boyan Li, Jiayi Zhang, Ju Fan, Yanwei Xu, Chong Chen, Nan ...

arXiv 2024
[6]

Preprint, arXiv:2502.11569

Towards reasoning ability of small language models. Preprint, arXiv:2502.11569. Shayan Talaei, Mohammadreza Pourreza, Yu-Chen Chang, Azalia Mirhoseini, and Amin Saberi. 2024. CHESS: Contextual Harnessing for Efficient SQL Synthesis. arXiv preprint. ArXiv:2405.16755 [cs] version: 1. Guiyao Tie, Zeli Zhao, Dingjie Song, Fuyang Wei, Rong Zhou, Yurou Dai, Wen...

arXiv 2024
[7]

By following these steps, we can generate the final SQL query

**Select the required columns**: We will select the ‘School‘, ‘District Name‘, ‘Eligible free rate‘, and ‘Excellence rate‘ columns from the result set. By following these steps, we can generate the final SQL query. </think> <answer>SELECT T2.School, T2.District Name, CAST(T2.‘Free Meal Count (Ages 5-17)‘ AS REAL) / T2.‘Enrollment (Ages 5-17)‘ AS Eligible_...

work page
[11]

We will create a subquery to calculate this for each school and then join this subquery with the main ‘frpm‘ table to get the corresponding district name

**Calculate the eligible free rate for students aged 5-17**: We will use the formula ‘Eligible free rate = ‘Free Meal Count (Ages 5-17)‘ / ‘Enrollment (Ages 5-17)‘. We will create a subquery to calculate this for each school and then join this subquery with the main ‘frpm‘ table to get the corresponding district name

work page

Show all 25 references

[12]

**Order the results by the eligible free rate in descending order**: To get the highest eligible free rate, we will order the results by the ‘Eligible free rate‘ column in descending order
[13]

**Limit the results to the top school**: Since we are only interested in the highest eligible free rate, we will limit the results to the top 1 row
[15]

- We need to find the ‘atom_id1‘ and ‘atom_id2‘ associated with ‘TR000_2_5‘

**‘bond‘ Table**: - This table contains information about bonds, including their ‘bond_id‘. - We need to find the ‘atom_id1‘ and ‘atom_id2‘ associated with ‘TR000_2_5‘
[16]

How many schools in Amador which the Low Grade is 9 and the High Grade is 12?

**‘connected‘ Table**: - This table links ‘atom_id1‘, ‘atom_id2‘, and ‘bond_id‘. - We will use this table to find the atom IDs that are part of the bond identified by ‘TR000_2_5‘. ### Step 3: Define the Relationship Between Tables - The ‘bond‘ table and the ‘connected‘ table a...
[17]

We need to count the number of schools (‘COUNT(*)‘)
[18]

Amador". - The ‘Low Grade‘ should be

The criteria for the schools are: - The ‘County Name‘ should be "Amador". - The ‘Low Grade‘ should be "9". - The ‘High Grade‘ should be "12". ### Step 2: Identify the Relevant Table From the schema, the ‘frpm‘ table contains the columns: - ‘County Name‘: To filter schools by c...
[19]

Filter rows where ‘County Name = ’Amador’‘
[20]

Filter rows where ‘Low Grade = ’9’‘
[21]

These filters ensure that only schools meeting all three conditions are counted

Filter rows where ‘High Grade = ’12’‘. These filters ensure that only schools meeting all three conditions are counted. ### Step 4: Count the Schools Once the rows are filtered, the query should count the number of rows that satisfy the conditions. The ‘COUNT(*)‘ function is u...
[22]

- It orders the results by the enrollment number in ascending order (‘ASC‘)

**First SQL Query**: “‘sql SELECT s.City FROM frpm AS f INNER JOIN schools AS s ON f.CDSCode = s.CDSCode ORDER BY f.‘Enrollment (Ages 5-17)‘ ASC LIMIT 5 “‘ - This query joins the ‘frpm‘ and ‘schools‘ tables based on the ‘CDSCode‘. - It orders the results by the enrollment numb...
[23]

- It groups the results by city

**Second SQL Query**: “‘sql SELECT s.City FROM schools s JOIN frpm f ON s.CDSCode = f.CDSCode GROUP BY s.City ORDER BY MAX(f.‘Enrollment (Ages 5-17)‘) ASC LIMIT 5 “‘ - This query also joins the ‘frpm‘ and ‘schools‘ tables based on the ‘CDSCode‘. - It groups the results by city...

2025
[24]

{PREDICT_SQL1} Execution result {EXECUTE_RESULT1}
[25]

- Remember that one of the draft SQLs is correct

{PREDICT_SQL2} Execution result {EXECUTE_RESULT2} Instructions: - You should first carefully analyze each draft SQL, compare their differences, and then conduct further analysis based on user questions to determine which draft SQL is correct in the end. - Remember that one of ...
[2019]

to large language model (LLM)-based ap- proaches (Liu et al., 2024; Hong et al., 2024). These approaches can be categorized into three groups: (1) in-context learning (ICL)-based meth- ods (Dong et al., 2023; Pourreza and Rafiei, 2023; Gao et al., 2023; Lee et al., 2024), (2) ...

2024
[2023]

arXiv preprint

C3: Zero-shot Text-to-SQL with ChatGPT. arXiv preprint. ArXiv:2307.07306 [cs] version: 1. Dawei Gao, Haibin Wang, Yaliang Li, Xiuyu Sun, Yichen Qian, Bolin Ding, and Jingren Zhou. 2023. Text-to-SQL Empowered by Large Language Mod- els: A Benchmark Evaluation. arXiv preprint . ...

2023 arXiv
[2024]

DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, Xiaokang Zhang, Xingkai Yu, Yu Wu, Z

Deepseek-coder: When the large language model meets programming – the rise of code intelli- gence. DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, Xiaokang Zhang, Xingkai Yu, Yu Wu, Z. F. Wu, Z...
[2025]

Preprint, arXiv:2501.12948

Deepseek-r1: Incentivizing reasoning capa- bility in llms via reinforcement learning. Preprint, arXiv:2501.12948. Xuemei Dong, Chao Zhang, Yuhang Ge, Yuren Mao, Yunjun Gao, lu Chen, Jinshu Lin, and Dongfang Lou

arXiv

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.

[1] [1]

**Identify the relevant tables**: We need to access data from the ‘frpm‘ table for the SAT scores and the ‘satscores‘ table for the eligibility rates

work page

[2] [2]

**Determine the join condition**: Since the ‘frpm‘ table and the ‘satscores‘ table share the common column ‘cds‘, we will join these two tables on this column

work page

[3] [3]

**Filter the data for schools with an SAT excellence rate over 0.3**: We will use a WHERE clause to filter the rows where the ‘Excellence rate‘ is greater than 0.3

work page

[4] [4]

arXiv preprint

Next-Generation Database Interfaces: A Sur- vey of LLM-based Text-to-SQL. arXiv preprint . ArXiv:2406.08426 [cs] version: 1. Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. Lora: Low-rank adap- tation of large language models. arXiv preprint arXiv:2106.09685. Binyuan Hui, Jian Yang, Zeyu ...

arXiv 2021

[5] [5]

The VLDB Journal, 32(4):905–936

A survey on deep learning approaches for text- to-SQL. The VLDB Journal, 32(4):905–936. Dongjun Lee, Choongwon Park, Jaehyuk Kim, and Heesoo Park. 2024. MCS-SQL: Leveraging Multiple Prompts and Multiple-Choice Selection For Text-to- SQL Generation. arXiv preprint. ArXiv:2405.07467 [cs] version: 1. Boyan Li, Jiayi Zhang, Ju Fan, Yanwei Xu, Chong Chen, Nan ...

arXiv 2024

[6] [6]

Preprint, arXiv:2502.11569

Towards reasoning ability of small language models. Preprint, arXiv:2502.11569. Shayan Talaei, Mohammadreza Pourreza, Yu-Chen Chang, Azalia Mirhoseini, and Amin Saberi. 2024. CHESS: Contextual Harnessing for Efficient SQL Synthesis. arXiv preprint. ArXiv:2405.16755 [cs] version: 1. Guiyao Tie, Zeli Zhao, Dingjie Song, Fuyang Wei, Rong Zhou, Yurou Dai, Wen...

arXiv 2024

[7] [7]

By following these steps, we can generate the final SQL query

**Select the required columns**: We will select the ‘School‘, ‘District Name‘, ‘Eligible free rate‘, and ‘Excellence rate‘ columns from the result set. By following these steps, we can generate the final SQL query. </think> <answer>SELECT T2.School, T2.District Name, CAST(T2.‘Free Meal Count (Ages 5-17)‘ AS REAL) / T2.‘Enrollment (Ages 5-17)‘ AS Eligible_...

work page

[8] [11]

We will create a subquery to calculate this for each school and then join this subquery with the main ‘frpm‘ table to get the corresponding district name

**Calculate the eligible free rate for students aged 5-17**: We will use the formula ‘Eligible free rate = ‘Free Meal Count (Ages 5-17)‘ / ‘Enrollment (Ages 5-17)‘. We will create a subquery to calculate this for each school and then join this subquery with the main ‘frpm‘ table to get the corresponding district name

work page