SQL-Factory: A Multi-Agent Framework for High-Quality and Large-Scale SQL Generation

Huaizhong Liu; Jiahui Li; Tongwang Wu; Yajie Feng; Yunjun Gao; Yuren Mao

REVIEW 3 major objections 6 minor 70 references

SQL-Factory: A Multi-Agent Framework for High-Quality and Large-Scale SQL Generation

T0 review · 3 major / 6 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read SQL-Factory claims that a three-team multi-agent pipeline can synthesize over 300,000 executable, structurally diverse SQL queries across four benchmarks for under $200 in API cost, and that this synthetic corpus rivals official benchmark…

desk verdict A credible systems paper that makes a concrete cost-diversity claim for SQL corpus generation, with solid diversity evidence but downstream Text-to-SQL comparisons that are weaker than they look. read the letter →

arxiv 2504.14837 v5 pith:RFDYEU6Q submitted 2025-04-21 cs.DB

Jiahui Li , Tongwang Wu , Yuren Mao , Yunjun Gao , Yajie Feng , Huaizhong Liu This is my paper · ORCID

classification cs.DB

keywords SQLgenerationmulti-agentframeworktext-to-SQLquerydiversityschema-awarelargelanguagemodelsdataaugmentationclustering

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

The paper argues that the hard trade-off in automatic SQL generation—between structural diversity, schema coverage, and cost—can be broken by dividing the work among three cooperating agent teams. A strong language model generates novel, join-heavy queries; a lightweight local model scales those patterns into variants; and a management team evaluates executability and redundancy in real time, switching between the two. Applied to TPC-DS, IMDB, Spider, and BIRD, the system reports over 300,000 generated queries for under $200 in API cost, with higher diversity than existing generators. The payoff the paper pursues is practical: synthetic SQL corpora used as fine-tuning data improve small text-to-SQL models beyond what official benchmark training sets achieve, and improve SQL clustering representations.

What carries the argument

The load-bearing mechanism is the explore–exploit scheduling loop gated by a hybrid-similarity evaluator. A centralized SQL Pool stores each query's text, referenced tables, and precomputed BERT embedding, and the Management Agent switches between the Generation Team and the Expansion Team through LLM-based inference over the state transition $S_{t+1}=\mathrm{AgentM}(S_t,E_t)$. The Critical Agent combines an execution checker with a retrieval tool that scores redundancy as $\mathrm{Sim}(q,q')=\alpha\,\mathrm{SimTok}+\beta\,\mathrm{SimAST}+\gamma\,\mathrm{SimEmb}$, with $\alpha=0.6$, $\beta=0.3$, $\gamma=0.1$, where token-level, AST edit-distance, and BERT cosine similarities each contribute. This gating is what permits a cheap local 14B model to produce most of the volume while a frontier model seeds only novel structures, keeping the reported API cost under $200.

What would settle it

Compute token-level and AST-level overlap between the generated corpus and the official Spider and BIRD test sets, then retrain the same text-to-SQL models on a version of the corpus stripped of any query whose schema fragments resemble a test query; if the accuracy gains shrink to the official-data level or below, the reported improvements come from benchmark memorization rather than from SQL-Factory's generation mechanism.

Watch

Extended reading notes

Core claim

SQL-Factory's central discovery is that large-scale, high-quality SQL synthesis can be organized as an exploration–exploitation loop instead of a single monolithic generation call. In the exploration phase, a Table Selection Agent prioritizes tables by schema complexity and current coverage, and a powerful generation model writes novel join-heavy queries; in the exploitation phase, a lightweight local model rewrites selected seed queries into variants. A management layer filters candidates by executability and hybrid similarity, then decides when to switch modes. The paper reports 380,000 generated queries across TPC-DS, IMDB, Spider, and BIRD for $179.91 total API cost, of which 78.6% contain at least one join and 15.34% return empty result sets, and shows fine-tuning and contrastive-learning experiments where this corpus improves downstream text-to-SQL and clustering models.

Load-bearing premise

All reported downstream gains rest on the assumption that GPT-4o has not memorized the Spider and BIRD test queries or schemas during its own training, so the synthetic SQL-to-natural-language pairs do not leak test-like content into the fine-tuned models.

Editorial extensions

If this is right

Fine-tuning a 1B-parameter text-to-SQL model on SQL-Factory data lifts Spider exact-match accuracy from 41.3% to 70.6% for LLaMA3.2-1B, exceeding the gain from official benchmark training data.
Contrastive fine-tuning of BERT-Large on the generated corpus improves clustering quality on all three academic benchmarks tested, lowering the BetaCV compactness metric below every compared baseline.
The GPT-4o-and-expansion split cuts API cost to $179.91 across four benchmarks, about one-fifth of the estimated $1,000 if GPT-4o generated everything alone.
Schema-aware table selection aligns query frequency with table complexity, so structurally rich tables receive dense coverage instead of being starved by uniform sampling.
The observed saturation point—expansion ratio rising and average similarity trending upward—gives a data-driven stopping criterion for when further synthesis yields diminishing returns.

Reading between the lines

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

The paper does not test whether the same explore–exploit scheduling transfers to other structured-output domains; a natural extension is to apply the three-team loop to Python, Cypher, or SPARQL generation, where a frontier model seeds skeletons and a cheap local model scales them.
The hybrid-similarity gate could serve as a general-purpose filter for synthetic code corpora; one testable question is whether its 0.6/0.3/0.1 token/AST/embedding weighting is close to optimal for predicting downstream model accuracy.
The reported text-to-SQL gains are consistent with GPT-4o having memorized benchmark test queries; an extension the authors do not run is to measure n-gram and AST overlap between generated queries and the Spider/BIRD test sets and rerun the pipeline with an open-weight generator.
The stopping-criterion argument suggests a broader data-centric rule: keep generating while marginal diversity exceeds a threshold, then stop; this saturation detector could be lifted into any LLM-based data augmentation pipeline.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

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

First thing to know: this is a real engineering contribution, and the central claim—300k executable queries across four benchmarks for under $200—holds up better than most similar claims. The genuinely new piece is the division of labor: GPT-4o explores structural patterns, a local 14B model expands them, and a management agent schedules between the two using schema-complexity statistics. I have not seen that decomposition in the cited literature, and it makes sense. The Vendi Score measurements are concrete, and the comparison against SQLSmith, LearnedSQLGen, and OmniSQL is fair enough on the diversity axis. The paper also ships code and data on GitHub, so the results are checkable; that is real evidence and should be credited.

The soft spots are in the downstream claims. Table 4 compares SQL-Factory fine-tuning against official-data fine-tuning without an equal-volume control; if one side gets many more training pairs, part of the gain could just be volume. More importantly, the paper never checks whether GPT-4o has memorized Spider and BIRD queries from pretraining. Since those same benchmarks are used for evaluation, contamination would inflate the reported improvements. This is a verification gap, not a demonstrated flaw—the artifact release makes it testable—but the authors should have addressed it head-on.

There is also a metric-reuse issue: the hybrid similarity from Eq. (3) is used both as a filter inside the pipeline and as one of the diversity metrics in Table 2. That gives SQL-Factory an advantage the baselines did not have. The independent Vendi scores temper this, but it should be acknowledged and ideally re-evaluated with a held-out metric. Minor issues: no variance estimates across runs, 15% empty-result queries are reported without much discussion, and the stopping criterion is empirical rather than principled.

Who is this for? Database systems and data-centric NLP people who need cheap, large SQL corpora for benchmarking, representation learning, or training data. It deserves serious peer review: the cost-diversity claim is important enough, and the artifact release makes it falsifiable. I would want the authors to add a decontamination analysis and an equal-volume control before acceptance, but I would not desk-reject it.

Referee Report

3 major / 6 minor

Summary. The paper proposes SQL-Factory, a multi-agent framework for synthesizing large volumes of executable SQL queries from a database schema. The Generation Team (backed by GPT-4o) explores novel query structures, the Expansion Team (backed by Qwen2.5-Coder-14B) scales promising patterns from selected seeds, and the Management Team filters queries by executability and a hybrid token/AST/embedding similarity metric while scheduling between exploration and exploitation. The authors report generating over 300,000 queries across TPC-DS, IMDB, Spider, and BIRD for under $200 in API cost, higher diversity than SQLSmith, LearnedSQLGen, and OmniSQL, and improved downstream performance on Text-to-SQL and SQL query clustering after fine-tuning on the generated data.

Significance. If the claims hold, SQL-Factory is a practically useful contribution: it converts a modest API budget into a large corpus of executable SQL, and the downstream results suggest that such corpora can rival or supplement manually curated Text-to-SQL training sets. The paper ships an open-source artifact, reports concrete cost and throughput numbers, and uses Vendi Scores with two independent encoders as diversity evidence, which is a strength because that evidence does not depend on the framework's own similarity filter. The main weaknesses are experimental-control issues in the downstream evaluation, specifically unequal training volumes and the absence of a decontamination check, rather than demonstrated failures of the generation method itself.

major comments (3)

[§5.3, Table 4] The comparison between '+Official-Data' and '+SQL-Factory' is confounded by training-set volume. The paper does not report the number of <NL, SQL> pairs used in each fine-tuning setting, and the official Spider and BIRD training sets are substantially smaller than the generated corpora (130,000 and 160,000 SQL queries before NL conversion). The claim that generated data 'rivals or surpasses expert-curated sets' therefore requires an equal-volume control, for example fine-tuning on a random subset of SQL-Factory pairs matched to the size of the official training set, or reporting the number of retained synthetic pairs after the semantic-consistency filter and adding an official-plus-synthetic condition. Without such a control, the observed gains in Table 4 could be driven largely by the amount of training data rather than by the quality of SQL-Factory's output.
[§5.1.4, §5.3.1] The downstream Text-to-SQL evaluation lacks a decontamination check. The Generation Agent uses GPT-4o on Spider and BIRD schemas, and the SQL-to-NL pipeline retrieves similar examples from the official training sets of those benchmarks; Spider and BIRD are public benchmarks whose test queries and schemas may have appeared in LLM pretraining data. Because the central claim that SQL-Factory improves Text-to-SQL accuracy depends on the generated pairs not leaking test-like content, the paper should report an overlap or membership analysis (for instance, n-gram overlap between generated SQL/NL and the test sets, or an experiment that excludes schemas appearing in the official splits) or explicitly justify why contamination cannot occur.
[§4.1.2, Eq. (3); §5.2.3, Table 2] The hybrid-similarity row of Table 2 is partially circular. The same metric with hand-set weights (alpha=0.6, beta=0.3, gamma=0.1) is used inside SQL-Factory's Critical Agent to filter and deduplicate the SQL Pool, while the baselines' outputs were not filtered with it; a lower average hybrid similarity for SQL-Factory is therefore partly by construction. The independent Vendi Scores with SQL-Encoder and SimCSE support the diversity claim, so this issue is not fatal, but the hybrid-similarity comparison should be supplemented by an evaluation on the unfiltered pool, or the hybrid-similarity claim should be dropped or de-emphasized in favor of the encoder-based diversity measures.

minor comments (6)

[§5.2.6] The text says 'the expansion ratio rapidly decrease while the average similarity among queries steadily rising'; the verb forms are inconsistent, and the direction of the expansion-ratio change should be stated precisely relative to Figure 9.
[Table 4] For Deepseek-Coder-1.3B on BIRD, '+SQL-Factory' executability (79.8) is slightly below '+Official-Data' (80.3), which weakens the statement that SQL-Factory 'consistently improves' over the official-data condition; this exception should be acknowledged or explained.
[Table 2] The method name 'LearnedGen' in Table 2 should be aligned with 'LearnedSQLGen' used in the text, and the duplicated column header 'Vendi Score Vendi Score' should be corrected.
[§5.2.5, Figures 7 and 8] The schema-aware allocation analysis is qualitative: the claim that SQL-Factory's query distribution 'aligns well' with table complexity is based on visual inspection of the figures, so a quantitative measure such as the Spearman correlation between per-table query counts and Complexity(T) should be reported for both SQL-Factory and OmniSQL.
[Tables 4 and 5] Tables 4 and 5 report point estimates without variance or repeated-run statistics; because fine-tuning and clustering evaluation are stochastic, the paper should report standard deviations over multiple runs or at least state the number of runs.
[Eq. (3)] The hand-set weights in the hybrid similarity metric are not accompanied by a sensitivity analysis; since the weights affect both the internal filtering and the diversity comparison, a brief robustness check (e.g., varying alpha/beta/gamma over a small grid) would strengthen the presentation.

Circularity Check

1 steps flagged · score 4.0 of 10

Partial circularity: the hybrid-similarity metric used to filter the SQL Pool is also the headline diversity metric in Table 2; independent Vendi and downstream benchmarks keep the core contribution grounded.

fitted input called prediction [Section 4.1.2 (Eq. 3) and Section 4.3.2; Table 2 in Section 5.2.3]
"Formally, the similarity between a candidate query q and a historical query q′∈ SQL Pool is computed as: Sim(q,q′) = α·SimTok+β·SimAST+γ·SimEmb. ... After expansion, the resulting queries Qexp are passed to the Critical Agent. In this phase, queries are checked for executability and evaluated for semantic redundancy using retrieval-based similarity assessment. Only queries satisfying both executability and novelty criteria are retained in the SQL Pool. ... We use our proposed hybrid similarity metric as described in Section 4.1.2 to measure the average pairwise similarity between queries."

The hybrid similarity of Eq. (3) is the gate that decides which expanded queries are retained in the SQL Pool (novelty criterion in Section 4.3.2), and the very same metric is then reported in Table 2 as evidence that SQL-Factory's queries are more diverse. Baselines such as SQLSmith, LearnedSQLGen, and OmniSQL did not have their outputs filtered by this metric, so SQL-Factory's lower hybrid-similarity score is advantaged by construction. The independent Vendi Scores and external downstream tasks provide non-circular grounding, but the hybrid-similarity diversity claim itself is not independent evidence.

full rationale

SQL-Factory's central generation and downstream claims are largely self-contained. The 300k-query corpus, API-cost accounting, and Text-to-SQL/clustering gains rest on external benchmarks (Spider/BIRD, IIT Bombay, UB Exam, PocketData) and on Vendi Score with two independent encoders, so the core contribution does not collapse into its inputs. The main circularity is localized to the hybrid-similarity diversity comparison: Eq. (3) is used inside the Critical Agent to filter expanded queries for novelty, and the same metric is then reported in Table 2 as evidence of higher diversity, giving SQL-Factory an advantage by construction over baselines that were not filtered by it. There is no load-bearing self-citation; the few self-citations (e.g., [30], [12], [59]) are routine related-work background, and no uniqueness theorem or ansatz is imported from prior work by the same authors. The evaluation-metric circularity is partial because independent evidence remains, but it should be acknowledged or supplemented with a filtered-baseline comparison.

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

The reported diversity, cost, and downstream gains rest on hand-set similarity weights, empirical stopping thresholds, agent temperatures, and retrieval constants. The pipeline also assumes executability and low similarity are adequate quality proxies, that the LLM verifier labels are trustworthy, and that GPT-4o does not leak Spider/BIRD content into the generated training pairs.

free parameters (5)

Hybrid similarity weights = alpha=0.6, beta=0.3, gamma=0.1
Set by hand in Eq. 3 and used both to filter the SQL Pool and as a diversity evaluation metric; the reported diversity advantage depends partly on these choices.
Table complexity weights = Complexity = NA + 2*RD + DRT
Introduced in Eq. 12 for the schema-allocation analysis; the factor of 2 and the additive form are chosen without calibration.
Agent temperatures = 0.8 for generation/expansion, 0.3 for management/selection/critique
Chosen to favor exploration or stability; no sensitivity analysis is reported, and temperature changes the query distribution and cost.
Retrieval and deduplication constants = k=5; top-(k*20) candidates; top-20 positives for contrastive training
Fixed values used by the Retrieval Tool and clustering fine-tuning; no ablation is given for their effect.
Stopping criterion (saturation point) = not quantified; chosen empirically per benchmark
Section 5.2.6 defines termination by expansion ratio and similarity trends but provides no explicit threshold, so corpus sizes are partly determined by an ad hoc rule.

assumptions (4)

domain assumption Executable SQL and low pairwise similarity are adequate proxies for generated corpus quality.
The Critical Agent filters on executability and hybrid similarity (Section 4.1.2), and the paper uses these filters as evidence of quality in Section 5.2 without a direct link to downstream utility.
domain assumption LLM-based SQL-to-NL conversion plus a CoT verifier produces semantically faithful training pairs, and the 1,000-sample human check generalizes to the full corpus.
The Text-to-SQL dataset construction in Section 5.3.1 relies on this pipeline; verifier errors would directly corrupt the fine-tuning labels.
domain assumption GPT-4o generations over Spider and BIRD schemas are not contaminated by benchmark queries from pretraining.
The strongest downstream results use GPT-4o-generated SQL translated to NL (Sections 5.1.4 and 5.3.1); no decontamination or overlap analysis is provided.
domain assumption Off-the-shelf diversity and similarity measures capture the aspects of SQL corpora that matter for downstream tasks.
Vendi Score, hybrid similarity, and BetaCV are treated as quality signals without a rigorous mapping to task performance beyond the two reported downstream experiments.

how reviews work

0 comments

Cite this review

Pith. "Pith review of SQL-Factory: A Multi-Agent Framework for High-Quality and Large-Scale SQL Generation." pith.science (2026). https://pith.science/paper/RFDYEU6Q

@misc{pith2026250414837,
  author       = {Pith},
  title        = {Pith review of: SQL-Factory: A Multi-Agent Framework for High-Quality and Large-Scale SQL Generation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/RFDYEU6Q}},
  note         = {Machine review of arXiv:2504.14837}
}

abstract

High quality SQL corpus is essential for intelligent database. For example, Text-to-SQL requires SQL queries and correspond natural language questions as training samples. However, collecting such query corpus remains challenging in practice due to the high cost of manual annotation, which highlights the importance of automatic SQL generation. Despite recent advances, existing generation methods still face limitations in achieving both diversity and cost-effectiveness. Besides, many methods also treat all tables equally, which overlooks schema complexity and leads to under-utilization of structurally rich tables. To address these issues, this paper proposes a multi-agent framework for high-quality and large-scale SQL generation, dubbed SQL-Factory. It decomposes the generation process into three collaborative teams: the Generation Team explores diverse query structures using a powerful language model, the Expansion Team scales promising patterns via a lightweight language model, and the Management Team adaptively schedules the workflow and evaluates the quality of synthesized queries. This modular framework ensures a balanced trade-off between diversity, scalability, and generation cost. We apply SQL-Factory to four widely used benchmarks and generate over 300,000 SQL queries with less than $200 API cost. Our generated queries achieve higher diversity compared to other methods, and extensive experiments demonstrate that the generated queries significantly improve the model performance in various downstream tasks.

Figures

Figures reproduced from arXiv: 2504.14837 by the authors.

**Figure 2.** An overview of SQL-Factory. complex tables or those with few synthesized queries. Then, the Generation Agent employs a powerful LLM to generate novel and semantically valid queries for selected tables. These queries often include complex structures such as nested subqueries, aggregations, and multi-table joins. By focusing on pattern exploration, the Generation Team ensures the introduction of high-diversity query … view at source ↗

**Figure 3.** An overview of our hybrid similarity. Specifically, the system begins in the exploration phase, where the Generation Team synthesizes queries for structurally complex tables or those with few synthesized queries. After a fixed number of generation cycles, control shifts to the Expansion Team to exploit learned patterns. During this exploitation phase, the Management Agent continuously monitors evaluation informati… view at source ↗

Figures from the paper (6 more)

**Figure 4.** Figure 4: Generation Prompt Template. Finally, the Critical Agent aggregates the execution validation results from ToolE and retrieval results from ToolR to produce the final evaluation score. 𝐸𝑡 = AgentC (Q𝑡 , ToolE, ToolR), (6) The final evaluation result 𝐸𝑡 is then passed to …

**Figure 5.** Figure 5: Expansion Prompt Template. constraints. For numeric or date type columns (e.g., int, float, date), we include its minimum and maximum values in the database, offering statistical context for range-based predicates (e.g., price > 100). For free-text or string columns, …

**Figure 6.** Figure 6: Overview of SQL queries synthesized by SQL-Factory. [PITH_FULL_IMAGE:figures/full_fig_p009_6.png]

**Figure 7.** Figure 7: Query and Complexity Distributions in OmniSQL. [PITH_FULL_IMAGE:figures/full_fig_p010_7.png]

**Figure 8.** Figure 8: Query and Complexity Distributions in SQL [PITH_FULL_IMAGE:figures/full_fig_p010_8.png]

**Figure 9.** Figure 9: Evolution of Expansion Ratio and Overall Similarity [PITH_FULL_IMAGE:figures/full_fig_p011_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

70 extracted references · 54 canonical work pages

[1]

Shadi Abdul Khalek and Sarfraz Khurshid. 2010. Automated SQL query genera- tion for systematic testing of database engines. In ASE

work page 2010
[2]

Meta AI. 2024. Llama 3.2: Revolutionizing edge AI and vision with open, cus- tomizable models. https://ai.meta.com/blog/llama-3-2-connect-2024-vision- edge-mobile-devices

work page 2024
[3]

Julien Aligon, Matteo Golfarelli, Patrick Marcel, et al. 2014. Similarity measures for OLAP sessions. Knowledge and information systems 39 (2014), 463–489

work page 2014
[4]

Kamel Aouiche, Pierre-Emmanuel Jouve, and Jérôme Darmont. 2006. Clustering- based materialized view selection in data warehouses. In ADBIS. 81–95

work page 2006
[5]

Alexander Bianchi, Andrew Chai, Vincent Corvinelli, Parke Godfrey, Jarek Szlichta, and Calisto Zuzarte. 2024. Db2une: Tuning Under Pressure via Deep Learning. Proc. VLDB Endow. 17, 12 (2024), 3855–3868

work page 2024
[6]

Jean-Flavien Bussotti, Enzo Veltri, Donatello Santoro, and Paolo Papotti. 2023. Generation of Training Examples for Tabular Natural Language Inference. In SIGMOD

work page 2023
[7]

Bikash Chandra, Bhupesh Chawda, Biplab Kar, K Reddy, Shetal Shah, and S Sudarshan. 2015. Data generation for testing and grading SQL queries. Proc. VLDB Endow. 24, 6 (2015), 731–755

work page 2015
[8]

Weize Chen, Yusheng Su, Jingwei Zuo, et al. 2023. Agentverse: Facilitating multi- agent collaboration and exploring emergent behaviors in agents. arXiv preprint arXiv:2308.10848 (2023)

arXiv 2023

Show all 70 references

[9]

Xinyun Chen, Maxwell Lin, Nathanael Schärli, and Denny Zhou. 2023. Teaching large language models to self-debug. arXiv preprint arXiv:2304.05128 (2023)

2023 arXiv
[10]

Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. 2019. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL. 4171–4186

2019
[11]

Bailu Ding, Surajit Chaudhuri, Johannes Gehrke, and Vivek Narasayya. 2021. DSB: A decision support benchmark for workload-driven and traditional database systems. Proc. VLDB Endow. 14, 13 (2021), 3376–3388

2021
[12]

Xuemei Dong, Chao Zhang, Yuhang Ge, Yuren Mao, Yunjun Gao, Jinshu Lin, Dongfang Lou, et al. 2023. C3: Zero-shot text-to-sql with chatgpt. arXiv preprint arXiv:2307.07306 (2023)

2023 arXiv
[13]

Dan Friedman and Adji Bousso Dieng. 2023. The Vendi Score: A Diversity Evaluation Metric for Machine Learning. Transactions on Machine Learning Research (2023)

2023
[14]

Dawei Gao, Haibin Wang, Yaliang Li, Xiuyu Sun, Yichen Qian, Bolin Ding, and Jingren Zhou. 2024. Text-to-SQL Empowered by Large Language Models: A Benchmark Evaluation. Proc. VLDB Endow. 17, 5 (2024), 1132–1145

2024
[15]

Tianyu Gao, Xingcheng Yao, and Danqi Chen. 2021. SimCSE: Simple Contrastive Learning of Sentence Embeddings. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing . 6894–6910

2021
[16]

Robert Giaquinto, Dejiao Zhang, Benjamin Kleiner, et al. 2023. Multitask pretrain- ing with structured knowledge for text-to-SQL generation. InACL. 11067–11083

2023
[17]

Daya Guo, Yibo Sun, Duyu Tang, et al . 2018. Question Generation from SQL Queries Improves Neural Semantic Parsing. In EMNLP. 1597–1607

2018
[18]

Daya Guo, Qihao Zhu, Dejian Yang, et al . 2024. DeepSeek-Coder: When the Large Language Model Meets Programming–The Rise of Code Intelligence.arXiv preprint arXiv:2401.14196 (2024)

2024 arXiv
[19]

Chenxu Hu, Jie Fu, Chenzhuang Du, Simian Luo, Junbo Zhao, and Hang Zhao
[20]

Yi Huang, Fangyin Cheng, Fan Zhou, et al . 2024. ROMAS: A Role-Based Multi-Agent System for Database monitoring and Planning. arXiv preprint arXiv:2412.13520 (2024)

2024 arXiv
[21]

Binyuan Hui, Jian Yang, Zeyu Cui, et al. 2024. Qwen2. 5-coder technical report. arXiv preprint arXiv:2409.12186 (2024)

2024 arXiv
[22]

Oliver Kennedy, Jerry Ajay, Geoffrey Challen, and Lukasz Ziarek. 2016. Pocket data: The need for TPC-MOBILE. In TPCTC. 8–25

2016
[23]

Hideo Kobayashi, Wuwei Lan, Peng Shi, et al. 2025. You Only Read Once (YORO): Learning to Internalize Database Knowledge for Text-to-SQL. In NAACL. 1889– 1901

2025
[24]

Igor Kotsyuba, Pavel Bezkorovaynyi, Julia Silko, and Alexey Shikov. 2021. Au- tomating MySQL database complexity estimation based on quantitative metrics. In INTERAGROMASH. 378–386

2021
[25]

Gokhan Kul, Duc Thanh Anh Luong, Ting Xie, Varun Chandola, Oliver Kennedy, and Shambhu Upadhyaya. 2018. Similarity Metrics for SQL Query Clustering. IEEE Transactions on Knowledge and Data Engineering 30, 12 (2018), 2408–2420

2018
[26]

Viktor Leis, Bernhard Radke, Andrey Gubichev, et al. 2018. Query optimization through the looking glass, and what we found running the join order benchmark. Proc. VLDB Endow. 27, 5 (2018), 643–668

2018
[27]

Haoyang Li, Shang Wu, Xiaokang Zhang, et al. 2025. OmniSQL: Synthesizing High-quality Text-to-SQL Data at Scale

2025
[28]

Haoyang Li, Jing Zhang, Hanbing Liu, et al . 2024. CodeS: Towards Building Open-source Language Models for Text-to-SQL. SIGMOD

2024
[29]

Jinyang Li, Binyuan Hui, Ge Qu, et al. 2023. Can llm already serve as a database interface? a big bench for large-scale database grounded text-to-sqls. NeurIPS (2023), 42330–42357

2023
[30]

Jiahui Li, Junhao Ye, Yuren Mao, Yunjun Gao, and Lu Chen. 2025. LOFTune: A Low-Overhead and Flexible Approach for Spark SQL Configuration Tuning. IEEE Transactions on Knowledge and Data Engineering (2025), 1–14

2025
[31]

Pengfei Li, Wenqing Wei, Rong Zhu, Bolin Ding, Jingren Zhou, and Hua Lu. 2023. ALECE: An Attention-based Learned Cardinality Estimator for SPJ Queries on Dynamic Workloads. 17, 2 (2023), 197–210

2023
[32]

Xinyue Liu, Xiangnan Kong, Lei Liu, et al . 2018. TreeGAN: Syntax-Aware Sequence Generation with Generative Adversarial Networks. In ICDM

2018
[33]

Andrew Maas, Raymond E Daly, Peter T Pham, Dan Huang, Andrew Y Ng, and Christopher Potts. 2011. Learning word vectors for sentiment analysis. In ACL. 142–150

2011
[34]

Vitor Hirota Makiyama, M Jordan Raddick, and Rafael DC Santos. 2015. Text Mining Applied to SQL Queries: A Case Study for the SDSS SkyServer.. InSIMBig. 66–72

2015
[35]

Ali Modarressi, Ayyoob Imani, Mohsen Fayyaz, and Hinrich Schütze. 2023. Ret- llm: Towards a general read-write memory for large language models. arXiv preprint arXiv:2305.14322 (2023)

2023 arXiv
[36]

J Zaki Mohammed and Meira Wagner. 2014. Data mining and analysis: funda- mental concepts and algorithms. Cambridge University (2014)

2014
[37]

Raghunath Othayoth Nambiar and Meikel Poess. 2006. The making of TPC-DS. In VLDB

2006
[38]

Parimarjan Negi, Ziniu Wu, Andreas Kipf, et al . 2023. Robust query driven cardinality estimation under changing workloads. Proc. VLDB Endow. 16, 6 (2023), 1520–1533

2023
[39]

OpenAI. 2024. Hello GPT-4o. https://openai.com/index/hello-gpt-4o/

2024
[40]

Mile Pavlic, Marin Kaluza, and Neven Vrcek. 2008. Database complexity measur- ing method. In CECIIS

2008
[41]

Mario Piattini, Coral Calero, and Marcela Genero. 2001. Table oriented metrics for relational databases. Software Quality Journal 9, 2 (2001), 79–97

2001
[42]

Meikel Poess and Chris Floyd. 2000. New TPC benchmarks for decision support and web commerce. ACM SIGMOD Record 29, 4 (2000), 64–71

2000
[43]

Mohammadreza Pourreza and Davood Rafiei. 2023. DIN-SQL: decomposed in- context learning of text-to-SQL with self-correction. In Proceedings of the 37th International Conference on Neural Information Processing Systems

2023
[44]

Mohammadreza Pourreza, Davood Rafiei, Yuxi Feng, et al. 2024. SQL-Encoder: Improving NL2SQL In-Context Learning Through a Context-Aware Encoder

2024
[45]

Chen Qian, Wei Liu, Hongzhang Liu, et al . 2024. ChatDev: Communicative Agents for Software Development. In ACL. 15174–15186

2024
[46]

Andreas Seltenreich. 2016. SQLSmith. https://github.com/anse1/sqlsmith

2016
[47]

Donald R Slutz. 1998. Massive stochastic testing of SQL. In VLDB, Vol. 98. 618– 622

1998
[48]

Ruoxi Sun, Sercan Ö Arik, Hootan Nakhost, et al. 2023. SQL-PaLM: Improved Large Language Model Adaptation for Text-to-SQL. CoRR (2023)

2023
[49]

Xiu Tang, Sai Wu, Mingli Song, Shanshan Ying, Feifei Li, and Gang Chen. 2022. PreQR: pre-training representation for SQL understanding. InSIGMOD. 204–216

2022
[50]

Xiangru Tang, Anni Zou, Zhuosheng Zhang, et al . 2024. MedAgents: Large Language Models as Collaborators for Zero-shot Medical Reasoning. In ACL

2024
[51]

Gordon, and Bohan Zhang

Dana Van Aken, Andrew Pavlo, Geoffrey J. Gordon, and Bohan Zhang. 2017. Automatic Database Management System Tuning Through Large-scale Machine Learning. In SIGMOD

2017
[52]

Bing Wang, Changyu Ren, Jian Yang, et al . 2025. MAC-SQL: A Multi-Agent Collaborative Framework for Text-to-SQL. InProceedings of the 31st International Conference on Computational Linguistics

2025
[53]

Fang Wang, Xiao Yan, Man Lung Yiu, Shuai LI, Zunyao Mao, and Bo Tang
[54]

Lei Wang, Chen Ma, Xueyang Feng, et al . 2024. A survey on large language model based autonomous agents. Frontiers of Computer Science 18, 6 (2024), 186345

2024
[55]

Speeding Up End-to-end Query Execution via Learning-based Progressive Cardinality Estimation. SIGMOD
[56]

Kun Wu, Lijie Wang, Zhenghua Li, et al. 2021. Data Augmentation with Hierar- chical SQL-to-Question Generation for Cross-domain Text-to-SQL Parsing. In EMNLP. 8974–8983

2021
[57]

Taiyi Wang, Liang Liang, Guang Yang, Thomas Heinis, and Eiko Yoneki. 2025. A New Paradigm in Tuning Learned Indexes: A Reinforcement Learning Enhanced Approach. arXiv preprint arXiv:2502.05001 (2025)

2025 arXiv
[58]

Wenxuan Xie, Gaochen Wu, and Bowen Zhou. 2024. Mag-sql: Multi-agent generative approach with soft schema linking and iterative sub-sql refinement for text-to-sql. arXiv preprint arXiv:2408.07930 (2024)

2024 arXiv
[59]

Zhiheng Xi, Wenxiang Chen, Xin Guo, et al. 2025. The rise and potential of large language model based agents: A survey. Science China Information Sciences 68, 2 (2025), 121101

2025
[60]

Tao Yu, Rui Zhang, Kai Yang, et al. 2018. Spider: A large-scale human-labeled dataset for complex and cross-domain semantic parsing and text-to-SQL task. In EMNLP. 3911–3921. 13

2018
[61]

Wenyi Xu, Yuren Mao, Xiaolu Zhang, et al. 2025. DAgent: A Relational Database- Driven Data Analysis Report Generation Agent. arXiv preprint arXiv:2503.13269 (2025)

2025 arXiv
[62]

Chao Zhang, Yuren Mao, Yijiang Fan, et al. 2024. FinSQL: model-agnostic LLMs- based text-to-SQL framework for financial analysis. In SIGMOD. 93–105

2024
[63]

Tao Yu, Zhaonian Zou, and Hao Xiong. 2024. Can Uncertainty Quantification Enable Better Learning-based Index Tuning? arXiv preprint arXiv:2410.17748 (2024)

2024 arXiv
[64]

Lixi Zhang, Chengliang Chai, Xuanhe Zhou, and Guoliang Li. 2022. Learned- SQLGen: Constraint-aware SQL Generation using Reinforcement Learning. In SIGMOD

2022
[65]

Ji Zhang, Yu Liu, Ke Zhou, et al. 2019. An End-to-End Automatic Cloud Database Tuning System Using Deep Reinforcement Learning. In SIGMOD

2019
[66]

Yaowei Zheng, Richong Zhang, Junhao Zhang, et al. 2024. LlamaFactory: Unified Efficient Fine-Tuning of 100+ Language Models. In ACL. 400–410

2024
[67]

Yi Zhang, Jan Deriu, George Katsogiannis-Meimarakis, et al. 2023. ScienceBench- mark: A Complex Real-World Benchmark for Evaluating Natural Language to SQL Systems. Proceedings of the VLDB Endowment 17, 4 (2023), 685–698

2023
[68]

Xuanhe Zhou, Guoliang Li, Zhaoyan Sun, et al. 2024. D-Bot: Database Diagnosis System using Large Language Models. Proc. VLDB Endow. 17, 10 (2024), 2514– 2527. 14

2024
[69]

Zhiling Zheng, Oufan Zhang, Ha L Nguyen, et al. 2023. Chatgpt research group for optimizing the crystallinity of mofs and cofs. ACS Central Science 9, 11 (2023), 2161–2170

2023
[2023]

arXiv preprint arXiv:2306.03901 (2023)

Chatdb: Augmenting llms with databases as their symbolic memory. arXiv preprint arXiv:2306.03901 (2023)

2023 arXiv

Pith tools

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

[1] [1]

Shadi Abdul Khalek and Sarfraz Khurshid. 2010. Automated SQL query genera- tion for systematic testing of database engines. In ASE

work page 2010

[2] [2]

Meta AI. 2024. Llama 3.2: Revolutionizing edge AI and vision with open, cus- tomizable models. https://ai.meta.com/blog/llama-3-2-connect-2024-vision- edge-mobile-devices

work page 2024

[3] [3]

Julien Aligon, Matteo Golfarelli, Patrick Marcel, et al. 2014. Similarity measures for OLAP sessions. Knowledge and information systems 39 (2014), 463–489

work page 2014

[4] [4]

Kamel Aouiche, Pierre-Emmanuel Jouve, and Jérôme Darmont. 2006. Clustering- based materialized view selection in data warehouses. In ADBIS. 81–95

work page 2006

[5] [5]

Alexander Bianchi, Andrew Chai, Vincent Corvinelli, Parke Godfrey, Jarek Szlichta, and Calisto Zuzarte. 2024. Db2une: Tuning Under Pressure via Deep Learning. Proc. VLDB Endow. 17, 12 (2024), 3855–3868

work page 2024

[6] [6]

Jean-Flavien Bussotti, Enzo Veltri, Donatello Santoro, and Paolo Papotti. 2023. Generation of Training Examples for Tabular Natural Language Inference. In SIGMOD

work page 2023

[7] [7]

Bikash Chandra, Bhupesh Chawda, Biplab Kar, K Reddy, Shetal Shah, and S Sudarshan. 2015. Data generation for testing and grading SQL queries. Proc. VLDB Endow. 24, 6 (2015), 731–755

work page 2015

[8] [8]

Weize Chen, Yusheng Su, Jingwei Zuo, et al. 2023. Agentverse: Facilitating multi- agent collaboration and exploring emergent behaviors in agents. arXiv preprint arXiv:2308.10848 (2023)

arXiv 2023