Pith. sign in

REVIEW 2 major objections 5 minor 88 references

I-Rex lets SQL users jump to any point of a query's logical execution, inspected through GPL-style stepping, breakpoints, and drill-down into correlated subqueries.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-01 20:54 UTC pith:GCJZNVWQ

load-bearing objection Strong systems contribution with real optimization results, but the user-study efficiency claim is confounded and should not be accepted at face value. the 2 major comments →

arxiv 2607.16452 v1 pith:GCJZNVWQ submitted 2026-07-17 cs.DB

I-Rex: An Interactive Debugger for SQL

Yihao Hu , Zian Chen , Zhiming Leong , Sharan Sokhi , Zachary Zheng , Alex Chao , Kristin Stephens-Martinez , Sudeepa Roy
show 1 more author
Jun Yang
This is my paper
classification cs.DB
keywords SQL debugginginteractive query debuggingcanonical executiondata provenancequery rewritingpagination optimizationcorrelated subqueriesBloom filter
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

The paper presents I-Rex, a SQL debugger that lets users inspect the logical execution of a query exactly as it is written, with features familiar from general-purpose debuggers: stepping, breakpoints, watchpoints, and drilling into correlated subqueries. Its central claim is that this inspection can be made scalable by rewriting the query into specialized page-fetch and milestone queries, so users can 'teleport' to any point of interest without executing the parts in between. The paper argues this speeds up SQL debugging without hurting accuracy, supporting the claim with TPC-H performance experiments and a classroom user study of 140 students. A sympathetic reader would care because SQL debugging tools are far behind general-purpose debuggers, and I-Rex offers a design that runs as lightweight middleware on top of an existing database.

Core claim

I-Rex defines a canonical execution of each SQL query: a deterministic, syntax-faithful, row-by-row procedure in which every intermediate table carries logical internal row identifiers (IIDs) that encode how each row was derived. These IIDs let the system compute any page of any intermediate result on demand by rewriting the original query into milestone queries (precomputed per-page summaries) and page-fetch queries that mix IID range filters, sargable filters, and Bloom filters. The result is that a user can pin an output row, trace backward to the input combinations that produced it, step forward again, or drill into a correlated subquery with specific parameter bindings—all without mater

What carries the argument

The central object is the IID (internal row identifier): a totally ordered, logical identifier synthesized for every row in every base and derived table during canonical execution. IIDs encode data provenance—for a joined row the IID is the vector of input IIDs; for a grouped row it is the group key plus the input IID—so tracing, pinning, and watchpointing reduce to IID range searches. The system's efficiency comes from milestone tables (client-cached per-page summaries) and page-fetch queries that combine IID-based filtering, sargable range filters on indexed columns, and Bloom filters to short-circuit expensive correlated subqueries.

Load-bearing premise

The claim that I-Rex speeds up debugging rests on a user study where the first problem was always solved without I-Rex and the second allowed optional use, so the ~8-minute time difference could be practice or motivation rather than the tool.

What would settle it

A randomized controlled study where half the participants use I-Rex on the first problem and half use traditional tools, with problem order and difficulty counterbalanced, measuring both debugging time and bugs found; if the I-Rex group shows no significant time advantage, the efficiency claim is falsified.

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • Debugging becomes practical on large, unmodified databases: I-Rex runs as stateless middleware, needs no special database preparation, and never stores session state in the database.
  • Correlated subqueries, which are opaque in optimized execution plans, become first-class debug targets through drill-down with explicit parameter bindings.
  • The query-rewriting techniques (milestone + page-fetch) could be reused for other interactive database tasks, such as paginated reporting, data exploration, or provenance auditing.
  • If the user-study result holds, adding a GPL-style debugger to SQL education could reduce debugging time without sacrificing correctness in homework or exam settings.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The user study's design—first problem always solved without I-Rex, second problem with optional I-Rex—means the measured ~8-minute improvement may partly reflect practice effects or motivation rather than the tool itself; a randomized crossover study would be needed to isolate the causal effect.
  • The IID-based provenance encoding suggests a natural extension to why-not explanations: when a pinned row has no derivative in a downstream stage, the system could report exactly which filter or subquery predicate rejected it.
  • The paper's small LLM comparison hints at a complementary division of labor: LLMs propose candidate fixes, while I-Rex provides a deterministic execution state that humans or LLM agents can query to verify those hypotheses.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

2 major / 5 minor

Summary. The paper presents I-Rex, a middleware SQL debugger that defines a canonical, reproducible execution model for SQL queries and supports GPL-style debugging features (stepping, breakpoints/watchpoints, pinning, forward/backward tracing, and drilling into correlated subqueries). To scale, I-Rex paginates all displayed tables and fetches pages using rewritten SQL queries with IID-based, sargable, and Bloom-filter filters whose summaries are precomputed in milestone tables. The authors evaluate page-fetch performance on TPC-H at 1/5/10 GB against an OFFSET/LIMIT baseline, and report a classroom user study of 140 students across two debugging problems, concluding that I-Rex significantly improves debugging efficiency without compromising accuracy.

Significance. If the claims hold, I-Rex makes a useful contribution: it is a deployable, middleware-only SQL debugger whose IID design gives logical provenance, whose teleporting/pagination optimizations show order-of-magnitude page-fetch speedups on TPC-H, and whose Bloom-filter equivalence (Prop. 4.1) is proven cleanly. The TPC-H evaluation covers multiple scale factors, page sizes, and all 22 queries in the appendix, which is a strength. However, the central effectiveness claim rests on the user study, and that study has a serious design confound; the performance experiments alone demonstrate scalability, not that I-Rex helps users find bugs faster in real debugging. The paper is therefore of considerable potential value, but its headline user-facing claim is not currently supported by the evidence.

major comments (2)
  1. [Section 6, Table 4 and 'Results and Analysis'] The claim that I-Rex 'significantly improves students' efficiency in finding bugs without compromising accuracy' is not supported by the study design. I-Rex is forbidden for the first problem and optional for the second, so for P1 the 38 I-Rex submissions are all second-problem attempts, while the 102 non-I-Rex submissions are 73 first-problem attempts plus 29 second-problem attempts; the same pattern holds for P2. The Mann-Whitney tests therefore confound tool use with problem order, practice effects, self-selection, and non-independence (the same students contribute to both the with-I-Rex and without-I-Rex pools across the two problems). The p-values of 0.0001 and 0.0007 cannot be interpreted as causal evidence for I-Rex. The Discussion acknowledges incentives and population but does not address this design confound. The authors should either provide a valid comparison (e.g., restricti
  2. [Section 6, Table 4 and Figures 7-8] Even if the time comparison were valid, the claim 'without compromising accuracy' is not formally supported. The paper reports only descriptive means for bugs found (P1: 1.13 vs 1.18; P2: 1.91 vs 1.85) and no confidence intervals or inferential test on the accuracy difference. With small and imbalanced samples (e.g., 38 vs 102), the absence of a statistically significant difference does not establish equivalence. The Conclusion and Abstract should either report an equivalence/non-inferiority analysis or soften the accuracy claim.
minor comments (5)
  1. [Appendix B.1 and B.2] The heading 'Proof of Theorem 4.1' should refer to Proposition 4.1, and Example B.2 says 'Continuing from Theorem B.1' where it should be 'Example B.1.'
  2. [Section 5.3, 'end-to-end latency'] The reported rendering/tracing/pinning latencies (~600 ms, ~300 ms, ~500 ms) are given without experimental setup, number of trials, or variance. Please provide methodology or move these to anecdotal observations.
  3. [Section 6, 'Results and Analysis'] The phrase 'We further prove I-Rex's efficiency through statistical tests' should be reworded; a Mann-Whitney U test does not prove causality and the tests are not valid as executed due to the confound described above.
  4. [Table 4] Report standard deviations or confidence intervals alongside means. The current presentation overstates the precision of the ~8-minute difference.
  5. [Section 4.1.2 and 5.2] The 30% sargable-filter cutoff and the Bloom filter size m=1024 are described as working well empirically, but no sensitivity analysis is reported. At least state whether results are robust to moderate changes in these parameters.

Circularity Check

0 steps flagged

No circularity: I-Rex is a constructive systems paper whose optimization claims are benchmarked externally against PostgreSQL/TPC-H; the only self-citations are historical context. The user-study comparison has an order/self-selection confound, but that is a validity threat, not circularity.

full rationale

I examined the paper's derivation chain: canonical execution (Section 3.1), debugging operations (Section 3.2), pagination optimizations (Sections 4.1), the equivalence proposition for Bloom filtering (Proposition 4.1 with proof in Appendix B.1), and the user study (Section 6). No load-bearing step reduces to its own inputs by construction. The page-fetch queries are query rewrites whose correctness is either proven (Bloom filters, Proposition 4.1) or argued constructively (IID-based filtering uses exact IID ranges; sargable filters are safe supersets). Performance is evaluated against a PostgreSQL OFFSET/LIMIT baseline on TPC-H at 1GB/5GB/10GB, an external benchmark, not against the authors' fitted values. The only self-citations are to earlier I-Rex papers [46,60], used to explain that prior versions precomputed all debugging data; this is development context and is not load-bearing for the paper's central scalability, optimization, or debugging claims. The user study has a real methodological confound: the first problem is always solved without I-Rex, while I-Rex use on the second problem is optional, so the Table 4 comparison of ~8 minutes is entangled with problem order, practice effects, and self-selection. This threatens the internal validity of the efficiency conclusion, but it is not circularity: the claimed effect is not equivalent to the study inputs by definition, and the paper's own Discussion acknowledges some limitations (incentives, population, LLM alternatives), though not this specific confound. No 'prediction' is fitted to a subset of data and then renamed; no uniqueness theorem is imported from the authors' prior work; no ansatz is smuggled in via citation. Therefore the circularity score is 0.

Axiom & Free-Parameter Ledger

4 free parameters · 4 axioms · 3 invented entities

The central claims rest on a small set of design choices (canonical execution, IIDs, milestones) and standard assumptions (static snapshot, Bloom filter no-false-negative property). The free parameters are performance heuristics, not fitted to a scientific derivation. The user study adds a domain assumption about participant comparability that is not met.

free parameters (4)
  • Sargable filter domain cutoff = 30%
    Section 4.1.2: a sargable filter is injected only if its range covers <=30% of the column domain; chosen empirically to avoid over-hinting the optimizer.
  • Bloom filter false-positive injection threshold = 50%
    Section 4.1.3: BLOOM_CHECK is injected only if estimated false-positive rate <50%; a hand-set heuristic affecting performance.
  • Bloom filter size m = 1024 bits
    Section 5.1: default m=1024; hash count set to (m/n)ln2. Arbitrary but impacts Bloom filter selectivity and performance.
  • Page size = 50/100/200 rows
    Used in experiments as a UI parameter; results vary with page size, and the choice is not derived from first principles.
axioms (4)
  • standard math Bloom filters have no false negatives: e in V implies BLOOM_CHECK(BLOOM_GEN(V), e)
    Proposition 4.1 and its proof rely on this standard Bloom filter property.
  • domain assumption The client sees a static snapshot of the database during a debugging session
    Section 4.1 footnote 3: data updates would invalidate cached milestones; the correctness of page fetches depends on this snapshot assumption.
  • ad hoc to paper SQL semantics can be represented by a row-oriented canonical execution with deterministic ordering defined by IIDs
    Section 3 defines this execution model; it is a design choice, not derived from the SQL standard, and all debugging features build on it.
  • domain assumption Student participants have comparable SQL familiarity
    Section 6 justifies using course students rather than MTurk to keep SQL familiarity similar; however, self-selection into I-Rex use still confounds the comparison.
invented entities (3)
  • Internal row IDs (IIDs) no independent evidence
    purpose: Totally ordered logical identifiers for reproducible row ordering and provenance; enable tracing, pinning, and query rewrites
    Section 3.1.1: IID synthesis is internal to I-Rex; no external falsifiable prediction is attached to the specific IID design.
  • Canonical execution procedure no independent evidence
    purpose: Defines the row-by-row execution order displayed to users; basis for all debugging operations
    Postulated in Section 3.1; it is a design choice and is not independently verified beyond the system's own experiments and user study.
  • Milestone tables no independent evidence
    purpose: Per-page summaries (min IID, sargable ranges, Bloom filters) used to generate page-fetch queries
    Section 4.1: internal optimization structure; its effectiveness is evaluated only on TPC-H queries, with no external validation.

pith-pipeline@v1.3.0-alltime-deepseek · 44714 in / 10810 out tokens · 111973 ms · 2026-08-01T20:54:14.731913+00:00 · methodology

0 comments
read the original abstract

SQL is declarative in nature and rich in its features. Writing semantically correct SQL queries and finding logical bugs in SQL are not easy, even for experienced programmers, who are often used to the mindset of working with general-purpose programming languages (GPLs). While there are many GPL debuggers, SQL debugging has received much less attention. In this paper, we present I-Rex, a SQL debugger that enables users to inspect the logical execution of SQL queries visually and interactively to identify and potentially fix logical bugs in the queries. I-Rex draws analogies to the debugging paradigm of GPLs (e.g., stepping, watchpoints, etc.), making it easier for programmers to adopt. However, unlike debugging GPLs, which involves executing the underlying program in full to the point of interest, I-Rex allows users to jump to arbitrary points of interest by leveraging the power of the database systems, through selective materialization and query rewrites. To simplify deployment, I-Rex acts as a lightweight middleware on top of the database system; it imposes no overhead to prepare a database for debugging and maintains no state in the database systems during debugging sessions. We demonstrate the effectiveness of I-Rex through performance experiments as well as a user study in an educational setting.

Figures

Figures reproduced from arXiv: 2607.16452 by Alex Chao, Jun Yang, Kristin Stephens-Martinez, Sharan Sokhi, Sudeepa Roy, Yihao Hu, Zachary Zheng, Zhiming Leong, Zian Chen.

Figure 1
Figure 1. Figure 1: A toy database about beers, bars, and drinkers. groups the intermediate results by bar and calculates the sum of revenue. There is a bug in the EXISTS subquery 𝑄inner, but the question for now is: how would a user examine the result of 𝑄inner? Note that 𝑄inner is correlated, with the value for f.drinker coming from the outer (i.e. enclosing) block. As a result, there is no way to inspect this result indepe… view at source ↗
Figure 2
Figure 2. Figure 2: Debugging context for outer query block, Example 2. Bindings from enclosing queries: f.drinker = ’Ben’ Likes AS l drinker beer 𝑙0 Amy Erdinger 𝑙1 Ben Budweiser 𝑙2 Ben Dixie 𝑙3 Coy Amstel 𝑙4 Dan Amstel 𝑙5 Dan Corona f.drinker = l.drinker ’Ben’ = ’Amy’ Filter Expression ⇒ Filtered / Output drinker beer 𝑜0 Ben Budweiser 𝑜1 Ben Dixie [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Debugging context for inner query block, Example 1. tracing backward from output to input using a more general mecha￾nism called pinning, denoted here by the red † next to 𝑜1 : ⟨Edge, 38.5⟩. A pinned output row intuitively narrows the execution down to only parts that are “relevant” to it (which we define formally later in Sec￾tion 3). As shown in [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Static reference graph of query blocks vs. dynamic call graph of debugging contexts, for a more complex example. Note that there are two debugging contexts for 𝑄1 with different states; the parent of 𝑄3’s debugging context provides the binding for T2.Y. • Each table defined by WITH is a function that computes the table contents when the table is referenced. Overall, the canonical execution starts by execut… view at source ↗
Figure 5
Figure 5. Figure 5: Bloom filtering vs. baseline: time to fetch each page. [·, ·] in legend shows min/max page fetch times. SELECT ROW(p_partkey, s_suppkey, ps_partkey, ps_suppkey, n_nationkey, r_regionkey), * FROM part, supplier, partsupp, nation, region WHERE ... AND ps_supplycost = ( SELECT MIN(ps_supplycost) FROM partsupp, supplier, nation, region WHERE p_partkey = ps_partkey -- p_partkey from outer query AND ...); As dis… view at source ↗
Figure 6
Figure 6. Figure 6: Sargable filtering vs. baseline: time to fetch each page. [·, ·] in legend shows min/max page fetch times. 1GB (ms) 5GB (ms) 10GB (ms) Page I-Rex Baseline I-Rex Baseline I-Rex Baseline head 2,532.81 5,870.729 14,184.028 46,234.889 37,419.067 120,576.875 middle 2,456.265 7,991.925 16,215.405 55,316.965 32,434.602 133,646.155 tail 2,787.514 10,113.122 13,983.933 64,399.041 33,393.882 146,715.434 [PITH_FULL_… view at source ↗
Figure 7
Figure 7. Figure 7: Bugs caught (out of two) for P1, using I-Rex vs. not [PITH_FULL_IMAGE:figures/full_fig_p011_7.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

88 extracted references · 6 canonical work pages

  1. [1]

    2023. dbForge. https://www.devart.com/dbforge/mysql/querybuilder/

    2023

  2. [2]

    Microsoft Access

    2023. Microsoft Access. https://www.microsoft.com/en-us/microsoft-365/access

    2023

  3. [3]

    2023. PgAdmin. https://www.pgadmin.org/

    2023

  4. [4]

    Rapid SQL

    2023. Rapid SQL. https://www.idera.com/rapid-sql-ide/

    2023

  5. [5]

    Azza Abouzied, Joseph Hellerstein, and Avi Silberschatz. 2012. Dataplay: inter- active tweaking and example-driven correction of graphical database queries. In Proceedings of the 25th annual ACM symposium on User interface software and technology. 207–218

    2012

  6. [6]

    Parag Agrawal, Omar Benjelloun, Anish Das Sarma, Chris Hayworth, Shubha Nabar, Tomoe Sugihara, and Jennifer Widom. 2006. Trio: A system for data, uncertainty, and lineage. InVLDB, Vol. 6. 1151–1154

    2006

  7. [7]

    Javad Akbarnejad, Gloria Chatzopoulou, Magdalini Eirinaki, Suju Koshy, Sarika Mittal, Duc On, Neoklis Polyzotis, and Jothi S Vindhiya Varman. 2010. SQL QueRIE recommendations.Proceedings of the VLDB Endowment3, 1-2 (2010), 1597–1600

    2010

  8. [8]

    Yael Amsterdamer, Susan B Davidson, Daniel Deutch, Tova Milo, Julia Stoy- anovich, and Val Tannen. 2011. Putting lipstick on pig: Enabling database-style workflow provenance.arXiv preprint arXiv:1201.0231(2011)

    Pith/arXiv arXiv 2011

  9. [9]

    Bahareh Sadat Arab, Su Feng, Boris Glavic, Seokki Lee, Xing Niu, and Qitian Zeng

  10. [10]

    Edmon Begoli, Jesús Camacho-Rodríguez, Julian Hyde, Michael J Mior, and Daniel Lemire. 2018. Apache calcite: A foundational framework for optimized query processing over heterogeneous data sources. InProceedings of the 2018 International Conference on Management of Data. 221–230

    2018

  11. [11]

    TPC Benchmark. [n.d.]. http://www.tpc.org/tpch

  12. [12]

    Nicole Bidoit, Melanie Herschel, and Katerina Tzompanaki. 2014. Query-based why-not provenance with nedexplain. InExtending database technology (EDBT)

    2014

  13. [13]

    Burton H. Bloom. 1970. Space/Time Trade-offs in Hash Coding with Allowable Errors.Commun. ACM13, 7 (1970), 422–426. https://doi.org/10.1145/362686. 362692

    doi:10.1145/362686 1970

  14. [14]

    Stefan Brass and Christian Goldberg. 2004. Detecting Logical Errors in SQL Queries. InTagungsband zum 16. GI-Workshop Grundlagen von Datenbanken, Mohnheim, NRW, Deutschland, 1.-4. Juni 2004, Mireille Samia and Stefan Conrad (Eds.). Universität Düsseldorf, 28–32

    2004

  15. [15]

    Stefan Brass and Christian Goldberg. 2005. Proving the Safety of SQL Queries. In Fifth International Conference on Quality Software (QSIC 2005), 19-20 September 2005, Melbourne, Australia. IEEE Computer Society, 197–204. https://doi.org/10. 1109/QSIC.2005.50

    2005

  16. [16]

    Stefan Brass and Christian Goldberg. 2006. Semantic errors in SQL queries: A quite complete list.J. Syst. Softw.79, 5 (2006), 630–644. https://doi.org/10.1016/J. JSS.2005.06.028

    doi:10.1016/j 2006

  17. [17]

    Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. 2020. Language models are few-shot learners.Advances in neural information processing systems33 (2020), 1877–1901

    2020

  18. [18]

    Peter Buneman, Sanjeev Khanna, and Tan Wang-Chiew. 2001. Why and where: A characterization of data provenance. InDatabase Theory—ICDT 2001: 8th International Conference London, UK, January 4–6, 2001 Proceedings 8. Springer, 316–330

    2001

  19. [19]

    Rafael Caballero, Yolanda García-Ruiz, and Fernando Sáenz-Pérez. 2012. Al- gorithmic debugging of SQL views. InPerspectives of Systems Informatics: 8th International Andrei Ershov Memorial Conference, PSI 2011, Novosibirsk, Russia, June 27-July 1, 2011, Revised Selected Papers 8. Springer, 77–85

    2012

  20. [20]

    Rafael Caballero, Yolanda García-Ruiz, and Fernando Sáenz-Pérez. 2012. Declar- ative debugging of wrong and missing answers for SQL views. InFunctional and Logic Programming: 11th International Symposium, FLOPS 2012, Kobe, Japan, May 23-25, 2012. Proceedings 11. Springer, 73–87

    2012

  21. [21]

    Nofar Carmeli, Nikolaos Tziavelis, Wolfgang Gatterbauer, Benny Kimelfeld, and Mirek Riedewald. 2023. Tractable Orders for Direct Access to Ranked Answers of Conjunctive Queries.ACM Trans. Database Syst.48, 1 (2023), 1:1– 1:45. https://doi.org/10.1145/3578517

    work page doi:10.1145/3578517 2023

  22. [22]

    Nofar Carmeli, Shai Zeevi, Christoph Berkholz, Benny Kimelfeld, and Nicole Schweikardt. 2020. Answering (Unions of) Conjunctive Queries using Random Access and Random-Order Enumeration. InProceedings of the 39th ACM SIGMOD- SIGACT-SIGAI Symposium on Principles of Database Systems, PODS 2020, Portland, OR, USA, June 14-19, 2020, Dan Suciu, Yufei Tao, and Z...

    arXiv 2020

  23. [23]

    Claudio Cerullo and Marco Porta. 2007. A system for database visual querying and query visualization: Complementing text and graphics to increase expressiveness. In18th International Workshop on Database and Expert Systems Applications (DEXA 2007). IEEE, 109–113

    2007

  24. [24]

    Su- darshan

    Bikash Chandra, Ananyo Banerjee, Udbhas Hazra, Mathew Joseph, and S. Su- darshan. 2021. Edit Based Grading of SQL Queries. InCODS-COMAD 2021: 8th ACM IKDD CODS and 26th COMAD, Virtual Event, Bangalore, India, Jan- uary 2-4, 2021, Jayant R. Haritsa, Shourya Roy, Manish Gupta, Sharad Mehro- tra, Balaji Vasan Srinivasan, and Yogesh Simmhan (Eds.). ACM, 56–64...

    arXiv 2021

  25. [25]

    Bikash Chandra, Bhupesh Chawda, Biplab Kar, K. V. Maheshwara Reddy, Shetal Shah, and S. Sudarshan. 2015. Data generation for testing and grading SQL queries.VLDB J.24, 6 (2015), 731–755. https://doi.org/10.1007/S00778-015-0395-0

    work page doi:10.1007/s00778-015-0395-0 2015

  26. [26]

    Adriane Chapman and HV Jagadish. 2009. Why not?. InProceedings of the 2009 ACM SIGMOD International Conference on Management of data. 523–534

    2009

  27. [27]

    Shumo Chu, Brendan Murphy, Jared Roesch, Alvin Cheung, and Dan Suciu. 2018. Axiomatic Foundations and Algorithms for Deciding Semantic Equivalences of SQL Queries.Proc. VLDB Endow.11, 11 (2018), 1482–1495. https://doi.org/10. 14778/3236187.3236200

    arXiv 2018

  28. [28]

    Shumo Chu, Chenglong Wang, Konstantin Weitz, and Alvin Cheung. 2017. Cosette: An Automated Prover for SQL. In8th Biennial Conference on Innovative Data Systems Research, CIDR 2017, Chaminade, CA, USA, January 8-11, 2017, Online Proceedings. www.cidrdb.org. http://cidrdb.org/cidr2017/papers/p51-chu- cidr17.pdf

    2017

  29. [29]

    Shumo Chu, Konstantin Weitz, Alvin Cheung, and Dan Suciu. 2017. HoTTSQL: proving query rewrites with univalent SQL semantics. InProceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI 2017, Barcelona, Spain, June 18-23, 2017, Albert Cohen and Martin T. Vechev (Eds.). ACM, 510–524. https://doi.org/10.1145/3062...

    arXiv 2017

  30. [30]

    Yingwei Cui, Jennifer Widom, and Janet L Wiener. 2000. Tracing the lineage of view data in a warehousing environment.ACM Transactions on Database Systems (TODS)25, 2 (2000), 179–227

    2000

  31. [31]

    Ralf Diestelkämper and Melanie Herschel. 2020. Tracing nested data with struc- tural provenance for big data analytics.. InEDBT. 253–264

    2020

  32. [32]

    Benjamin Dietrich and Torsten Grust. 2015. A SQL debugger built from spare parts: Turning a SQL: 1999 database system into its own debugger. InProceedings of the 2015 ACM SIGMOD International Conference on Management of Data. 865– 870

    2015

  33. [33]

    Kyriaki Dimitriadou, Olga Papaemmanouil, and Yanlei Diao. 2014. Explore-by- example: An automatic query steering framework for interactive data exploration. InProceedings of the 2014 ACM SIGMOD international conference on Management of data. 517–528

    2014

  34. [34]

    Haoran Ding, Zhaoguo Wang, Yicun Yang, Dexin Zhang, Zhenglin Xu, Haibo Chen, Ruzica Piskac, and Jinyang Li. 2023. Proving Query Equivalence Using Linear Integer Arithmetic.Proc. ACM Manag. Data1, 4 (2023), 227:1–227:26. https://doi.org/10.1145/3626768

    doi:10.1145/3626768 2023

  35. [35]

    Idan Eldar, Nofar Carmeli, and Benny Kimelfeld. 2024. Direct Access for Answers to Conjunctive Queries with Aggregation. In27th International Conference on Database Theory, ICDT 2024, March 25-28, 2024, Paestum, Italy (LIPIcs), Graham Cormode and Michael Shekelyan (Eds.), Vol. 290. Schloss Dagstuhl - Leibniz- Zentrum für Informatik, 4:1–4:20. https://doi....

    work page doi:10.4230/lipics.icdt.2024.4 2024

  36. [36]

    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.Proceedings of the VLDB Endowment17, 5 (2024), 1132– 1145

    2024

  37. [37]

    Sebastian Gehrmann, Falcon Dai, Henry Elder, and Alexander Rush. 2018. End- to-End Content and Plan Selection for Data-to-Text Generation. InProceedings of the 11th International Conference on Natural Language Generation. Association for Computational Linguistics, Tilburg University, The Netherlands, 46–56. https: //doi.org/10.18653/v1/W18-6505

    work page doi:10.18653/v1/w18-6505 2018

  38. [38]

    Pushpendu Ghosh, Aryan Jain, and Promod Yenigalla. 2025. SQLGenie: A Practi- cal LLM based System for Reliable and Efficient SQL Generation. InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 6: Industry Track), Georg Rehm and Yunyao Li (Eds.). Association for Computational Linguistics, Vienna, Austria, 1004–...

    doi:10.18653/v1/2025.acl- 2025

  39. [39]

    Amir Gilad, Zhengjie Miao, Sudeepa Roy, and Jun Yang. 2022. Understanding Queries by Conditional Instances. InSIGMOD ’22: International Conference on Management of Data, Philadelphia, PA, USA, June 12 - 17, 2022, Zachary G. Ives, Angela Bonifati, and Amr El Abbadi (Eds.). ACM, 355–368. https://doi.org/10. 1145/3514221.3517898

    arXiv 2022

  40. [40]

    Boris Glavic and Gustavo Alonso. 2009. Perm: Processing provenance and data on the same data model through query rewriting. In2009 IEEE 25th International Conference on Data Engineering. IEEE, 174–185

    2009

  41. [41]

    Todd J Green, Grigoris Karvounarakis, and Val Tannen. 2007. Provenance semir- ings. InProceedings of the twenty-sixth ACM SIGMOD-SIGACT-SIGART sympo- sium on Principles of database systems. 31–40

    2007

  42. [42]

    Torsten Grust and Jan Rittinger. 2013. Observing sql queries in their natural habitat.ACM Transactions on Database Systems (TODS)38, 1 (2013), 1–33

    2013

  43. [43]

    Laura M Haas, Johann Christoph Freytag, Guy M Lohman, and Hamid Pirahesh

  44. [44]

    Sabaat Haroon, Chris Brown, and Muhammad Ali Gulzar. 2024. DeSQL: Interac- tive Debugging of SQL in Data-Intensive Scalable Computing.Proc. ACM Softw. Eng.1, FSE (2024), 767–788. https://doi.org/10.1145/3643761 I-Rex: An Interactive Debugger for SQL

    doi:10.1145/3643761 2024

  45. [45]

    Yihao Hu, Amir Gilad, Kristin Stephens-Martinez, Sudeepa Roy, and Jun Yang

  46. [46]

    Yihao Hu, Zhengjie Miao, Zhiming Leong, Haechan Lim, Zachary Zheng, Sudeepa Roy, Kristin Stephens-Martinez, and Jun Yang. 2022. I-Rex: An Interactive Re- lational Query Debugger for SQL. InProceedings of the 53rd ACM Technical Symposium on Computer Science Education V. 2. 1180–1180

    2022

  47. [47]

    Jiansheng Huang, Ting Chen, AnHai Doan, and Jeffrey F Naughton. 2008. On the provenance of non-answers to queries over extracted data.Proceedings of the VLDB Endowment1, 1 (2008), 736–747

    2008

  48. [48]

    Matteo Interlandi, Kshitij Shah, Sai Deep Tetali, Muhammad Ali Gulzar, Se- unghyun Yoo, Miryung Kim, Todd Millstein, and Tyson Condie. 2015. Titian: Data provenance support in spark. InProceedings of the VLDB Endowment Inter- national Conference on Very Large Data Bases, Vol. 9. NIH Public Access, 216

    2015

  49. [49]

    Srinivasan Iyer, Ioannis Konstas, Alvin Cheung, and Luke Zettlemoyer. 2016. Summarizing Source Code using a Neural Attention Model. InProceedings of the 54th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics, Berlin, Germany, 2073–2083. https://doi.org/10.18653/v1/P16-1195

    doi:10.18653/v1/p16-1195 2016

  50. [50]

    Hannu Jaakkola and Bernhard Thalheim. 2003. Visual SQL–high-quality ER- based query treatment. InConceptual Modeling for Novel Application Domains: ER 2003 Workshops ECOMO, IWCMQ, AOIS, and XSDM, Chicago, IL, USA, October 13, 2003. Proceedings 22. Springer, 129–139

    2003

  51. [51]

    Grigoris Karvounarakis, Todd J Green, Zachary G Ives, and Val Tannen. 2013. Col- laborative data sharing via update exchange and provenance.ACM Transactions on Database Systems (TODS)38, 3 (2013), 1–42

    2013

  52. [52]

    Georgia Koutrika, Alkis Simitsis, and Yannis E Ioannidis. 2010. Explaining structured queries in natural language. In2010 IEEE 26th International Conference on Data Engineering (ICDE 2010). IEEE, 333–344

    2010

  53. [53]

    Marie Le Guilly, Jean-Marc Petit, Vasile-Marian Scuturici, and Ihab F Ilyas. 2019. Explique: Interactive databases exploration with SQL. InProceedings of the 28th ACM International Conference on Information and Knowledge Management. 2877– 2880

    2019

  54. [54]

    Seokki Lee, Bertram Ludäscher, and Boris Glavic. 2019. PUG: a framework and practical implementation for why and why-not provenance.The VLDB Journal 28, 1 (2019), 47–71

    2019

  55. [55]

    Fangyu Lei, Jixuan Chen, Yuxiao Ye, Ruisheng Cao, Dongchan Shin, Hongjin Su, Zhaoqing Suo, Hongcheng Gao, Wenjing Hu, Pengcheng Yin, et al. 2024. Spider 2.0: Evaluating language models on real-world enterprise text-to-sql workflows. arXiv preprint arXiv:2411.07763(2024)

    Pith/arXiv arXiv 2024

  56. [56]

    Aristotelis Leventidis, Jiahui Zhang, Cody Dunne, Wolfgang Gatterbauer, HV Jagadish, and Mirek Riedewald. 2020. QueryVis: Logic-based diagrams help users understand complicated SQL queries faster. InProceedings of the 2020 ACM SIGMOD International Conference on Management of Data. 2303–2318

    2020

  57. [57]

    Haoyang Li, Jing Zhang, Cuiping Li, and Hong Chen. 2023. Resdsql: Decoupling schema linking and skeleton parsing for text-to-sql. InProceedings of the AAAI Conference on Artificial Intelligence, Vol. 37. 13067–13075

    2023

  58. [58]

    Jinyang Li, Binyuan Hui, Ge Qu, Jiaxi Yang, Binhua Li, Bowen Li, Bailin Wang, Bowen Qin, Ruiying Geng, Nan Huo, et al . 2024. Can llm already serve as a database interface? a big bench for large-scale database grounded text-to-sqls. Advances in Neural Information Processing Systems36 (2024)

    2024

  59. [59]

    Henry B Mann and Donald R Whitney. 1947. On a test of whether one of two random variables is stochastically larger than the other.The annals of mathematical statistics(1947), 50–60

    1947

  60. [60]

    Zhengjie Miao, Tiangang Chen, Alexander Bendeck, Kevin Day, Sudeepa Roy, and Jun Yang. 2020. I-Rex: an interactive relational query explainer for SQL. Proceedings of the VLDB Endowment13, 12 (2020), 2997–3000

    2020

  61. [61]

    Zhengjie Miao, Sudeepa Roy, and Jun Yang. 2019. Explaining Wrong Queries Using Small Examples. InProceedings of the 2019 International Conference on Management of Data, SIGMOD Conference 2019, Amsterdam, The Netherlands, June 30 - July 5, 2019, Peter A. Boncz, Stefan Manegold, Anastasia Ailamaki, Amol Deshpande, and Tim Kraska (Eds.). ACM, 503–520. https:...

    arXiv 2019

  62. [62]

    Daphne Miedema and George Fletcher. 2021. SQLVis: Visual query representa- tions for supporting SQL learners. In2021 IEEE Symposium on Visual Languages and Human-Centric Computing (VL/HCC). IEEE, 1–9

    2021

  63. [63]

    Tobias Müller, Benjamin Dietrich, and Torsten Grust. 2018. You Say ’What’, I Hear ’Where’ and ’Why’? (Mis-)Interpreting SQL to Derive Fine-Grained Provenance. Proc. VLDB Endow.11, 11 (2018), 1536–1549. https://doi.org/10.14778/3236187. 3236204

    doi:10.14778/3236187 2018

  64. [64]

    Xing Niu, Boris Glavic, Ziyu Liu, Pengyuan Li, Dieter Gawlick, Vasudha Krish- naswamy, Zhen Hua Liu, and Danica Porobic. 2021. Provenance-based Data Skipping.Proc. VLDB Endow.15, 3 (2021), 451–464. https://doi.org/10.14778/ 3494124.3494130

    arXiv 2021

  65. [65]

    Orr, Srikanth Kandula, and Surajit Chaudhuri

    Laurel J. Orr, Srikanth Kandula, and Surajit Chaudhuri. 2019. Pushing Data- Induced Predicates Through Joins in Big-Data Clusters.Proc. VLDB Endow.13, 3 (2019), 252–265. https://doi.org/10.14778/3368289.3368292

    arXiv 2019

  66. [66]

    PostgreSQL. [n.d.]. https://www.postgresql.org/

  67. [67]

    Mohammadreza Pourreza, Hailong Li, Ruoxi Sun, Yeounoh Chung, Shayan Talaei, Gaurav Tarlok Kakkar, Yu Gan, Amin Saberi, Fatma Ozcan, and Sercan O Arik

  68. [68]

    Mohammadreza Pourreza and Davood Rafiei. 2023. Din-sql: Decomposed in- context learning of text-to-sql with self-correction.Advances in neural informa- tion processing systems36 (2023), 36339–36348

    2023

  69. [69]

    Kai Presler-Marshall, Sarah Heckman, and Kathryn T. Stolee. 2021. SQLRepair: Identifying and Repairing Mistakes in Student-Authored SQL Queries. In43rd IEEE/ACM International Conference on Software Engineering: Software Engineering Education and Training, ICSE (SEET) 2021, Madrid, Spain, May 25-28, 2021. IEEE, 199–210. https://doi.org/10.1109/ICSE-SEET526...

    arXiv 2021

  70. [70]

    Fotis Psallidas and Eugene Wu. 2018. Smoke: Fine-grained lineage at interactive speed.arXiv preprint arXiv:1801.07237(2018)

    Pith/arXiv arXiv 2018

  71. [71]

    Selinger, Morton M

    Patricia G. Selinger, Morton M. Astrahan, Donald D. Chamberlin, Raymond A. Lorie, and Thomas G. Price. 1979. Access Path Selection in a Relational Database Management System. InProceedings of the 1979 ACM SIGMOD International Conference on Management of Data, Boston, Massachusetts, USA, May 30 - June 1, Philip A. Bernstein (Ed.). ACM, 23–34. https://doi.o...

    arXiv 1979

  72. [72]

    Praveen Seshadri, Hamid Pirahesh, and T. Y. Cliff Leung. 1996. Complex Query Decorrelation. InProceedings of the Twelfth International Conference on Data Engineering, February 26 - March 1, 1996, New Orleans, Louisiana, USA, Stanley Y. W. Su (Ed.). IEEE Computer Society, 450–458. https://doi.org/10.1109/ICDE. 1996.492194

    arXiv 1996

  73. [73]

    Samuel Sanford Shapiro and Martin B Wilk. 1965. An analysis of variance test for normality (complete samples).Biometrika52, 3-4 (1965), 591–611

    1965

  74. [74]

    Chang Shu, Yusen Zhang, Xiangyu Dong, Peng Shi, Tao Yu, and Rui Zhang

  75. [75]

    Cafarella, and Samuel Madden

    Sivaprasad Sudhir, Wenbo Tao, Nikolay Pavlovich Laptev, Cyrille Habis, Michael J. Cafarella, and Samuel Madden. 2023. Pando: Enhanced Data Skipping with Logical Data Partitioning.Proc. VLDB Endow.16, 9 (2023), 2316–2329. https: //doi.org/10.14778/3598581.3598601

    arXiv 2023

  76. [76]

    Shayan Talaei, Mohammadreza Pourreza, Yu-Chen Chang, Azalia Mirhoseini, and Amin Saberi. 2024. Chess: Contextual harnessing for efficient sql synthesis. arXiv preprint arXiv:2405.16755(2024)

    Pith/arXiv arXiv 2024

  77. [77]

    Nikolaos Tziavelis, Wolfgang Gatterbauer, and Mirek Riedewald. 2021. Beyond Equi-joins: Ranking, Enumeration and Factorization.Proc. VLDB Endow.14, 11 (2021), 2599–2612. https://doi.org/10.14778/3476249.3476306

    arXiv 2021

  78. [78]

    Margus Veanes, Nikolai Tillmann, and Jonathan de Halleux. 2010. Qex: Sym- bolic SQL Query Explorer. InLogic for Programming, Artificial Intelligence, and Reasoning - 16th International Conference, LPAR-16, Dakar, Senegal, April 25- May 1, 2010, Revised Selected Papers (Lecture Notes in Computer Science), Ed- mund M. Clarke and Andrei Voronkov (Eds.), Vol....

    work page doi:10.1007/978-3-642-17511-4_24 2010

  79. [79]

    Shuxian Wang, Sicheng Pan, and Alvin Cheung. 2024. QED: A Powerful Query Equivalence Decider for SQL.Proc. VLDB Endow.17, 11 (2024), 3602–3614. https://www.vldb.org/pvldb/vol17/p3602-wang.pdf

    2024

  80. [80]

    Kun Xu, Lingfei Wu, Zhiguo Wang, Yansong Feng, and Vadim Sheinin. 2018. SQL- to-Text Generation with Graph-to-Sequence Model. InProceedings of the 2018 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, Brussels, Belgium, 931–936. https://doi.org/10. 18653/v1/D18-1112

    2018

Showing first 80 references.