Pith. sign in

REVIEW 3 major objections 7 minor 36 references

SDE-SQL: Enhancing Text-to-SQL Generation in Large Language Models via Self-Driven Exploration with SQL Probes

T0 review · 3 major / 7 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read SDE-SQL claims that letting a large language model generate and execute SQL probes against the database before writing the final query improves text-to-SQL accuracy, reaching 67.67% execution accuracy on BIRD in a zero-shot, training-free…

desk verdict Probe-based database exploration is a real win for text-to-SQL, but fix the inconsistent relative gain and address the empty-result conflation before trusting the numbers. read the letter →

arxiv 2506.07245 v2 pith:HKMNBOZ3 submitted 2025-06-08 cs.CL cs.AI

Wenxuan Xie , Yaxun Dai , Wenhao Jiang This is my paper
classification cs.CLcs.AI
keywords Text-to-SQLSQLprobesself-drivenexplorationlargelanguagemodelsBIRDbenchmarkexecutionaccuracyzero-shotgenerationrefinement
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

Text-to-SQL systems usually hand the language model a static, pre-processed schema and ask it to write a query in one shot. SDE-SQL instead lets the model generate small auxiliary queries, called SQL probes, execute them against the database, and use the results to ground both query writing and repair. The paper argues that this dynamic interaction, not more demonstrations or fine-tuning, is what lets an open model close part of the gap with much larger closed systems. On the BIRD benchmark, Qwen2.5-72B-Instruct with SDE-SQL reaches 67.67% execution accuracy in a zero-shot, training-free setting, rising to 68.19% after targeted fine-tuning. The paper's central claim is that treating SQL as an interface for exploration, rather than only as an output format, is a broadly useful lever for text-to-SQL.

What carries the argument

The central object is the SQL Probe: an auxiliary query the LLM generates and executes in order to see what the database actually contains. Two probe-driven exploration phases precede generation: Candidate Exploration builds Base SQL Probes for target columns and Condition SQL Probes for condition columns and values, and Combination Exploration merges all condition candidates, discarding any combination whose probe returns empty. In refinement, the same idea is applied to empty-result failures: a SQLGlot-based decomposer splits the failed query into Sub-SQL probes whose empty or non-empty results localize the fault, the model proposes a cause from five named error types, validates the fix with diagnostic probes, and a Target Checking module removes surplus SELECT columns. The mechanism works by converting the database's execution engine from a final oracle into an information source the model can consult before committing to a query.

What would settle it

Manually label every empty-result failure that SDE-SQL fails to repair on the BIRD dev set and check whether the true causes fall inside the five listed error types; a substantial share of out-of-taxonomy causes would show the refinement module's diagnosis is incomplete. A cleaner controlled version is to replace the five-cause prompt with a generic 'explain why this is empty and fix it' prompt and compare repair success.

Watch

Extended reading notes

Core claim

SDE-SQL's central claim is that letting the LLM actively explore a database before and after writing SQL improves text-to-SQL accuracy beyond what static schema context provides. Before generation, the model issues Base SQL Probes that enumerate candidate columns for a question's target and Condition SQL Probes that test candidate columns and values for each condition; a combination-exploration stage then joins these candidates and keeps only combinations that return non-empty results. The final query is generated zero-shot from the schema plus these probe results, with self-consistency over multiple generated SQLs. For queries that execute but return nothing, refinement decomposes the failed SQL into Sub-SQL probes via an SQLGlot-based AST decomposer, asks the model to hypothesize why the result is empty using five named error causes, and validates candidate fixes with further probes before applying a target-checking pass. On BIRD dev this yields 67.67% execution accuracy with Qwen2.5-72B-Instruct and 68.19% after supervised fine-tuning, which the paper reports as a new state of the art among open-source methods without SFT or ensembling.

Load-bearing premise

The load-bearing premise is that the five hand-written error causes and the prompt templates cover the main reasons a generated SQL query returns empty results, so the refinement stage can diagnose and fix them rather than merely retrying.

Editorial extensions

If this is right

  • Zero-shot text-to-SQL can improve meaningfully without few-shot question-SQL pairs, because execution feedback substitutes for demonstrations.
  • On BIRD dev, the approach reaches 67.67% execution accuracy training-free and 68.19% after SFT, surpassing many GPT-4-based methods and open-source baselines that do not use ensembling.
  • Empty-result failures, previously addressed by blind regeneration, become diagnosable through decomposed sub-query probes and a five-cause error taxonomy.
  • Spider results (87.3% dev training-free, 87.5% after SFT) indicate the gain transfers across domains, though the paper notes the improvement is smaller because many Spider queries already return empty results, limiting useful feedback.
  • Fine-tuning the explorer and generator on sampled exploration rollouts adds 0.52%, suggesting that module-level SFT can complement prompt-driven exploration.

Reading between the lines

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

  • A testable extension is to apply the five-cause empty-result taxonomy to other text-to-SQL benchmarks; if the distribution of empty-result failure causes differs, the refinement stage would need benchmark-specific causes.
  • If dynamic probing is the driver, the same SQL-probe exploration pattern could transfer to other execution-grounded tasks, such as database question answering or tool-using agents, where the model can test its assumptions against an environment.
  • Exploration cost becomes a practical concern: each question may execute many probes, so reporting accuracy against the number of probe executions would clarify where exploration is worth the overhead.
  • The paper's own limitation section notes that probing is entirely prompt-driven; a natural extension is to learn the probing policy from execution outcomes, such as through reinforcement learning, to make exploration adaptive.
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.

Referee Report

3 major / 7 minor

Summary. SDE-SQL is a framework for text-to-SQL that lets an LLM issue and execute SQL probes against the database before and after generating a candidate query. The pipeline consists of entity-based schema linking with value retrieval and soft linking, a two-stage pre-generation exploration (Candidates Exploration and Combinations Exploration), zero-shot SQL generation with self-consistency, and a refinement module that decomposes empty-result SQL into Sub-SQLs, uses the results to diagnose errors, generates solution probes, and then applies target checking. The method is evaluated on BIRD and Spider with Qwen2.5-72B-Instruct, reporting 67.67% execution accuracy on the BIRD dev set (68.19% after SFT) and competitive Spider results. The paper positions the approach as a training-free, zero-shot alternative to methods that rely on in-context demonstrations or static, preprocessed schema information.

Significance. If the reported results hold, SDE-SQL demonstrates a meaningful gain from dynamic database interaction: executing SQL probes gives the model content-level evidence that static schema descriptions cannot provide. The paper is also useful as a detailed prompt recipe, with the full prompt templates provided in the appendix. The approach is reproducible in principle from the description, although no code is released. Its main conceptual weakness is that the core signal—whether a probe returns rows—is treated as a definitive correctness indicator, without considering that a correct query may legitimately return no rows; Section 4.2.2 even notes the limiting effect of empty results on Spider, which undercuts the assumption. In addition, the headline relative improvement number in the abstract is inconsistent with the table.

major comments (3)
  1. [Abstract and Table 2] The abstract states that SDE-SQL achieves an 8.02% relative improvement in execution accuracy over the vanilla Qwen2.5-72B-Instruct baseline, but Table 2 reports 67.67% versus 60.17%, which is a relative improvement of 12.46%. The 8.02% figure does not match any calculation from the reported numbers, and the discrepancy undermines the precision of the central empirical claim. Please correct the abstract or the table and ensure all derived percentages are consistent with the raw values.
  2. [Table 1] The ablation study in Table 1 reports differences that range from 0.13 to 3.20 percentage points, but no variance or significance testing is reported. Several component removals produce changes that may be within run-to-run noise (e.g., w/o Soft Schema Linker -0.79; SDE-SQL + Fine-tuned Explorer +0.19 and +0.13). Since the paper claims each component plays an important role, it should support this with either multiple independent runs with standard deviations, paired significance tests on the dev set, or at least an error-budget discussion. Without this, the relative contribution of individual modules is not established.
  3. [Section 3.3.2 and Figures 12-13] The Solution Exploration Stage asks the LLM to derive hypotheses about error causes, but the prompt fixes the hypothesis space to five hand-crafted causes: conflicting conditions or redundant descriptions, incorrect condition values or case sensitivity, unnecessary table joins, incorrect column selection, and misuse of MAX/MIN or ORDER BY. The paper provides no analysis of whether these five causes cover the actual distribution of empty-result failures on BIRD. If a failure falls outside this taxonomy, the 'self-driven' diagnosis cannot identify it. The authors should either analyze the coverage of these causes on a sample of BIRD errors or soften the claim that the model autonomously explores possible solutions. This is relevant to the central claim because the refinement gains are attributed to this exploration mechanism.
minor comments (7)
  1. [Abstract and Section 1] The paper calls the method zero-shot, but Section 3.1.1 uses few-shot learning for entity extraction and Section 3.1.2 uses one-shot prompting for soft schema linking; 'zero-shot' should be qualified to refer specifically to the SQL generation stage.
  2. [Section 4.2.2] The statement that a large portion of Spider SQL queries return empty results is interesting, but it is used only to explain a modest gain; please add a concrete statistic (e.g., the fraction of empty gold results in Spider dev/test) to support the explanation.
  3. [Figure 6] The example SQL in Figure 6 contains a typo: 'FROM from AS T1' should be a valid table reference; please correct.
  4. [Section 2.2] In the sentence 'DELLMHong et al. (2024) specifically fine-tuned...', there is a missing space between 'DELLM' and 'Hong'; please fix the citation formatting.
  5. [Table 2] The ordering of baselines mixes closed-source and open-source methods without a clear grouping; a separate section or a bolded row for the best open-source no-SFT result would improve readability.
  6. [Section 3.4] The SFT data collection says 5,231 valid samples were obtained from 9,428 data points; please clarify the sampling strategy and whether the rollout was performed with the same Qwen2.5-72B-Instruct model, as this affects the interpretation of the SFT gains.
  7. [Appendix E] The prompts are detailed, but the exact values of several free parameters mentioned in the text (number of candidate options per entity, self-consistency sample count, similarity threshold for value retrieval, and number of refinement attempts) are not reported; please provide these values and, ideally, a sensitivity analysis.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: SDE-SQL's central performance claims are empirically validated on external benchmarks and do not reduce to fitted inputs or self-citation.

full rationale

The paper is an empirical engineering system, not a derivation from first principles. The final SQL is produced by prompting an LLM with database schema and execution results of SQL probes, and the reported accuracies (67.67% training-free, 68.19% with SFT on BIRD dev) are measured against BIRD gold execution results. No parameter or constant is fitted to BIRD dev and then renamed as a prediction. The 'empty result means unsuitable' rule in Section 3.2.2 is a heuristic assumption; it may be a correctness risk for questions whose gold SQL legitimately returns empty, but it is not circular because the evaluation criterion is independent of that heuristic. The method borrows soft schema linking and target/condition decomposition from the authors' prior MAG-SQL, but this self-citation is not load-bearing: Table 1's ablations attribute the main gains to the exploration and refinement modules, and the central BIRD comparison is against an external benchmark with independently labeled gold SQL. SFT data are sampled from the BIRD training set and evaluated on the dev set, so there is no label leakage into the reported result. No enumerated circular pattern is exhibited with a quotable reduction.

Assumptions & free parameters 4 free parameters · 5 assumptions · 2 invented entities

The framework relies on several design choices (candidate counts, similarity thresholds, refinement iterations) that are not fully specified. It also depends on hand-crafted error taxonomies and standard benchmark assumptions, which are reasonable but not derived from first principles.

free parameters (4)
  • Number of candidate options per entity = 2 (illustrative)
    The paper illustrates with two candidates per entity in Figure 3, but does not report what was used in the actual experiments; this affects the number of SQL probes.
  • Self-consistency sample count = not reported
    SDE-SQL uses self-consistency to select the most consistent answer, but the number of samples is not specified, affecting reliability and cost.
  • Similarity threshold for value retrieval = not reported
    Value retrieval uses LSH and semantic similarity without specifying thresholds.
  • Number of refinement attempts = not reported
    The refinement process likely has an attempt limit, but it is not specified.
assumptions (5)
  • domain assumption BIRD and Spider execution accuracy is a valid measure of Text-to-SQL quality.
    The paper uses EX as the only metric and assumes it reflects correctness.
  • domain assumption The LLM (Qwen2.5-72B-Instruct) can faithfully generate and execute SQL probes as instructed.
    The method assumes the base model follows the complex multi-step prompt instructions.
  • ad hoc to paper The hand-crafted five error causes in the refinement prompts cover the main failure modes for empty results.
    These causes are not derived from a formal taxonomy; they are introduced by the authors based on observed errors, and may not generalize.
  • domain assumption SQLGlot correctly parses and decomposes SQL into subqueries.
    The decomposition stage relies on SQLGlot without discussing potential parsing failures.
  • domain assumption The BIRD training set is representative of the dev set.
    The SFT stage samples from BIRD training and assumes it transfers to the dev set.
invented entities (2)
  • SQL Probes independent evidence
    purpose: SQL queries generated by the LLM to explore candidate columns and values in the database.
    A new concept introduced to enable dynamic database interaction; their execution results provide observable feedback.
  • Sub-SQLs independent evidence
    purpose: Rule-based decomposition of incorrect SQL to localize errors.
    Introduced in the Error Cause Identification Stage; their execution results are observable.

how reviews work

0 comments
Cite this review

Pith. "Pith review of SDE-SQL: Enhancing Text-to-SQL Generation in Large Language Models via Self-Driven Exploration with SQL Probes." pith.science (2026). https://pith.science/paper/HKMNBOZ3

@misc{pith2026250607245,
  author       = {Pith},
  title        = {Pith review of: SDE-SQL: Enhancing Text-to-SQL Generation in Large Language Models via Self-Driven Exploration with SQL Probes},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/HKMNBOZ3}},
  note         = {Machine review of arXiv:2506.07245}
}
read the original abstract

Recent advancements in large language models (LLMs) have significantly improved performance on the Text-to-SQL task. However, prior approaches typically rely on static, pre-processed database information provided at inference time, which limits the model's ability to fully understand the database contents. Without dynamic interaction, LLMs are constrained to fixed, human-provided context and cannot autonomously explore the underlying data. To address this limitation, we propose SDE-SQL, a framework that enables large language models to perform self-driven exploration of databases during inference. This is accomplished by generating and executing SQL probes, which allow the model to actively retrieve information from the database and iteratively update its understanding of the data. Unlike prior methods, SDE-SQL operates in a zero-shot setting, without relying on any question-SQL pairs as in-context demonstrations. When evaluated on the BIRD benchmark with Qwen2.5-72B-Instruct, SDE-SQL achieves an 8.02% relative improvement in execution accuracy over the vanilla Qwen2.5-72B-Instruct baseline, establishing a new state-of-the-art among methods based on open-source models without supervised fine-tuning (SFT) or model ensembling. Moreover, with SFT, the performance of SDE-SQL can be further enhanced, yielding an additional 0.52% improvement.

Figures

Figures reproduced from arXiv: 2506.07245 by the authors.

Figure 1
Figure 1. The Workflow of SDE-SQL, which consists of three parts: 1) Schema Linking: which retrieves and selects [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. is an example. Question Database Find the names of employees who work in the IT department and earn more than $50000. Target: the names of employees Condition 1: The employees must work in the IT department Condition 2: The employees must earn more than $50000 SELECT `name` FROM employees WHERE `department` = 'IT' WHERE `salary` > 50000 SELECT `name` FROM employees WHERE `department` = 'IT’ AND `salary` > 50000 SQL … view at source ↗
Figure 3
Figure 3. Condition SQL Probes Generation Process Illustrated Using a Tree Structure. [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (10 more)
Figure 4
Figure 4. Figure 4: An illustration of the proposed refinement process with exploration in SDE-SQL. [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: An Example of Condition Conflict frpm satscores CDSCode cds AvgScrRead FRPM Count (Ages 5-17) 136 43696414332904 43696414332904 642 192 19642121931880 19642121931880 639 83 43694684334421 43694684334421 639 1611760135244 653 Rows not in the JOIN result 43696414332904 6…
Figure 6
Figure 6. Figure 6: An example of Sub-query Scope Inconsis￾tency B Target Checking Module Question Evidence SQL Result Columns ```json { “Modification”: “True/False”, “Final SQL”: “<SQL>” } ``` LLM Target Checking Module [PITH_FULL_IMAGE:figures/full_fig_p012_6.png]
Figure 7
Figure 7. Figure 7: Target Checking Module C Training Settings Parameter Value per_device_train_batch_size 1 gradient_accumulation_steps 8 learning_rate 1.0e-4 num_train_epochs 2.0 lr_scheduler_type cosine lora_rank 16 [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]
Figure 9
Figure 9. Figure 9: Prompt Template of Candidates Exploration [PITH_FULL_IMAGE:figures/full_fig_p013_9.png]
Figure 10
Figure 10. Figure 10: Prompt Template of Combinations Exploration [PITH_FULL_IMAGE:figures/full_fig_p014_10.png]
Figure 11
Figure 11. Figure 11: Prompt Template of Zero-shot Generation 15 [PITH_FULL_IMAGE:figures/full_fig_p015_11.png]
Figure 12
Figure 12. Figure 12: Prompt Template of Solution Exploration [PITH_FULL_IMAGE:figures/full_fig_p016_12.png]
Figure 13
Figure 13. Figure 13: Prompt Template of Final Refinement 17 [PITH_FULL_IMAGE:figures/full_fig_p017_13.png]
Figure 14
Figure 14. Figure 14: Prompt Template of Target Checking 18 [PITH_FULL_IMAGE:figures/full_fig_p018_14.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

36 extracted references · 5 canonical work pages

  1. [1]

    Ruichu Cai, Jinjie Yuan, Boyan Xu, and Zhifeng Hao. 2022. https://arxiv.org/abs/2111.00653 Sadga: Structure-aware dual graph aggregation network for text-to-sql . Preprint, arXiv:2111.00653

    work page Pith review arXiv 2022

  2. [2]

    Ruisheng Cao, Lu Chen, Zhi Chen, Yanbin Zhao, Su Zhu, and Kai Yu. 2021. https://arxiv.org/abs/2106.01093 Lgesql: Line graph enhanced text-to-sql model with mixed local and non-local relations . Preprint, arXiv:2106.01093

    arXiv 2021

  3. [3]

    Xiaojun Chen, Tianle Wang, Tianhao Qiu, Jianbin Qin, and Min Yang. 2024. https://arxiv.org/abs/2405.06674 Open-sql framework: Enhancing text-to-sql on open-source large language models . Preprint, arXiv:2405.06674

    arXiv 2024

  4. [4]

    DongHyun Choi, Myeong Cheol Shin, EungGyun Kim, and Dong Ryeol Shin. 2020. https://arxiv.org/abs/2004.03125 Ryansql: Recursively applying sketch-based slot fillings for complex text-to-sql in cross-domain databases . Preprint, arXiv:2004.03125

    work page Pith review arXiv 2020

  5. [5]

    Dawei Gao, Haibin Wang, Yaliang Li, Xiuyu Sun, Yichen Qian, Bolin Ding, and Jingren Zhou. 2023. https://arxiv.org/abs/2308.15363 Text-to-sql empowered by large language models: A benchmark evaluation . Preprint, arXiv:2308.15363

    arXiv 2023

  6. [6]

    Yingqi Gao, Yifu Liu, Xiaoxia Li, Xiaorong Shi, Yin Zhu, Yiming Wang, Shiqi Li, Wei Li, Yuntao Hong, Zhiling Luo, Jinyang Gao, Liyu Mou, and Yu Li. 2025. https://arxiv.org/abs/2411.08599 A preview of xiyan-sql: A multi-generator ensemble framework for text-to-sql . Preprint, arXiv:2411.08599

    arXiv 2025

  7. [7]

    Jiaqi Guo, Zecheng Zhan, Yan Gao, Yan Xiao, Jian-Guang Lou, Ting Liu, and Dongmei Zhang. 2019. https://arxiv.org/abs/1905.08205 Towards complex text-to-sql in cross-domain database with intermediate representation . Preprint, arXiv:1905.08205

    arXiv 2019

  8. [8]

    Zijin Hong, Zheng Yuan, Hao Chen, Qinggang Zhang, Feiran Huang, and Xiao Huang. 2024. https://arxiv.org/abs/2402.11517 Knowledge-to-sql: Enhancing sql generation with data expert llm . Preprint, arXiv:2402.11517

    arXiv 2024

Show all 36 references
  1. [9]

    Binyuan Hui, Xiang Shi, Ruiying Geng, Binhua Li, Yongbin Li, Jian Sun, and Xiaodan Zhu. 2021. https://arxiv.org/abs/2103.04399 Improving text-to-sql with schema dependency learning . Preprint, arXiv:2103.04399

    2021 arXiv

  2. [10]

    Wonseok Hwang, Jinyeong Yim, Seunghyun Park, and Minjoon Seo. 2019. https://arxiv.org/abs/1902.01069 A comprehensive exploration on wikisql with table-aware word contextualization . Preprint, arXiv:1902.01069

    2019 arXiv

  3. [11]

    Dongjun Lee, Choongwon Park, Jaehyuk Kim, and Heesoo Park. 2024. https://arxiv.org/abs/2405.07467 Mcs-sql: Leveraging multiple prompts and multiple-choice selection for text-to-sql generation . Preprint, arXiv:2405.07467

    2024 arXiv

  4. [12]

    Fangyu Lei, Jixuan Chen, Yuxiao Ye, Ruisheng Cao, Dongchan Shin, Hongjin Su, Zhaoqing Suo, Hongcheng Gao, Wenjing Hu, Pengcheng Yin, Victor Zhong, Caiming Xiong, Ruoxi Sun, Qian Liu, Sida Wang, and Tao Yu. 2025. https://arxiv.org/abs/2411.07763 Spider 2.0: Evaluating language ...

    2025 arXiv

  5. [13]

    Haoyang Li, Jing Zhang, Hanbing Liu, Ju Fan, Xiaokang Zhang, Jun Zhu, Renjie Wei, Hongyan Pan, Cuiping Li, and Hong Chen. 2024. https://arxiv.org/abs/2402.16347 Codes: Towards building open-source language models for text-to-sql . Preprint, arXiv:2402.16347

    2024 arXiv

  6. [14]

    Jinyang Li, Binyuan Hui, Ge Qu, Jiaxi Yang, Binhua Li, Bowen Li, Bailin Wang, Bowen Qin, Rongyu Cao, Ruiying Geng, Nan Huo, Xuanhe Zhou, Chenhao Ma, Guoliang Li, Kevin C. C. Chang, Fei Huang, Reynold Cheng, and Yongbin Li. 2023. https://arxiv.org/abs/2305.03111 Can llm already...

    2023 arXiv

  7. [15]

    Xiping Liu and Zhao Tan. 2023. https://arxiv.org/abs/2304.11556 Divide and prompt: Chain of thought prompting for text-to-sql . Preprint, arXiv:2304.11556

    2023 arXiv

  8. [16]

    OpenAI, :, Aaron Hurst, Adam Lerer, Adam P. Goucher, Adam Perelman, Aditya Ramesh, Aidan Clark, AJ Ostrow, Akila Welihinda, Alan Hayes, Alec Radford, Aleksander Madry, Alex Baker-Whitcomb, Alex Beutel, Alex Borzunov, Alex Carney, Alex Chow, Alex Kirillov, Alex Nichol, Alex Pai...

    2024 arXiv

  9. [17]

    Mohammadreza Pourreza, Hailong Li, Ruoxi Sun, Yeounoh Chung, Shayan Talaei, Gaurav Tarlok Kakkar, Yu Gan, Amin Saberi, Fatma Ozcan, and Sercan O. Arik. 2024 a . https://arxiv.org/abs/2410.01943 Chase-sql: Multi-path reasoning and preference optimized candidate selection in tex...

    2024 arXiv

  10. [18]

    Mohammadreza Pourreza and Davood Rafiei. 2023. https://arxiv.org/abs/2304.11015 Din-sql: Decomposed in-context learning of text-to-sql with self-correction . Preprint, arXiv:2304.11015

    2023 arXiv

  11. [19]

    Mohammadreza Pourreza and Davood Rafiei. 2024. Dts-sql: Decomposed text-to-sql with small large language models. arXiv preprint arXiv:2402.01117

    2024 arXiv

  12. [20]

    Mohammadreza Pourreza, Ruoxi Sun, Hailong Li, Lesly Miculicich, Tomas Pfister, and Sercan O. Arik. 2024 b . https://arxiv.org/abs/2408.12733 Sql-gen: Bridging the dialect gap for text-to-sql via synthetic data and model merging . Preprint, arXiv:2408.12733

    2024 arXiv

  13. [21]

    Nitarshan Rajkumar, Raymond Li, and Dzmitry Bahdanau. 2022. https://arxiv.org/abs/2204.00498 Evaluating the text-to-sql capabilities of large language models . Preprint, arXiv:2204.00498

    2022 arXiv

  14. [22]

    Jiawei Shen, Chengcheng Wan, Ruoyi Qiao, Jiazhen Zou, Hang Xu, Yuchen Shao, Yueling Zhang, Weikai Miao, and Geguang Pu. 2025. https://arxiv.org/abs/2501.09310 A study of in-context-learning-based text-to-sql errors . Preprint, arXiv:2501.09310

    2025

  15. [23]

    Arik, Alex Muzio, Lesly Miculicich, Satya Gundabathula, Pengcheng Yin, Hanjun Dai, Hootan Nakhost, Rajarishi Sinha, Zifeng Wang, and Tomas Pfister

    Ruoxi Sun, Sercan Ö. Arik, Alex Muzio, Lesly Miculicich, Satya Gundabathula, Pengcheng Yin, Hanjun Dai, Hootan Nakhost, Rajarishi Sinha, Zifeng Wang, and Tomas Pfister. 2024. https://arxiv.org/abs/2306.00739 Sql-palm: Improved large language model adaptation for text-to-sql (e...

    2024 arXiv

  16. [24]

    Chang-You Tai, Ziru Chen, Tianshu Zhang, Xiang Deng, and Huan Sun. 2023. https://arxiv.org/abs/2305.14215 Exploring chain-of-thought style prompting for text-to-sql . Preprint, arXiv:2305.14215

    2023 arXiv

  17. [25]

    Shayan Talaei, Mohammadreza Pourreza, Yu-Chen Chang, Azalia Mirhoseini, and Amin Saberi. 2024. https://arxiv.org/abs/2405.16755 Chess: Contextual harnessing for efficient sql synthesis . Preprint, arXiv:2405.16755

    2024 arXiv

  18. [26]

    Bailin Wang, Richard Shin, Xiaodong Liu, Oleksandr Polozov, and Matthew Richardson. 2020. RAT-SQL : Relation-aware schema encoding and linking for text-to- SQL parsers. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics, pages 7567--7578...

    2020

  19. [27]

    Bing Wang, Changyu Ren, Jian Yang, Xinnian Liang, Jiaqi Bai, LinZheng Chai, Zhao Yan, Qian-Wen Zhang, Di Yin, Xing Sun, and Zhoujun Li. 2025. https://arxiv.org/abs/2312.11242 Mac-sql: A multi-agent collaborative framework for text-to-sql . Preprint, arXiv:2312.11242

    2025 arXiv

  20. [28]

    Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed Chi, Quoc Le, and Denny Zhou. 2023. https://arxiv.org/abs/2201.11903 Chain-of-thought prompting elicits reasoning in large language models . Preprint, arXiv:2201.11903

    2023 arXiv

  21. [29]

    Wenxuan Xie, Gaochen Wu, and Bowen Zhou. 2024. https://arxiv.org/abs/2408.07930 Mag-sql: Multi-agent generative approach with soft schema linking and iterative sub-sql refinement for text-to-sql . Preprint, arXiv:2408.07930

    2024 arXiv

  22. [30]

    Xiaojun Xu, Chang Liu, and Dawn Song. 2017. https://arxiv.org/abs/1711.04436 Sqlnet: Generating structured queries from natural language without reinforcement learning . Preprint, arXiv:1711.04436

    2017 arXiv

  23. [31]

    Tao Yu, Rui Zhang, Kai Yang, Michihiro Yasunaga, Dongxu Wang, Zifan Li, James Ma, Irene Li, Qingning Yao, Shanelle Roman, Zilin Zhang, and Dragomir Radev. 2019. https://arxiv.org/abs/1809.08887 Spider: A large-scale human-labeled dataset for complex and cross-domain semantic p...

    2019 arXiv

  24. [32]

    Zelle and Raymond J

    John M. Zelle and Raymond J. Mooney. 1996. Learning to parse database queries using inductive logic programming. In Proceedings of the Thirteenth National Conference on Artificial Intelligence - Volume 2, AAAI'96, page 1050–1055. AAAI Press

    1996

  25. [33]

    Hanchong Zhang, Ruisheng Cao, Hongshen Xu, Lu Chen, and Kai Yu. 2024 a . https://arxiv.org/abs/2405.02712 Coe-sql: In-context learning for multi-turn text-to-sql with chain-of-editions . Preprint, arXiv:2405.02712

    2024 arXiv

  26. [34]

    Tingkai Zhang, Chaoyu Chen, Cong Liao, Jun Wang, Xudong Zhao, Hang Yu, Jianchao Wang, Jianguo Li, and Wenhui Shi. 2024 b . https://arxiv.org/abs/2407.14568 Sqlfuse: Enhancing text-to-sql performance through comprehensive llm synergy . Preprint, arXiv:2407.14568

    2024 arXiv

  27. [35]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list...

  28. [36]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

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