Pith. sign in

REVIEW 5 major objections 7 minor 1 cited by

Toward Real-World Table Agents: Capabilities, Workflows, and Design Principles for LLM-based Table Intelligence

T0 review · 5 major / 7 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 This survey defines five competencies for LLM-based table agents and reports a controlled Text-to-SQL evaluation in which most agent frameworks add little or nothing for weaker open-source models.

desk verdict A useful capability-centric survey with a genuine but narrow empirical result on Text-to-SQL agents; the abstract's real-world gap claim goes beyond what the clean-benchmark experiments actually show. read the letter →

arxiv 2507.10281 v1 pith:IGZLZ5LH submitted 2025-07-14 cs.AI cs.DB

Jiaming Tian , Liyao Li , Wentao Ye , Haobo Wang , Lingxin Wang , Lihua Yu , Zujie Ren , Gang Chen
show 1 more author
Junbo Zhao
This is my paper · ORCID
classification cs.AIcs.DB
keywords LLM-basedtableagentsText-to-SQLreasoningintelligenceopen-sourceLLMsExecutionAccuracyfivecorecompetenciesbenchmark-to-real-worldgap
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 survey argues that LLM-based table agents should be organized around five competencies—structure understanding, semantic understanding, retrieval and compression, traceable executable reasoning, and cross-domain generalization—and it uses that lens to review current systems. Its sharpest claim is empirical: in head-to-head Text-to-SQL runs on Spider and BIRD, most published agent frameworks give little or no benefit over a simple schema-and-prompt baseline when the underlying model is a smaller open-source LLM, and sometimes hurt. The authors take this as evidence that the field's benchmark-driven progress is overshooting practical deployment, where cost, privacy, and local compute push users toward weaker models. A sympathetic reader would care because the survey names a concrete mismatch between where table-agent research is optimizing and where real-world table work happens.

What carries the argument

The survey's organizing machinery is the five-competency taxonomy, which gives each section a capability to measure methods against rather than a tool to praise. The quantitative machinery is a controlled Text-to-SQL evaluation: one shared Execution Accuracy implementation, three open-source models (TableGPT2-7B, Qwen2.5-Coder-7B, and Qwen2.5-Coder-32B), a plain baseline prompt, and seven agent methods layered on top so that any accuracy change can be attributed to the agent scaffold. The baseline-versus-agent contrast carries the argument.

What would settle it

Run the same seven Text-to-SQL agent methods and the plain baseline on a benchmark of real-world messy tables with dirty values, merged cells, and domain abbreviations, using TableGPT2-7B and Qwen2.5-Coder-7B; if the agent frameworks substantially beat the baseline there even though they do not on Spider and BIRD, the claim that current methods are ill-suited to real-world deployment would lose its main support.

Watch

Extended reading notes

Core claim

The paper's central claim is that real-world table intelligence is best understood as five competencies—C1 table structure understanding, C2 table and query semantic understanding, C3 table retrieval and compression, C4 executable reasoning with traceability, and C5 cross-domain generalization—and that current systems fall short on exactly those competencies when taken outside clean academic data. The quantitative support comes from a controlled Text-to-SQL comparison on Spider and BIRD using three open-source models. For most tested agent frameworks, the paper reports that Execution Accuracy is roughly flat or worse than a plain prompt-and-schema baseline, with the notable exception of OpenSearch-SQL on the weaker TableGPT2-7B model. The authors conclude that many published agent designs are optimized for powerful closed models and fail to transfer to the lighter open-source models that real-world deployments often require.

Load-bearing premise

The load-bearing premise is that Execution Accuracy on the clean Spider and BIRD benchmarks is a reliable proxy for the real-world performance gap the survey claims, because the experiments never run on the noisy and heterogeneous tables that motivate the paper.

Editorial extensions

If this is right

  • Agent frameworks that add multi-step decomposition, self-correction, and retrieval must be re-evaluated on the actual deployable model, because the reported runs show they can add token cost without adding accuracy.
  • For weaker open-source models, base-model instruction following and formatted-output capability appear to be a larger lever than agent scaffolding, so improving those abilities may matter more than adding workflow modules.
  • The absence of real-world table benchmarks means the claimed performance gap cannot currently be measured directly, making benchmark construction a necessary next step.
  • The design principles the survey derives—multiformat input, integrated preprocessing, stepwise traceability, sandboxed execution, modular architecture, and real-world adaptation—constitute a concrete checklist for building the next generation of table agents.
  • If the reported exception holds, consistency-alignment mechanisms like those in OpenSearch-SQL are the most promising agent technique for weaker models and deserve focused follow-up.

Reading between the lines

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

  • A natural extension is to hold the agent architecture fixed and vary model scale, which would quantify how much of any agent benefit is gated by base-model capability rather than by the framework itself.
  • If the paper's clean-benchmark results were repeated on noisy, messy tables, the performance gap might grow or shrink asymmetrically; adding such a condition would test whether the real-world gap is larger than reported.
  • The survey's emphasis on traceability suggests a testable design: compare DSL-based agents against SQL/Python agents on fault-localization time for incorrect outputs, since traceability claims are currently qualitative.
  • A competence-specific benchmark that measures each of C1–C5 separately on realistic data would let developers see which competency is the actual bottleneck before choosing an agent architecture.
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

5 major / 7 minor

Summary. The manuscript is a survey of LLM-based table agents organized around five proposed core competencies (C1: Table Structure Understanding, C2: Table and Query Semantic Understanding, C3: Table Retrieval and Compression, C4: Executable Reasoning with Traceability, C5: Cross-Domain Generalization). It reviews methods for each capability, compares representative end-to-end agents in a workflow-oriented table, and reports a small quantitative study of Text-to-SQL agents on Spider-dev, Spider-test, and BIRD-dev using three open-source models. The paper's central empirical claim is that most agent techniques give little, marginal, or negative improvements on weaker open-source models on academic benchmarks, and it extrapolates from this to a 'performance gap' between academic benchmarks and real-world scenarios. The paper concludes with seven design principles and five future research directions.

Significance. If the empirical finding is accepted, it is a useful caution for the field: many Text-to-SQL agent frameworks are validated on strong closed-source models and may not transfer to locally deployed open-source models. The five-competency taxonomy and the workflow comparison in Table 3 are useful organizing devices, and the paper is candid about several evaluation limitations, including excluded models, failure replacement, and budget constraints. The experimental protocol is described specifically enough to be replicated, and the full MAGIC guidelines in Appendix A support transparency. However, the headline claim about a real-world performance gap is not directly tested, and the quantitative evidence in Table 4 lacks variance estimates; these weaknesses are load-bearing for the paper's central message and need to be addressed before publication.

major comments (5)
  1. The claim of a 'performance gap between academic benchmarks and real-world scenarios, especially for open-source models' is not supported by the experiments, because all three evaluation sets (Spider-dev, Spider-test, BIRD-dev) are clean academic benchmarks. The extrapolation in §4.2—'as many agent techniques show only marginal gains even on academic benchmarks, their real-world effectiveness—under more complex conditions—is likely even more limited'—assumes that the benefit of agent scaffolding degrades monotonically as tables become noisier, larger, and more heterogeneous. The opposite is plausible for methods such as TableRAG, OPENTAB, and ReAcTable, whose retrieval and compression modules are specifically designed for large or noisy tables and may have little to do on the small, clean schemas in Spider. I recommend either evaluating on a real-world noisy-table benchmark or a constructed noisy variant, or explicitly reframing the abstract and conclusion as a hypothesis about real-world transfer rather than an empirical result.
  2. The central quantitative claim that 'most methods applied to academic datasets have little to no effect or only yield marginal improvements' is presented without repeated runs, variance estimates, or significance tests. Several differences are within a fraction of a point—for example, Qwen2.5-Coder-7B-Instruct on Spider-dev: baseline 76.89, CHESSICU 76.60, MAGIC 77.27—yet these are used to support claims about 'no effect.' I request at least a few repeated runs where sampling is involved, or a clear statement that differences below a prespecified threshold are treated as noise, together with a per-method/per-model breakdown of which effects are positive, negative, and effectively null.
  3. The failure-replacement protocol biases Table 4 in an unknown direction. For CHESS, MAGIC, and OpenSearch-SQL, the authors 'replaced failing samples with baseline SQL queries,' meaning a method that produces no valid output is credited with the baseline accuracy on those samples. This can inflate the measured performance of a method that fails often, or deflate it if the baseline is worse than what a successful method would have produced. Additionally, TableGPT2-7B is excluded from both CHESS rows due to format mismatches, even though this model is central to the 'weaker open-source models' claim. I ask for the failure rates for each method/model, results before replacement, and a sensitivity analysis so that readers can assess how much the conclusions depend on this protocol.
  4. The MAGIC experiment uses DeepSeek-V3 to correct the formatting of guidelines generated by the weak models. This is a substantial intervention: the guidelines shown in Appendix A are well-structured and generic, and the measured Execution Accuracy reflects the weak model combined with a strong external formatter, not the weak model's own ability to produce and apply self-correction guidelines. Since the paper's stated purpose is to test whether weaker models can benefit from agent methods, this variant should be clearly labeled as 'MAGIC with external formatting correction,' and ideally ablated against using the raw, unformatted guidelines to quantify the effect of the intervention.
  5. The Execution Accuracy implementation and the baseline prompt are both taken from TableGPT2-agent, and TableGPT2-7B is one of the three evaluated models. This coupling creates an asymmetry in the cross-model comparison: the prompt and evaluation harness may be better aligned with TableGPT2's output conventions than with the Qwen models or with other agent frameworks. I do not think this is disqualifying, but the paper should either provide evidence that the main conclusions are robust to using a neutral or model-agnostic prompt and EX implementation, or explicitly acknowledge this as a limitation when interpreting the 'weaker open-source models' claim.
minor comments (7)
  1. The text says 'A simple comparison of these formats is presented in Figure 1,' but the comparison is actually in Table 1; please correct the cross-reference.
  2. Figure 2 labels both the second and third panels as '(b)'; the third panel should be labeled '(c)'.
  3. The manuscript contains many spacing artifacts such as 'T able Agents,' 'T able Reasoning,' and 'T able Generation,' likely introduced during PDF extraction; these should be cleaned so that 'Table' is spelled correctly.
  4. References [10] and [11] are duplicate entries for the same survey of LLM-based autonomous agents; one should be removed or the two should be merged.
  5. Reference [165] is listed separately from [18] even though both point to the TableGPT2 arXiv paper; please unify them or clarify the distinction, since the current formatting makes it look like two different works.
  6. In the DataLab entry, 'A unifed platform' should be 'A unified platform.'
  7. The MAGIC appendix is very long, occupying roughly twelve pages of guidelines; consider moving the full guidelines to supplementary material and summarizing the guideline structure in the main text.

Circularity Check

0 steps flagged · score 0.0 of 10

No load-bearing circularity: the empirical claims rest on external Spider/BIRD evaluations and external agent methods, and the TableGPT2 self-citations are not used to derive the central conclusions.

full rationale

This paper is a survey with a small empirical evaluation rather than a formal derivation, so the self-definitional and fitted-input patterns do not apply. The central empirical claim in Contribution 4 and Section 4.2, that most Text-to-SQL agent methods give little or no improvement on weaker open-source models, is grounded in Execution Accuracy on the external benchmarks Spider-dev, Spider-test, and BIRD-dev (Table 4). The compared agents (MAC-SQL, MAG-SQL, CHESS, MAGIC, OpenSearch-SQL) are external systems, and the TableGPT2-agent implementation is used only as the evaluation harness and baseline prompt, not as the source of the predicted outcome. The extrapolation that real-world effectiveness is likely even more limited is explicitly acknowledged in the text as an inference under budget constraints; an unmeasured extrapolation is a correctness or evidence limitation, not circularity. The five-competency taxonomy (C1-C5) is an organizing framework rather than a result derived from itself. The only notable self-citation is the qualitative statement in Section 4.1 that TableGPT2 stands out as the most comprehensive agent, which has a self-referential flavor but is not load-bearing for the paper's main claims and does not reduce to a construction or fitted value. Because no specific reduction by the paper's own equations or definitions can be exhibited, the circularity score is 0.

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

The ledger is clean on parameters and entities: no fitted constants and no invented mechanisms. The load-bearing assumptions are evaluative, a single-metric benchmark, a three-model sample, the inference from academic benchmarks to real-world scenarios, and an ad hoc strong-model repair of MAGIC guidelines.

free parameters (1)
  • Temperature = 0
    Decoding temperature set to 0 for baseline and CoT experiments to ensure determinism; chosen by hand and affects absolute scores, though relative rankings are unlikely to reverse.
assumptions (4)
  • domain assumption Execution Accuracy (EX) as implemented by TableGPT2-agent is a sufficient metric for Text-to-SQL quality.
    Used as the sole metric in Table 4; different EX implementations vary (ordering of results), so the choice could affect cross-method comparisons. Location: §4.2 Metric.
  • domain assumption The three selected open-source models (TableGPT2-7B, Qwen2.5-Coder-7B-Instruct, Qwen2.5-Coder-32B-Instruct) are representative of weaker open-source models used in real-world deployment.
    The generalization claim about 'weaker open-source models' rests on this small sample; QwQ-32B was excluded. Location: §4.2 Models.
  • domain assumption Academic benchmarks (Spider, BIRD) are adequate surrogates for the academic side of the academic-vs-real-world gap; the real-world side is inferred, not measured.
    The abstract claims a real-world performance gap, but experiments only run on Spider and BIRD. Location: Abstract and §4.2 Benchmark.
  • ad hoc to paper Using DeepSeek-V3 to reformat MAGIC guidelines does not materially alter the measured performance of the model under test.
    The guidelines fed to weaker models were post-processed by a stronger model, potentially injecting knowledge beyond the original method. Location: §4.2 Methods, MAGIC bullet.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Toward Real-World Table Agents: Capabilities, Workflows, and Design Principles for LLM-based Table Intelligence." pith.science (2026). https://pith.science/paper/IGZLZ5LH

@misc{pith2026250710281,
  author       = {Pith},
  title        = {Pith review of: Toward Real-World Table Agents: Capabilities, Workflows, and Design Principles for LLM-based Table Intelligence},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/IGZLZ5LH}},
  note         = {Machine review of arXiv:2507.10281}
}
read the original abstract

Tables are fundamental in domains such as finance, healthcare, and public administration, yet real-world table tasks often involve noise, structural heterogeneity, and semantic complexity--issues underexplored in existing research that primarily targets clean academic datasets. This survey focuses on LLM-based Table Agents, which aim to automate table-centric workflows by integrating preprocessing, reasoning, and domain adaptation. We define five core competencies--C1: Table Structure Understanding, C2: Table and Query Semantic Understanding, C3: Table Retrieval and Compression, C4: Executable Reasoning with Traceability, and C5: Cross-Domain Generalization--to analyze and compare current approaches. In addition, a detailed examination of the Text-to-SQL Agent reveals a performance gap between academic benchmarks and real-world scenarios, especially for open-source models. Finally, we provide actionable insights to improve the robustness, generalization, and efficiency of LLM-based Table Agents in practical settings.

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Towards Agents That Know When They Don't Know: Uncertainty as a Control Signal for Structured Reasoning

    cs.AI 2025-09 conditional novelty 6.0 of 10

    An LLM agent using retrieval and summary uncertainty as training rewards and inference filters produces more factual, useful multi-omics summaries and better downstream survival predictions.

Reference graph

Works this paper leans on

172 extracted references · 79 canonical work pages · cited by 1 Pith paper

  1. [1]

    Did I use the correct table for the query?

    **T able Selection** - **Question**: “Did I use the correct table for the query?” - **Negative questions**: - Did I verify the table contains all required data? - Have I checked for any missing related tables?

  2. [2]

    Exploring chain-of-thought style prompting for text-to-sql

    URL https://journal.hep.com.cn/fcs/EN/abstract/article 51778.shtml 134 Tai C Y, Chen Z, Zhang T, et al. Exploring chain-of-thought style prompting for text-to-sql. arXiv preprint arXiv:2305.14215, 2023 135 Zhang T, Yue X, Li Y, et al. Tablellama: Towards open large generalist models for tables. arXiv preprint arXiv:2311.09206, 2023 Sci China Inf Sci 23 13...

    arXiv 2023

  3. [3]

    Did I use the correct filtering conditions?

    **Filter Conditions** - **Question**: “Did I use the correct filtering conditions?” - **Negative questions**: - Do my conditions cover all required criteria? - Are any conditions too broad or too restrictive?

  4. [4]

    Did I correctly specify the column to count/select?

    **Column Specification** Sci China Inf Sci 24 - **Question**: “Did I correctly specify the column to count/select?” - **Negative questions**: - Did I confirm the column exists in the selected table? - Is this the precise column needed for the calculation?

  5. [5]

    Are my conditions accurately targeted without unnecessary complexity?

    **Query Complexity** - **Question**: “Are my conditions accurately targeted without unnecessary complexity?” - **Negative questions**: - Can any conditions be simplified? - Are there redundant filters?

  6. [6]

    Did I unnecessarily use DISTINCT?

    **DISTINCT Usage** - **Question**: “Did I unnecessarily use DISTINCT?” - **Negative questions**: - Is DISTINCT actually needed for this query? - Could it be masking underlying data issues?

  7. [7]

    Are table aliases correct and consistent?

    **T able Aliases** - **Question**: “Are table aliases correct and consistent?” - **Negative questions**: - Do aliases match the database schema? - Are they used consistently throughout the query?

  8. [8]

    Did I use correct syntax for string literals?

    **String Literals** - **Question**: “Did I use correct syntax for string literals?” - **Negative questions**: - Are strings properly quoted (single/double as required)? - Do string values match the database exactly?

Show all 172 references
  1. [9]

    Did I use the correct set operation (UNION/INTERSECT/EXCEPT)?

    **Set Operations** - **Question**: “Did I use the correct set operation (UNION/INTERSECT/EXCEPT)?” - **Negative questions**: - Is this the most appropriate operation for the task? - Are the combined queries compatible?

  2. [10]

    Is this subquery actually needed?

    **Subquery Necessity** - **Question**: “Is this subquery actually needed?” - **Negative questions**: - Can this be written more efficiently without a subquery? - Does the subquery return the expected data?

  3. [11]

    Are my GROUP BY and aggregate functions correct?

    **Aggregation Logic** - **Question**: “Are my GROUP BY and aggregate functions correct?” - **Negative questions**: - Does every non-aggregated column appear in GROUP BY? - Are the right columns being aggregated?

  4. [12]

    Are my join conditions correct and complete?

    **Join Conditions** - **Question**: “Are my join conditions correct and complete?” - **Negative questions**: - Do I have all necessary join predicates? - Are any joins accidentally Cartesian products?

  5. [13]

    Did I ensure that the ‘ORDER BY‘ clause is used to sort the results correctly?

    **ORDER BY Clause Sorting** - **Question**: “Did I ensure that the ‘ORDER BY‘ clause is used to sort the results correctly?” - **Incorrect SQL generated by me**: Used the ‘ORDER BY‘ clause incorrectly to sort the results. - **Corrected SQL generated by me**: Ensure the ‘ORDER ...

  6. [14]

    Does the output match the expected results?

    **Result V alidation** - **Question**: “Does the output match the expected results?” - **Negative questions**: - Have I spot-checked sample results? - Are any result counts suspiciously high/low? Guidelines for T ableGPT2-7B on BIRD

  7. [15]

    Did I use the correct table for the query?

    **Did I use the correct table for the query?** - Question: “Did I use the correct table for the query?” - Negative and strict step-by-step ask-to-myself questions:

  8. [16]

    Did I verify the table contains all required data?

  9. [17]

    Did I cross-check table names with schema documentation?

  10. [18]

    Did I consider if joins with other tables are needed?

  11. [19]

    Did I correctly specify the column to count?

    **Did I correctly specify the column to count?** - Question: “Did I correctly specify the column to count?” - Negative and strict step-by-step ask-to-myself questions:

  12. [20]

    Does the column exist in the selected table?

  13. [21]

    Is this the precise column needed for the metric?

  14. [22]

    Should I be counting rows instead with COUNT(*)?

  15. [23]

    Did I use the correct filtering condition?

    **Did I use the correct filtering condition?** - Question: “Did I use the correct filtering condition?” - Negative and strict step-by-step ask-to-myself questions:

  16. [24]

    Do my conditions match the business requirements exactly?

  17. [25]

    Have I tested edge cases in my filters?

  18. [26]

    Are my logical operators (AND/OR) correctly grouped?

  19. [27]

    Did I unnecessarily use DISTINCT?

    **Did I unnecessarily use DISTINCT?** - Question: “Did I unnecessarily use DISTINCT?” - Negative and strict step-by-step ask-to-myself questions:

  20. [28]

    Does my query naturally produce duplicates?

  21. [29]

    Could DISTINCT be masking a join problem?

  22. [30]

    W ould GROUP BY be more appropriate?

  23. [31]

    Have I ensured my conditions target required data without unnecessary complexity?

    **Have I ensured my conditions target required data without unnecessary complexity?** - Question: “Have I ensured my conditions target required data without unnecessary complexity?” - Negative and strict step-by-step ask-to-myself questions:

  24. [32]

    Can any conditions be simplified?

  25. [33]

    Are all conditions absolutely necessary?

  26. [34]

    W ould someone else understand this logic easily?

  27. [35]

    Did I use correct syntax for string literals?

    **Did I use correct syntax for string literals?** - Question: “Did I use correct syntax for string literals?” - Negative and strict step-by-step ask-to-myself questions:

  28. [36]

    Are strings properly quoted? Sci China Inf Sci 25

  29. [37]

    Have I escaped special characters?

  30. [38]

    Did I use the correct quote type for this SQL dialect?

  31. [39]

    Did I correctly join the tables?

    **Did I correctly join the tables?** - Question: “Did I correctly join the tables?” - Negative and strict step-by-step ask-to-myself questions:

  32. [40]

    Are all necessary tables included?

  33. [41]

    Are join conditions between correct columns?

  34. [42]

    Did I specify the correct join type (INNER/LEFT etc.)?

  35. [43]

    Did I use the correct aggregate function?

    **Did I use the correct aggregate function?** - Question: “Did I use the correct aggregate function?” - Negative and strict step-by-step ask-to-myself questions:

  36. [44]

    Does the function match the intended calculation?

  37. [45]

    Are non-aggregated columns properly grouped?

  38. [46]

    Should I be using window functions instead?

  39. [47]

    Did I correctly calculate age?

    **Did I correctly calculate age?** - Question: “Did I correctly calculate age?” - Negative and strict step-by-step ask-to-myself questions:

  40. [48]

    Does my calculation handle leap years?

  41. [49]

    Is the date format consistent?

  42. [50]

    Did I account for time zone differences?

  43. [51]

    Did I validate the complete SQL syntax?

    **Did I validate the complete SQL syntax?** - Question: “Did I validate the complete SQL syntax?” - Negative and strict step-by-step ask-to-myself questions:

  44. [52]

    Have I run EXPLAIN to verify execution?

  45. [53]

    Did I check for reserved word conflicts?

  46. [54]

    Are all parentheses properly balanced? Guidelines for Qwen2.5-Coder-7B-Instruct on Spider

  47. [55]

    Did I use the correct tables for the query?

    **T able Inclusion in Joins** - **Question**: “Did I use the correct tables for the query?” - **Incorrect SQL generated by me**: (Not provided) - **Corrected SQL generated by me**: Ensure all necessary tables ( student, lives in, dorm, and has amenity) are included in the join...

  48. [56]

    Did I correctly specify the columns to count or select?

    **Column Specification in SELECT and GROUP BY** - **Question**: “Did I correctly specify the columns to count or select?” - **Incorrect SQL generated by me**: Used ‘T1.movie‘ and ‘T2.name‘ instead of ‘T1.title‘ and ‘T1.director‘. - **Corrected SQL generated by me**: Ensure the...

  49. [57]

    Did I use the correct filtering conditions?

    **Filtering Conditions in HA VING Clause** - **Question**: “Did I use the correct filtering conditions?” - **Incorrect SQL generated by me**: Used ‘>= 2‘ and ‘>= 1‘ instead of ‘= 2‘ and ‘= 1‘ in the ‘HA VING‘ clause. - **Corrected SQL generated by me**: Ensure the filtering co...

  50. [58]

    Did I unnecessarily use ‘DISTINCT‘?

    **Unnecessary Use of DISTINCT** - **Question**: “Did I unnecessarily use ‘DISTINCT‘?” - **Incorrect SQL generated by me**: (Not applicable, as ‘DISTINCT‘ was not used initially .) - **Corrected SQL generated by me**: Ensure ‘DISTINCT‘ is only used when necessary . - **Negative...

  51. [59]

    Did I use the correct syntax for string literals?

    **String Literal Syntax** - **Question**: “Did I use the correct syntax for string literals?” - **Incorrect SQL generated by me**: Used double quotes for string literals, which might not be correct for all SQL dialects. - **Corrected SQL generated by me**: Use single quotes fo...

  52. [60]

    Did I ensure that the join conditions are correct?

    **Join Conditions** - **Question**: “Did I ensure that the join conditions are correct?” - **Incorrect SQL generated by me**: Used ‘T1.movie = T2.title‘ instead of ‘T1.director = T2.director‘. - **Corrected SQL generated by me**: Ensure the join conditions accurately link the ...

  53. [61]

    Did I ensure that the ‘ORDER BY‘ clause is necessary and correctly used?

    **ORDER BY Clause Usage** - **Question**: “Did I ensure that the ‘ORDER BY‘ clause is necessary and correctly used?” - **Incorrect SQL generated by me**: Included an unnecessary ‘ORDER BY‘ clause. - **Corrected SQL generated by me**: Ensure the ‘ORDER BY‘ clause is only used w...

  54. [62]

    Did I ensure that the ‘GROUP BY‘ clause is correctly used?

    **GROUP BY Clause Usage** - **Question**: “Did I ensure that the ‘GROUP BY‘ clause is correctly used?” - **Incorrect SQL generated by me**: Placed the aggregate function after the column in the ‘SELECT‘ clause, which is not the correct syntax. - **Corrected SQL generated by me...

  55. [63]

    Did I ensure that the column names are in the correct case?

    **Case Sensitivity in Column Names** - **Question**: “Did I ensure that the column names are in the correct case?” - **Incorrect SQL generated by me**: Used ‘wifi = ’no’‘ instead of ‘wifi = ’No’‘. - **Corrected SQL generated by me**: Ensure the column names and values are in t...

  56. [64]

    Did I ensure that the ‘LIMIT‘ clause is used correctly?

    **LIMIT Clause Usage** - **Question**: “Did I ensure that the ‘LIMIT‘ clause is used correctly?” - **Incorrect SQL generated by me**: Included an unnecessary ‘LIMIT‘ clause. - **Corrected SQL generated by me**: Ensure the ‘LIMIT‘ clause is only used when necessary to restrict ...

  57. [65]

    Did I ensure that the ‘UNION‘ operator is used correctly?

    **UNION Operator Usage** - **Question**: “Did I ensure that the ‘UNION‘ operator is used correctly?” - **Incorrect SQL generated by me**: Used the ‘UNION‘ operator without filtering to combine the results of both queries. - **Corrected SQL generated by me**: Ensure the ‘UNION‘...

  58. [66]

    Did I ensure that the ‘DISTINCT‘ keyword is used correctly?

    **DISTINCT Keyword Usage** - **Question**: “Did I ensure that the ‘DISTINCT‘ keyword is used correctly?” - **Incorrect SQL generated by me**: Included an unnecessary ‘DISTINCT‘ keyword. - **Corrected SQL generated by me**: Ensure the ‘DISTINCT‘ keyword is only used when necess...

  59. [68]

    Did I ensure that the ‘GROUP BY‘ clause is used to group the results correctly?

    **GROUP BY Clause Grouping** - **Question**: “Did I ensure that the ‘GROUP BY‘ clause is used to group the results correctly?” - **Incorrect SQL generated by me**: Used the ‘GROUP BY‘ clause incorrectly to group the results. - **Corrected SQL generated by me**: Ensure the ‘GRO...

  60. [69]

    Did I ensure that the ‘HA VING‘ clause is used to filter the grouped results correctly?

    **HA VING Clause Filtering** - **Question**: “Did I ensure that the ‘HA VING‘ clause is used to filter the grouped results correctly?” - **Incorrect SQL generated by me**: Used the ‘HA VING‘ clause incorrectly to filter the grouped results. - **Corrected SQL generated by me**:...

  61. [70]

    Did I ensure that the ‘JOIN‘ conditions are correctly specified?

    **JOIN Conditions Specification** - **Question**: “Did I ensure that the ‘JOIN‘ conditions are correctly specified?” - **Incorrect SQL generated by me**: Used incorrect ‘JOIN‘ conditions to link the tables. - **Corrected SQL generated by me**: Ensure the ‘JOIN‘ conditions are ...

  62. [71]

    Did I ensure that the ‘WHERE‘ clause is used to filter the results correctly?

    **WHERE Clause Filtering** - **Question**: “Did I ensure that the ‘WHERE‘ clause is used to filter the results correctly?” - **Incorrect SQL generated by me**: Used the ‘WHERE‘ clause incorrectly to filter the results. - **Corrected SQL generated by me**: Ensure the ‘WHERE‘ cl...

  63. [72]

    Did I ensure that the ‘SELECT‘ clause is used to specify the required columns correctly?

    **SELECT Clause Column Specification** - **Question**: “Did I ensure that the ‘SELECT‘ clause is used to specify the required columns correctly?” - **Incorrect SQL generated by me**: Used the ‘SELECT‘ clause incorrectly to specify the required columns. - **Corrected SQL genera...

  64. [73]

    Have I ensured that my conditions accurately target the required data without adding unnecessary complexity?

    **Complexity and T argeting of Conditions** - **Question**: “Have I ensured that my conditions accurately target the required data without adding unnecessary complexity?” - **Incorrect SQL generated by me**: (Not provided) - **Corrected SQL generated by me**: Ensure the condit...

  65. [74]

    Did I select the correct column from the joined table?

    **W rong Column Selected in JOIN** - **Question**: “Did I select the correct column from the joined table?” - **Incorrect SQL generated by me**: “‘sql SELECT T2.author name FROM T1 JOIN T3 ON ... – W rong column (T2 vs. T3) “‘ - **Corrected SQL generated by me**: “‘sql SELECT ...

  66. [75]

    Did I verify the exact column name in the database schema?

  67. [76]

    Did I confirm which table contains the required column?

  68. [77]

    Did I check for typos in the column name?

  69. [78]

    Did I use the right aggregate function for counting?

    **Incorrect Aggregate F unction** - **Question**: “Did I use the right aggregate function for counting?” - **Incorrect SQL generated by me**: “‘sql SELECT SUM(pid) FROM T2 – W rong: Should COUNT occurrences “‘ - **Corrected SQL generated by me**: “‘sql SELECT COUNT(T2.occurren...

  70. [79]

    Did I verify whether I need COUNT, SUM, A VG, MIN or MAX?

  71. [80]

    Did I check if the column contains NULL values?

  72. [81]

    Did I consider if DISTINCT should be used with the aggregate?

  73. [82]

    Did I use the right condition for filtering the oldest movies?

    **Incorrect Y ear Filter Logic** - **Question**: “Did I use the right condition for filtering the oldest movies?” - **Incorrect SQL generated by me**: “‘sql SELECT * FROM Movies WHERE year = 1 – W rong: Not necessarily oldest “‘ - **Corrected SQL generated by me**: “‘sql SELEC...

  74. [83]

    Did I verify if I need MIN or MAX for this temporal query?

  75. [84]

    Did I check if year values could be NULL or invalid?

  76. [85]

    Did I consider if multiple records might share the oldest year?

  77. [86]

    Did I place the year filter in the correct clause?

    **Misplaced Filter Condition in JOIN** - **Question**: “Did I place the year filter in the correct clause?” - **Incorrect SQL generated by me**: “‘sql SELECT * FROM T1 JOIN T2 ON T1.id = T2.id WHERE T2.year = 1970 – W rong: Filter in WHERE “‘ - **Corrected SQL generated by me*...

    1970

  78. [87]

    Did I analyze whether the filter should apply before or after joining?

  79. [88]

    Did I verify if moving the condition affects the result set size?

  80. [89]

    Did I check the execution plan to understand performance impact?

  81. [90]

    Did I unnecessarily use ‘DISTINCT‘?

    **Redundant DISTINCT Usage** - **Question**: “Did I unnecessarily use ‘DISTINCT‘?” - **Incorrect SQL generated by me**: “‘sql SELECT DISTINCT T1.name FROM T1 JOIN T2 ON ... – DISTINCT not needed “‘ - **Corrected SQL generated by me**: “‘sql SELECT T1.name FROM T1 JOIN T2 ON .....

  82. [91]

    Did I verify if duplicates are possible in the result set?

  83. [92]

    Did I analyze the join conditions to confirm uniqueness?

  84. [93]

    Did I measure the performance impact of DISTINCT?

  85. [94]

    Did I specify the correct JOIN condition?

    **Incorrect JOIN Condition** - **Question**: “Did I specify the correct JOIN condition?” - **Incorrect SQL generated by me**: “‘sql SELECT * FROM T1 JOIN T2 ON T1.id = T3.id – W rong table reference “‘ - **Corrected SQL generated by me**: “‘sql SELECT * FROM T1 JOIN T2 ON T1.i...

  86. [95]

    Did I verify the join keys between tables?

  87. [96]

    Did I check for referential integrity?

  88. [97]

    Did I confirm the join type (INNER, LEFT, etc.) is correct?

  89. [98]

    Did I include all non-aggregated columns in GROUP BY?

    **Missing GROUP BY Clause** - **Question**: “Did I include all non-aggregated columns in GROUP BY?” - **Incorrect SQL generated by me**: “‘sql SELECT department, COUNT(*) FROM employees – Missing GROUP BY “‘ - **Corrected SQL generated by me**: “‘sql SELECT department, COUNT(*...

  90. [99]

    Did I identify all non-aggregated columns?

  91. [100]

    Did I verify the grouping logic matches requirements?

  92. [101]

    Did I check if any columns need to be excluded?

  93. [102]

    Did I use HA VING instead of WHERE for non-aggregate filters?

    **Incorrect HA VING Usage** - **Question**: “Did I use HA VING instead of WHERE for non-aggregate filters?” - **Incorrect SQL generated by me**: “‘sql SELECT department FROM employees GROUP BY department HA VING hire date > ’2020-01-01’ “‘ - **Corrected SQL generated by me**: ...

    2020

  94. [103]

    Did I verify if the filter applies to rows or groups?

  95. [104]

    Did I check if the column is used in an aggregate function?

  96. [105]

    Did I confirm the performance implications?

  97. [106]

    Did I specify the correct sort order and columns?

    **W rong ORDER BY Specification** - **Question**: “Did I specify the correct sort order and columns?” - **Incorrect SQL generated by me**: “‘sql SELECT * FROM products ORDER BY 1 – Poor practice: using ordinal position “‘ - **Corrected SQL generated by me**: “‘sql SELECT * FRO...

  98. [107]

    Did I explicitly name the sort columns? Sci China Inf Sci 28

  99. [108]

    Did I verify the sort direction (ASC/DESC)?

  100. [109]

    Did I check if multiple sort columns are needed?

  101. [110]

    Did I properly handle NULL values in comparisons?

    **Incorrect NULL Handling** - **Question**: “Did I properly handle NULL values in comparisons?” - **Incorrect SQL generated by me**: “‘sql SELECT * FROM customers WHERE phone = NULL – W rong NULL comparison “‘ - **Corrected SQL generated by me**: “‘sql SELECT * FROM customers ...

  102. [111]

    Did I use IS NULL/IS NOT NULL for NULL checks?

  103. [112]

    Did I consider COALESCE or NULLIF where appropriate?

  104. [113]

    Did I verify how NULLs affect joins and aggregates?

  105. [114]

    Did I use inefficient subqueries that could be joins?

    **Unoptimized Subqueries** - **Question**: “Did I use inefficient subqueries that could be joins?” - **Incorrect SQL generated by me**: “‘sql SELECT * FROM orders WHERE customer id IN (SELECT id FROM customers WHERE status = ’active’) “‘ - **Corrected SQL generated by me**: “‘...

  106. [115]

    Did I analyze the query execution plan?

  107. [116]

    Did I consider JOIN alternatives for subqueries?

  108. [117]

    Did I verify if EXISTS would be more efficient than IN?

  109. [118]

    Did I account for case sensitivity in string comparisons?

    **Incorrect String Comparison** - **Question**: “Did I account for case sensitivity in string comparisons?” - **Incorrect SQL generated by me**: “‘sql SELECT * FROM users WHERE username = ’ADMIN’ – Might miss ’admin’ “‘ - **Corrected SQL generated by me**: “‘sql SELECT * FROM ...

  110. [119]

    Did I verify the database’s collation settings?

  111. [120]

    Did I consider using LOWER() or UPPER() for case-insensitive compares?

  112. [121]

    Did I check if LIKE would be more appropriate?

  113. [122]

    Did I consider index usage in my query design?

    **Missing Index Consideration** - **Question**: “Did I consider index usage in my query design?” - **Incorrect SQL generated by me**: “‘sql SELECT * FROM large table WHERE non indexed column = ’value’ – F ull scan “‘ - **Corrected SQL generated by me**: “‘sql SELECT * FROM lar...

  114. [123]

    Did I check which columns are indexed?

  115. [124]

    Did I verify if my query can leverage existing indexes?

  116. [125]

    Did I consider adding indexes for frequent queries?

  117. [126]

    Did I implement pagination correctly?

    **Incorrect Pagination Implementation** - **Question**: “Did I implement pagination correctly?” - **Incorrect SQL generated by me**: “‘sql SELECT * FROM products LIMIT 10 OFFSET 20 – No ORDER BY, results unstable “‘ - **Corrected SQL generated by me**: “‘sql SELECT * FROM prod...

  118. [127]

    Did I include an ORDER BY clause for stable pagination?

  119. [128]

    Did I verify the performance of OFFSET with large datasets?

  120. [129]

    Did I consider keyset pagination as an alternative?

  121. [130]

    Did I handle date/time values correctly?

    **Improper Date/Time Handling** - **Question**: “Did I handle date/time values correctly?” - **Incorrect SQL generated by me**: “‘sql SELECT * FROM events WHERE event date = ’2023-01-01’ – Might miss timestamps “‘ - **Corrected SQL generated by me**: “‘sql SELECT * FROM events...

    2023

  122. [131]

    Did I account for time components in date comparisons?

  123. [132]

    Did I verify the database’s date format settings?

  124. [133]

    Did I consider timezone conversions if needed? Guidelines for Qwen2.5-Coder-32B-Instruct on Spider

  125. [134]

    **Incorrect column name usage** - Question: What are each document’s location code, and starting date and ending date in that location? - **Incorrect SQL generated by me**: “‘sql SELECT Document ID, Location Code, Date in Location F rom AS Start Date, Date in Locaton T o AS En...

  126. [135]

    **Unnecessary use of aliases and simplification** - Question: Which game type has the most number of games? - **Incorrect SQL generated by me**: “‘sql SELECT GType, COUNT(*) AS GameCount FROM Video Games GROUP BY GType ORDER BY GameCount DESC LIMIT 1; “‘ - **Corrected SQL gene...

  127. [136]

    **Unnecessary joins and direct selection** - Question: What nurses are on call with block floor 1 and block code 1? T ell me their names. - **Incorrect SQL generated by me**: “‘sql SELECT Nurse.Name FROM Nurse JOIN On Call ON Nurse.EmployeeID = On Call.Nurse WHERE On Call.Bloc...

  128. [137]

    **Incorrect join and unnecessary distinct** - Question: Which job titles correspond to jobs with salaries over 9000? - **Incorrect SQL generated by me**: “‘sql SELECT DISTINCT j.JOB TITLE FROM employees e JOIN jobs j ON e.JOB ID = j.JOB ID WHERE e.SALAR Y > 9000; “‘ - **Correc...

  129. [138]

    Acknowledgement

    **Not joining the correct table for verification** - Question: Find the average access counts of documents with functional area “Acknowledgement”. - **Incorrect SQL generated by me**: “‘sql SELECT A VG(d.accesscount) AS average access count FROM Documents d JOIN Document F unc...

  130. [139]

    **Incorrect ordering for highest rank** - Question: What is the joined year of the pilot of the highest rank? - **Incorrect SQL generated by me**: “‘sql SELECT Join Y ear FROM pilot WHERE Rank = (SELECT MAX(Rank) FROM pilot) “‘ - **Corrected SQL generated by me**: “‘sql SELECT...

  131. [140]

    Bob F osse

    **Incorrect award values in query** - Question: Show the musical nominee with award “Bob F osse” or “Cleavant Derricks”. - **Incorrect SQL generated by me**: “‘sql SELECT Nominee FROM musical WHERE Award = ’Bob F osse’ OR Award = ’Cleavant Derricks’; “‘ - **Corrected SQL gener...

  132. [141]

    **Simplification of count expressions** - Question: Which store owns most items? - **Incorrect SQL generated by me**: “‘sql SELECT store id, COUNT(film id) AS item count FROM inventory GROUP BY store id ORDER BY item count DESC LIMIT 1; “‘ - **Corrected SQL generated by me**: ...

  133. [142]

    **Unnecessary aliases and simplification for least number of games** - Question: Which game type has the least number of games? - **Incorrect SQL generated by me**: “‘sql SELECT GType, COUNT(*) AS GameCount FROM Video Games GROUP BY GType ORDER BY GameCount ASC LIMIT 1; “‘ - *...

  134. [143]

    **Incorrect aggregation for total hours per week** - Question: What are the total number of domestic passengers at all London airports? - **Incorrect SQL generated by me**: “‘sql SELECT SUM(Domestic Passengers) AS T otalDomestic Passengers FROM airport WHERE City = ’London’; “...

  135. [144]

    **Case sensitivity and table name mismatch** - Question: How many credit cards does customer Blanche Huels have? - **Incorrect SQL generated by me**: “‘sql SELECT COUNT(*) FROM Customers JOIN Customers Cards ON Customers.customer id = Customers Cards.customer id WHERE Customer...

  136. [145]

    **Missing join for associated data** - Question: What are the different cities where people live? - **Incorrect SQL generated by me**: “‘sql SELECT DISTINCT city FROM Addresses; “‘ - **Corrected SQL generated by me**: “‘sql SELECT DISTINCT city FROM Addresses JOIN People Addre...

  137. [146]

    sesame” with type code “Grade

    **Selecting unnecessary columns** - Question: List all characteristics of product named “sesame” with type code “Grade”. - **Incorrect SQL generated by me**: “‘sql SELECT c.characteristic name, pc.product characteristic value FROM Products p JOIN Product Characteristics pc ON ...

  138. [147]

    **Case sensitivity in string literals** - Question: Return the address and email of the customer with the first name Linda. - **Incorrect SQL generated by me**: “‘sql SELECT a.address, c.email FROM customer c JOIN address a ON c.address id = a.address id WHERE c.first name = ’...

  139. [148]

    **Incorrect string literals for city names** - Question: What is the average price for flights from LA to Honolulu? - **Incorrect SQL generated by me**: “‘sql SELECT A VG(price) AS averageprice FROM flight WHERE origin = ’LA’ AND destination = ’Honolulu’; “‘ - **Corrected SQL ...

  140. [149]

    **Incorrect position value in query** - Question: What are the names of all schools that have students trying out for the position of goal and ’mid’-field. - **Incorrect SQL generated by me**: “‘sql SELECT cName FROM T ryout WHERE pPos = ’goal’ INTERSECT SELECT cName FROM T ry...

  141. [150]

    **Unnecessary join and selecting unnecessary columns** - Question: When do all the researcher role staff start to work, and when do they stop working? - **Incorrect SQL generated by me**: “‘sql SELECT ps.staff id, ps.date from AS start date, ps.date to AS end date FROM Project...

  142. [151]

    **Incorrect column name and unnecessary join** - Question: What is the maximum training hours for the students whose training hours is greater than 1000 in different positions? - **Incorrect SQL generated by me**: “‘sql SELECT pPos, MAX(HS) AS maxT rainingHours FROM Player JOI...

  143. [152]

    **Incorrect column name and unnecessary join for company with most expensive furniture** - Question: Find the id and number of shops for the company that produces the most expensive furniture. - **Incorrect SQL generated by me**: “‘sql SELECT m.Manufacturer ID, m.Num of Shops ...

  144. [153]

    **Incorrect WHERE clause for least chargeable amount** Sci China Inf Sci 32 - Question: Which part has the least chargeable amount? List the part id and amount. - **Incorrect SQL generated by me**: “‘sql SELECT part id, chargeable amount FROM Parts WHERE chargeable yn = ’Y’ OR...

  145. [154]

    **Grouping by department name instead of department code** - Question: Find the name of the department that offers the largest number of credits of all classes. - **Incorrect SQL generated by me**: “‘sql SELECT d.DEPT NAME, SUM(c.CRS CREDIT) AS total credits FROM CLASS cl JOIN...

  146. [155]

    Give the body height status of Mr. Vincent Wyman on 2010/8/2

    **Not selecting the description field for body height status** - Question: “Give the body height status of Mr. Vincent Wyman on 2010/8/2.” - **Incorrect SQL generated by me**: “‘Incorrect corrected sql “‘ - **Corrected SQL generated by me**: “‘sql SELECT T2.DESCRIPTION, T2.V A...

    2010

  147. [156]

    Who was the captain of the winning team in the match held on 1st June 2008?

    **Incorrect join condition for identifying the captain of the winning team** - Question: “Who was the captain of the winning team in the match held on 1st June 2008?” - **Incorrect SQL generated by me**: “‘SELECT T3.Player Name FROM ‘Match‘ AS T1 INNER JOIN Player Match AS T2 ...

    2008

  148. [157]

    What percentage of students enlisted in the navy are male?

    **Not casting count to a real number for percentage calculation** - Question: “What percentage of students enlisted in the navy are male?” - **Incorrect SQL generated by me**: “‘SELECT CAST(COUNT(CASE WHEN T1.organ = ’navy’ THEN T2.name ELSE NULL END) AS REAL) * 100 / COUNT(T2...

  149. [158]

    List the full name of all the ’Production T echnician - WC50

    **Using SUM and CASE statement unnecessarily for listing full names** - Question: “List the full name of all the ’Production T echnician - WC50”’ - **Incorrect SQL generated by me**: “‘SELECT SUM(T1.Likes) FROM twitter AS T1 INNER JOIN location AS T2 ON T2.LocationID = T1.Loca...

  150. [159]

    Calculate the average of object samples for the image

    **Calculating percentage instead of average for object samples** - Question: “Calculate the average of object samples for the image.” - **Incorrect SQL generated by me**: “‘SELECT (SUM(CASE WHEN gender = ’M’ THEN 1 ELSE 0 END) * 100.0 / COUNT(device id)) AS male percentage FRO...

  151. [160]

    How many ’cool’ type compliments does user No. 41717 get?

    **Using LIKE instead of equals for exact match and not using COUNT** - Question: “How many ’cool’ type compliments does user No. 41717 get?” - **Incorrect SQL generated by me**: “‘SELECT T2.number of compliments FROM Compliments AS T1 INNER JOIN Users Compliments AS T2 ON T1.c...

  152. [161]

    What is the image ID with a predicted class of ’parked on’ ?

    **Selecting the wrong column and filtering by the wrong condition** - Question: “What is the image ID with a predicted class of ’parked on’ ?” - **Incorrect SQL generated by me**: “‘SELECT timestamp FROM events WHERE event id = 12;“‘ - **Corrected SQL generated by me**: “‘sql ...

  153. [162]

    State the name of the city with the most venues

    **Grouping by non-unique identifier** - Question: “State the name of the city with the most venues.” - **Incorrect SQL generated by me**: “‘SELECT T1.City Name FROM City AS T1 INNER JOIN V enue AS T2 ON T1.CityId = T2.City Id GROUP BY T1.City Name ORDER BY COUNT(T2.V enue Id) ...

  154. [163]

    List down the titles and descriptions of the crimes cases against persons

    **Selecting wrong tables and columns, using incorrect join condition, and filtering with irrelevant criteria** - Question: “List down the titles and descriptions of the crimes cases against persons.” - **Incorrect SQL generated by me**: “‘SELECT T2.AggregationMethod FROM Indic...

    1960

  155. [164]

    Among the players who became coaches, how many of them have gotten in the Hall of F ame?

    **Selecting names instead of counting players who became coaches and are in the Hall of F ame** - Question: “Among the players who became coaches, how many of them have gotten in the Hall of F ame?” - **Incorrect SQL generated by me**: “‘SELECT T2.name FROM Award AS T1 INNER J...

  156. [165]

    What categories of offers qualify for group discounts for resellers?

    **Selecting wrong tables and columns for group discounts for resellers** - Question: “What categories of offers qualify for group discounts for resellers?” - **Incorrect SQL generated by me**: “‘SELECT T1.email FROM student AS T1 INNER JOIN registration AS T2 ON T1.student id ...

  157. [166]

    How many customers have an employee who reports to William Patterson as their sales representative?

    **Incorrectly using a subquery to find the sales representative** - Question: “How many customers have an employee who reports to William Patterson as their sales representative?” - **Incorrect SQL generated by me**: “‘SELECT COUNT(T1.customerNumber) FROM customers AS T1 INNER...

  158. [167]

    Give the Mauritius Rupee’s currency code

    **Selecting the wrong table and columns for currency code** - Question: “Give the Mauritius Rupee’s currency code.” - **Incorrect SQL generated by me**: “‘SELECT T2.Name FROM characters AS T1 INNER JOIN actor AS T2 ON T1.ActorID = T2.ActorID WHERE T1.‘Character Name‘ = ’Chanic...

  159. [168]

    What is the percentage of the trips were done by a subscriber?

    **Incorrectly calculating the percentage of trips done by subscribers** - Question: “What is the percentage of the trips were done by a subscriber?” - **Incorrect SQL generated by me**: “‘SELECT CustomerID, ‘Customer Names‘ FROM Customers WHERE ‘Customer Names‘ LIKE ’W%’“‘ - *...

  160. [169]

    List out the name of orders which have delivery date of 6/13/2018

    **Incorrectly selecting OrderNumber instead of order names** - Question: “List out the name of orders which have delivery date of 6/13/2018.” - **Incorrect SQL generated by me**: “‘SELECT OrderNumber FROM ‘Sales Orders‘ WHERE DeliveryDate = ’6/13/2018’;“‘ - **Corrected SQL gen...

    2018

  161. [170]

    List all the cities in Sonoma County

    **Case sensitivity issue in county names** - Question: “List all the cities in Sonoma County .” - **Incorrect SQL generated by me**: “‘SELECT city FROM geographic WHERE county = ’Sonoma County’;“‘ - **Corrected SQL generated by me**: “‘sql SELECT city FROM geographic WHERE cou...

  162. [171]

    Give the level of education and occupation of customers ages from 20 to 35 with an income K of 2000 and below

    **Selecting from wrong tables and using incorrect filtering conditions** - Question: “Give the level of education and occupation of customers ages from 20 to 35 with an income K of 2000 and below.” - **Incorrect SQL generated by me**: “‘SELECT T1.Seriescode FROM F ootNotes AS ...

    2000

  163. [172]

    Please list all horror films that have a rating of 1

    **Incorrectly selecting match IDs and filtering by unrelated conditions** - Question: “Please list all horror films that have a rating of 1.” - **Incorrect SQL generated by me**: “‘SELECT DISTINCT m.movieid FROM movies2directors m2d JOIN u2base u“‘ - **Corrected SQL generated ...

  164. [2023]

    Data Ambiguity Strikes Back: How Documentation Improves GPT’s Text-to-SQL, 2023 122 Hwang F K, Richards D S

    7053–7074 121 Huang Z, Damalapati P K, Wu E. Data Ambiguity Strikes Back: How Documentation Improves GPT’s Text-to-SQL, 2023 122 Hwang F K, Richards D S. Steiner tree problems. Networks, 1992, 22: 55–89 123 Lu W, Zhang J, Fan J, et al. Large language model for table processing...

    2023 arXiv

Pith tools

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