acceptodds
Under review as a conference paper at ICLR 2027

Database Context Compression for Text-to-SQL on Real-World Large Databases

Abstract

Recent progress on Text-to-SQL has been driven by stronger language models and richer prompting strategies, yet performance on real enterprise benchmarks such as Spider 2.0 and BIRD remains far below that on classical academic datasets. We argue that a central bottleneck on such benchmarks is the way the database is presented to the model. Real databases contain wide tables with repeated audit columns, large families of homogeneous partitioned tables, opaque machine-generated identifiers whose meaning lives only in column descriptions, and long data dictionaries in which only a small, query-dependent fraction is actually relevant. Existing query-aware approaches—schema linking, broadly construed to include retrieval-style schema subsetting—attempt to filter this raw context, but often operate on a representation that is structurally redundant, semantically verbose and documentation-heavy. We re-frame the problem as one of database context compression: a database-side rewrite that increases the information density of schema structure and semantic descriptors, complemented by query-aware purification of external documents. We introduce the SGCF (Support–Gain Component Factorization) principle as a common accounting abstraction for repeated column groups, isomorphic table templates and shared semantic-tag components; question-relevant evidence purification addresses the distinct, query-dependent document layer. Building on this abstraction, we present DBCC, a two-phase database-side middleware that performs query-agnostic structural and semantic re-encoding offline, and lightweight query-aware evidence purification online. DBCC is model-agnostic and pipeline-agnostic, and can be inserted before schema linking or generation in existing Text-to-SQL systems. On Spider 2.0-Snow and BIRD, DBCC reduces input tokens by up to 75x (on the most challenging Large bucket of Spider 2.0-Snow, from 2.6 M to 34.7K tokens). On that bucket, where the raw input is over budget and produces no completed predictions, the compressed input reaches 56.5% strict recall under DeepSeek-V3.2 and 63.1% under Claude-Opus-4.7. DBCC also yields a 1.8-1.9 percentage-point end-to-end EX improvement when stacked on top of each of three recent Text-to-SQL systems. Code and evaluation artifacts are available in the anonymous repository at https://anonymous.4open.science/r/SchemaCompression/.

Primary area:
other topics in machine learning (i.e., none of the above)
Keywords:
Text-to-SQL, large databases, context compression, schema linking, natural language interfaces to databases

Reviews

Among:
Shape:
1234this paper, Top 4%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.33 over 3 reviews, above 96% of the others.
Reviewer_MuyxOpenReview ↗
Rating
4(+1)
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes DBCC, a middleware that compresses the database context for Text-to-SQL. It uses a two-phase approach: offline structural/semantic compression via the SGCF principle, and online query-driven evidence purification. Experiments on Spider 2.0-Snow show substantial reductions in serialized context size and significant improvements in strict recall, with consistent end-to-end gains when plugged into existing systems.

Critical strengths

S1. The problem is well-motivated with a clear compositional analysis (Table 2), showing that over 90% of the serialized database context in large databases is repeated. This diagnosis grounds the method’s design and highlights a real bottleneck.

S2. The compressed view is modular and plug-and-play: it can be inserted into either the linking or generation stage without modifying downstream models. Consistent gains across three different end-to-end systems (AutoLink, ReFoRCE, Apex-SQL) demonstrate practical compatibility.

Critical weaknesses

W1. The method introduces many hyperparameters (e.g., τ_s, τ_w, τ_g, w_max), yet no sensitivity analysis is provided. It is unclear how these thresholds affect the trade-off between compression rate and accuracy, and whether the reported gains are robust across different settings.

Questions for authors

Q1. Could you provide a sensitivity sweep for key thresholds showing how strict recall and token count vary?

Q2. How was Table 2 constructed? Specifically, what rules were used to classify each token into “repeated,” “irrelevant docs,” and “unique task content”?

5 comments
AuthorsOpenReview ↗

Response to Reviewer Muyx (Part I)

We sincerely thank you for acknowledging the strong motivation, modular compressed representation, and plug-and-play design of our work. We deeply value the constructive criticisms you raised and respond to each concern in detail below.

Sensitivity Analysis of Compression Thresholds

Thank you for raising this question. We apologize for not including a sensitivity analysis of DBCC's key hyperparameters in the original submission. We evaluate the sensitivity of schema linking to the four component-selection thresholds (τs,τw,τg,wmax⁡)(\tau_s,\tau_w,\tau_g,w_{\max}), which respectively control the minimum support, minimum width, minimum gain, and maximum width of a selected component. The results are summarized in the following table.

Note on the experimental results. Unfortunately, evaluating SQL execution correctness on Spider 2.0 requires online access to the Snowflake databases. However, the Snowflake evaluation account has been unexpectedly unavailable since August 12, 2026 (please see the first news item in the README of the Spider 2.0 official repository for details). Therefore, we are unable to provide SQL execution accuracy for these newly conducted experiments and report only schema-linking performance and token cost. We sincerely apologize for this limitation.

τs\tau_sτw\tau_wτg\tau_gSmall SRRSmall NSRSmall NSPSmall TokMedium SRRMedium NSRMedium NSPMedium TokLarge SRRLarge NSRLarge NSPLarge Tok
Sensitivity to τs\tau_s (with τw=2\tau_w=2 and τg=1\tau_g=1)
22161.782.471.84.5K56.385.955.714.3K56.578.673.334.7K
32162.082.471.94.6K57.385.955.814.5K56.579.573.634.7K
42161.481.771.44.6K53.184.654.514.4K52.276.772.534.7K
62160.981.170.64.6K52.183.853.914.5K56.577.673.134.8K
Sensitivity to τw\tau_w (with τs=2\tau_s=2 and τg=1\tau_g=1)
22161.782.471.84.5K56.385.955.714.3K56.578.673.334.7K
23161.782.171.64.6K55.285.355.514.7K52.275.772.935.8K
24161.181.671.14.6K54.284.755.014.9K47.874.872.036.5K
26160.680.970.34.6K52.183.553.615.0K47.873.871.436.8K
Sensitivity to τg\tau_g (with τs=2\tau_s=2 and τw=2\tau_w=2)
22161.782.471.84.5K56.385.955.714.3K56.578.673.334.7K
22262.382.672.04.6K57.386.156.014.4K52.278.173.534.7K
22461.781.971.24.6K55.285.055.214.5K56.579.072.834.8K
22661.181.470.94.6K54.284.354.814.5K52.277.174.035.0K

The default setting is (τs,τw,τg,wmax⁡)=(2,2,1,6)(\tau_s,\tau_w,\tau_g,w_{\max})=(2,2,1,6). We first compared wmax⁡∈{5,6,8,10}w_{\max} \in \{5,6,8,10\}. These settings produced almost identical compression results. This saturation is consistent with the structure of the input: keyword sets are short and the width of shared components is limited. At wmax⁡=6w_{\max}=6, all practically available shared components are already covered, so increasing the limit does not improve the compression ceiling and only increases the number of candidate combinations considered. We therefore fix wmax⁡=6w_{\max}=6 in the remaining experiments.

The thresholds τs\tau_s, τw\tau_w, and τg\tau_g impose lower bounds on the support, width, and gain of a selected component. Smaller thresholds admit smaller and more fragmented components. Such components can still provide a useful aggregate token reduction even when the saving from an individual component is limited. We therefore use (2,2,1)(2,2,1) as the default: each threshold is set to its minimum, allowing the compressor to retain all components that may contribute to the total reduction.

We sweep one threshold at a time while keeping the other two at their default values. Specifically, τs\tau_s and τw\tau_w take values in {2,3,4,6}\{2,3,4,6\}, while τg\tau_g takes values in {1,2,4,6}\{1,2,4,6\}. The default configuration is shared by the three sweeps and is reported only once in the first row.

As the thresholds increase, a small number of components with low support, narrow scope, or limited gain are filtered out. Overall, the schema-linking metrics remain relatively stable across the three database-size buckets, while the input token count increases slightly because fewer components are retained for compression. These results show that the compression pipeline is robust to reasonable threshold choices, while the default setting preserves the largest set of potential compression opportunities.

AuthorsOpenReview ↗

Response to Reviewer Muyx (Part II)

Clarification of Table 2

Thank you for raising this question. We apologize for the omission of the relevant explanation in the original manuscript. Table 2 was constructed from the database-context portion of each evaluated prompt; the user question and prompt instructions were excluded.

  • Repeated context includes redundant structural or semantic material. For structural content, we canonicalized column signatures using the column name, type, and structural metadata. If the same column group occurred in multiple tables, one occurrence was retained as the canonical occurrence and the remaining occurrences were counted as repeated. Similarly, for a family of isomorphic tables, one table signature was treated as canonical and the duplicated portions of the other tables were counted as repeated. For semantic content, descriptions were normalized into semantic tags; occurrences of a tag component beyond its first occurrence were counted as repeated. Thus, this category measures removable duplicated material rather than merely counting recurring lexical tokens.
  • Irrelevant docs includes tokens from external-document spans that did not support any decision required by the evaluated question. A document span was considered relevant if it provided a mapping to a Gold table or column, a metric or transformation used by the Gold SQL, an encoded filter value, or a domain definition required to interpret the question. All other external-document spans were assigned to this category.
  • Unique task content is the residual category: nonduplicated schema definitions, nonrepeated column semantics, and question-relevant document spans. Prompt scaffolding was not included in the denominator.

The assignment order was deterministic: external-document spans were first divided into relevant and irrelevant spans; schema and semantic records were then checked for structural or semantic duplication; all remaining context was labeled as unique task content.

Manuscript Revision Explanation

We would like to once again express our gratitude for your constructive suggestions and acknowledge that the original manuscript has several shortcomings. In response to your feedback, we have revised our manuscript as follows:

  • We added a sensitivity analysis for the component-selection thresholds τs\tau_s, τw\tau_w, τg\tau_g, and wmax⁡w_{\max}, reporting both schema-linking performance and token cost across the Small, Medium, and Large database buckets.

  • We documented the default threshold configuration and explained how increasing each threshold changes the number of retained components, input-token cost, and schema-linking performance.

  • We expanded the construction protocol for Table 2 by defining the mutually exclusive categories of repeated context, irrelevant documents, and unique task content, as well as the deterministic assignment order used to classify the serialized context.

To facilitate quick identification of our modifications, we have highlighted the changes using special colored fonts. Please refer to the Guideline for Reviewers on the last page of the revised manuscript.


We sincerely thank you once again for your thoughtful guidance. Your feedback has been immensely valuable to us, and incorporating your suggestions has significantly improved the quality of our manuscript. If you have any further questions or concerns, please feel free to contact us at any time. We are always available and look forward to further discussions with you.

Best regards,

All Authors of Submission 14265

AuthorsOpenReview ↗

Kindly Request for Reviewer's Feedback

Dear Reviewer Muyx,

We hope this message finds you well. We completely understand that your schedule may be demanding, and we sincerely appreciate the time and effort you have devoted to reviewing our manuscript.

In response to your thoughtful suggestions and questions, we have carefully prepared a detailed rebuttal that we hope addresses your concerns.

Specifically, following your suggestions, we have made the following revisions:

  1. Threshold sensitivity. We varied the support, width, and gain thresholds one at a time and reported strict recall and input-token count across the Small, Medium, and Large database buckets. Raising these thresholds retained fewer shared components and slightly increased token counts. Schema-linking performance was generally stable across the settings tested, with some variation in strict recall. We also tested maximum component widths of 5, 6, 8, and 10 and observed nearly identical compression results.

  2. Construction of Table 2. We clarified that the percentages use only the database-context portion of each prompt. We first classified external-document spans by whether they supplied evidence needed to answer the question. We then identified repeated schema structures and normalized semantic components, counting occurrences beyond the first as repeated. The remaining material was classified as unique task content. The revision documents this assignment order and the criteria for each category.

We are eager to understand whether our efforts have effectively addressed the limitation in the original manuscript. Given your expertise, we are eager to engage in further discussion with you. However, as the discussion phase draws to a close (with less than 24 hours remaining), we have yet to receive your response. If possible, we would be deeply grateful if you could spare a moment to share your thoughts, which would be of immense value to us.

Thank you again for your time, thoughtful feedback, and invaluable guidance.

Warmest regards,

All Authors of Submission #14265

Reviewer_GnBpOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes DBCC to reduce the database context used by large language models for Text-to-SQL. Large databases often contain repeated table structures, lengthy column descriptions, and extensive external documents. These inputs increase token costs and can exceed the model’s context window. DBCC combines offline structural and semantic compression with online evidence extraction. Structural compression shares common column groups and represents similar tables through templates and differences. Semantic compression converts column descriptions into compact tags and shares repeated tag combinations. A gain criterion selects shared components when they reduce the total description cost. These database representations are reused across questions, while relevant definitions and business rules are extracted from external documents for each question. The evaluation covers schema linking and SQL execution on Spider 2.0-Snow and BIRD, along with integration into existing Text-to-SQL systems. The paper reports that large-database inputs shrink from about 2.6 million to 34,700 tokens. It also reports execution accuracy improvements from 9.4% to 17.2% on medium Spider 2.0-Snow databases and from 53.6% to 58.2% on BIRD. Integration experiments show gains of 1.8–1.9 percentage points. For the largest inputs, the results primarily demonstrate that compression makes otherwise over-budget tasks feasible.

Critical strengths
  1. Practical relevance. Excessive database context is a real bottleneck for Text-to-SQL. The reported token reductions are substantial and can make very large schemas usable within a limited context window.

  2. Reusable design. Separating offline database compression from question-dependent evidence extraction is sensible. Shared components and templates offer a concrete way to reduce repeated information and support integration into existing systems.

Critical weaknesses
  1. The experimental statistics need reconciliation. Appendix C reports 812.1 columns per database, but its bucket counts imply an average of at least 1,861.8. Table 4 also reports NSR = 2.9% and NSP = 50.0% for Large Raw, despite “zero completed predictions.” These inconsistencies make the evaluation difficult to interpret.

  2. The added value of the full method needs stronger validation. In Table 4, full DBCC and structure-only compression achieve the same EX: 17.2% on Medium and 11.6% on Large. Further token savings and recall gains are useful, but their total cost is unclear. The released materials also lack the described semantic compression, structured evidence processing, and SQL evaluation pipeline.

I would consider raising my score if the rebuttal resolves these inconsistencies and provides convincing evidence for the full method.

Questions for authors
  1. Appendix C lists 152 databases, including 53 with at least 1,000 columns and 23 with at least 10,000. This implies a mean of at least 1,861.8 columns, compared with the reported 812.1. Do these statistics use the same databases and column definition?

  2. Section 4.1 states that Large Raw has “zero completed predictions,” while Table 4 reports NSR = 2.9% and NSP = 50.0%. Does “completed” refer to schema linking or SQL execution? How were the nonzero scores calculated?

  3. The paper reports 547 questions from 152 databases, while the released evaluation set contains 469 questions from 143. The stated micro metrics also differ from the evaluator’s per-question averages. Which sample list and aggregation rules produced Table 4?

  4. Table 4 gives identical EX for structure-only and full DBCC on Medium and Large. After including preprocessing and all model calls, how many queries are needed for full DBCC to become cheaper than structure-only?

  5. Which version implements Algorithm 3 and the typed, schema-anchored evidence described in Appendix B.5? Please provide that version and the per-question SQL results behind the EX and integration tables.

7 comments
AuthorsOpenReview ↗

Response to Reviewer GnBp (Part I)

We sincerely appreciate your recognition of the practical relevance and reusable design of DBCC. We have carefully considered the shortcomings you identified in our manuscript and provide detailed responses below.

Response regarding the dataset statistics

Thank you for pointing out this inconsistency. We sincerely apologize for the errors introduced during the preparation of the manuscript. Below, we provide a detailed explanation of the two issues concerning our dataset statistics:

  • Regarding the reported average of 812.1 columns per database: this number was taken directly from Table 2 in Section 2.3 of the original Spider 2.0 paper [1]. In contrast, the statistics reported for our database-size buckets were independently recomputed from the publicly released Spider 2.0-Snow schemas, following the schema-processing logic used in utils.py from the official Spider 2.0 repository. We were unable to reproduce the value 812.1 using the currently available public schemas. Because the original Spider 2.0 paper does not provide sufficient details about how this statistic was calculated, we cannot determine the exact reason for the discrepancy. We will revise the manuscript by replacing the quoted value with the result of our own statistics and adding a footnote to clarify that this value was independently computed by us and differs from that reported in the Spider 2.0 paper.

  • Regarding the discrepancy between the 547 questions from 152 databases described in the manuscript and the released evaluation set containing 469 questions from 143 databases: Spider 2.0 indeed releases 547 questions over 152 databases. However, it provides Gold SQL for only 120 questions (see the gold/sql directory), while providing Gold SQL execution results for all questions (see the gold/exec_result directory). To provide a more stable evaluation, we manually annotated Gold SQL for the questions without released Gold SQL and verified each annotation using the corresponding Gold SQL execution result. We successfully annotated and verified 349 additional questions. The remaining 78 questions, for which our annotations could not be successfully verified, were excluded.

When writing the manuscript, we overlooked this experimental setting and directly cited the statistics of the full Spider 2.0 evaluation set. We sincerely apologize for this mistake.

Importantly, all of our experiments were conducted on the same 469 questions from 143 databases, ensuring consistent and fair comparisons across methods. We have also released the annotated Gold SQL in the anonymous repository to facilitate reproduction and further research: the updated 469-question set is available at data/input/expand.json, and the original 120-question set is available at data/input/filtered.json.

AuthorsOpenReview ↗

Response to Reviewer GnBp (Part II)

Response regarding the meaning of "zero completed predictions"

We apologize for the imprecise wording in Section 4.1. "Zero completed predictions" was intended to refer to the absence of successfully executed SQL predictions counted as correct by EX (EX = 0), rather than to a failure of every schema-linking inference. We will revise the statement to: "No SQL predictions were successfully executed and counted as correct in the Large Raw setting."

A few databases near the lower boundary of the Large bucket, such as GNOMAD (10,264 columns), still produced partial schema-linking predictions containing some correct columns (NSR). These predictions did not cover all required Gold columns, so strict recall (SRR) remained zero, but their true-positive columns contributed to the micro-aggregated NSR and NSP. Consequently, SRR = 0 and EX = 0 can coexist with NSR = 2.9% and NSP = 50.0%. NSP measures the proportion of predicted columns that are correct, rather than the proportion of questions answered correctly.

We further revised Appendix C to provide the formulas for SRR, NSR, NSP, and EX, helping readers clearly distinguish the meanings and aggregation rules of these metrics.

Response regarding metric aggregation

Thank you for pointing out the discrepancy between the manuscript's micro-aggregated metrics and the released evaluator. The uploaded evaluator was an earlier version: recall_case measures strict recall, whereas recall_column and precision were averaged across questions. These per-question averages are not the micro-aggregated NSR and NSP reported in Table 4.

For the final experiments, we recomputed NSR and NSP using a separate aggregation script in order to follow the evaluation convention adopted by related work, but inadvertently failed to include that script in the released evaluator.

We have prepared an updated evaluator that directly reports SRR, NSR, and NSP. The changes are provided in metrics.py and runner.py.

Response regarding full DBCC versus structure-only compression

Thank you for raising this issue. We agree that a complete break-even analysis comparing full DBCC with structure-only compression better demonstrates the importance of the complete DBCC pipeline.

We compute the break-even point relative to the structure-only configuration. Table 12 reports the one-time Phase-I cost of DBCC. Because structural compression itself is combinatorial and does not require model calls, this Phase-I cost is attributable to semantic compression. Full DBCC additionally incurs the per-question Phase-II evidence-purification cost.

Following the cost model in Appendix B.6.2,

N∗=⌈cI(D)Δc−cII⌉,N^* = \left\lceil \frac{c_I(D)}{\Delta c-c_{II}} \right\rceil,

where cI(D)c_I(D) is the Phase-I cost per database, cIIc_{II} is the Phase-II cost per question, and Δc\Delta c is the per-question token saving of full DBCC relative to structure-only compression.

Using Table 4 and Table 16:

ScalecI(D)c_I(D)Δc\Delta ccIIc_{II}Break-even N∗N^*
Medium138K29.9K - 14.3K = 15.6K1.3K10
Large2.0M100.7K - 34.7K = 66.0K1.6K32

Thus, after approximately 10 queries per Medium database or 32 queries per Large database, the cumulative token cost of full DBCC becomes lower than that of structure-only compression.

Importantly, this break-even point is considerably smaller than the workloads of real-world production database systems. For example, Google F1 reports that some production applications issue tens or even hundreds of thousands of SQL queries per second [2], while Treasure Data reports processing millions of distributed SQL queries every day in production environments [3]. These industrial-scale workloads indicate that a single schema version is typically reused by a massive number of downstream queries. Consequently, the one-time preprocessing cost is amortized very quickly in practice, making its per-query overhead negligible.

AuthorsOpenReview ↗

Response to Reviewer GnBp (Part III)

Response regarding the reproducibility materials

Thank you for pointing out the omissions in our released materials. We have reorganized the anonymous repository and provide a point-by-point response below regarding each artifact you requested:

  • Semantic compression (Algorithm 3). The detailed implementation is documented in src/full_semantic/README.md. In particular, frequency_first.py implements the core algorithm described in Algorithm 3, while compressor.py organizes keyword extraction, invokes the component-compression algorithm, and generates the compressed outputs.

  • Structured evidence processing (Appendix B.5). The implementation is available in src/knowledge/summarizer.py, and detailed usage and implementation instructions are provided in the project README.md.

  • SQL evaluation pipeline. We did not implement a separate SQL execution evaluator. Instead, we directly used the official Spider 2.0 evaluation scripts available in the Spider 2.0 evaluation suite.

  • Per-question SQL results. The SQL predictions underlying the reported execution-accuracy results are available in the anonymous repository under SQL_EX.

Manuscript Revision Explanation

We would like to once again express our gratitude for your constructive suggestions and acknowledge that the original manuscript has several shortcomings. In response to your feedback, we have revised our manuscript as follows:

  • We corrected the Spider 2.0-Snow dataset description by distinguishing the full released benchmark from the 469-question/143-database subset used in our experiments, and we replaced the inconsistent average column count with statistics recomputed from the public schemas using a single documented definition.

  • We clarified that "zero completed predictions" referred to EX = 0 rather than the absence of all schema-linking outputs, and added the formulas for SRR, NSR, NSP, and EX in Appendix C to explain how nonzero micro NSR/NSP can coexist with zero SRR and EX.

  • We updated and released the evaluator so that it directly reports the micro-aggregated SRR, NSR, and NSP used in Table 4, and released the 469-question evaluation set and its annotated Gold SQL.

  • We added the cost-amortization comparison between full DBCC and structure-only compression, showing break-even points of 10 queries for Medium databases and 32 queries for Large databases under the reported token-cost model.

  • We expanded the reproducibility materials with the implementation of semantic compression and structured evidence processing, links to the official Spider 2.0 SQL evaluator, and the per-question SQL predictions underlying the reported EX results.

To facilitate quick identification of our modifications, we have highlighted the changes using special colored fonts. Please refer to the Guideline for Reviewers on the last page of the revised manuscript.

References:

[1] Spider 2.0: Evaluating Language Models on Real-World Enterprise Text-to-SQL Workflows. ICLR 2025.

[2] F1: A Distributed SQL Database That Scales. VLDB 2013.

[3] Journey of Migrating Millions of Queries on the Cloud. IWTDS 2022.


We sincerely thank you once again for your thoughtful guidance. Your feedback has been immensely valuable to us, and incorporating your suggestions has significantly improved the quality of our manuscript. If you have any further questions or concerns, please feel free to contact us at any time. We are always available and look forward to further discussions with you.

Best regards,

All Authors of Submission 14265

Reviewer_V1o8OpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

Authors study how the representation of database context affects Text-to-SQL systems on large databases. It proposes DBCC, a middleware layer that compresses schema structure and column semantics offline, then extracts question-dependent evidence from external documentation online. The structural methods factor repeated column groups and represent related table families through shared templates and deltas. The semantic method converts descriptions into normalized tags and factors recurring tag combinations. SGCF provides a common support-and-gain accounting rule for selecting reusable components.

The paper distinguishes exact recovery of structural signatures and normalized tag sets from the lossy conversion of descriptions and documents. Evaluation includes Spider 2.0-Snow, BIRD, three LLMs, operator ablations, and integration with existing Text-to-SQL systems. Reported results include reducing large-bucket context from 2.6M to 34.7K tokens, achieving 56.5% strict schema recall with DeepSeek-V3.2 in that setting, and improving execution accuracy by 1.8–1.9 percentage points when integrated with three downstream systems. The largest raw-input comparison primarily demonstrates feasibility because the uncompressed input exceeds the usable budget.

Critical strengths
  • A useful and reusable representation layer. The offline/online separation is well motivated. Structural compression preserves the schema candidate space, while the paper explicitly acknowledges the lossy nature of semantic normalization and evidence purification (§§3.1–3.5). This design can complement existing linking and generation systems.

  • Substantial reported savings across several evaluation settings. Table 4 reports a Medium-bucket reduction from 166.0K to 14.3K tokens while improving strict recall from 44.8% to 56.3%. The factorial ablation reveals meaningful operator interactions. Integration results additionally report 57–73.5% fewer input tokens per request and positive execution-accuracy gains across three systems (Table 5).

Critical weaknesses

The contribution beyond existing schema compression is insufficiently proved. Appendix A.3 contrasts DBCC with Schemonic’s purported free-form summaries. However, Schemonic already uses structured grouping and abbreviations, preserves schema facts, and optimizes the representation through integer linear programming. ReFoRCE also already compresses related table descriptions.

The integration results are useful, but the handling of ReFoRCE’s native compressor is unclear. A direct comparison with Schemonic and simple template deduplication would better show up the benefit of DBCC’s particular representation and component-selection strategy.

Questions for authors

How does DBCC compare with Schemonic under comparable settings? In the ReFoRCE experiment, is native table compression retained, replaced, or bypassed?

4 comments
AuthorsOpenReview ↗

Response to Reviewer V1o8 (Part I)

Thank you for acknowledging the effectiveness of our method and the significant experimental improvements. We are especially grateful for your critical comments, which prompted us to reflect deeply on the limitations of our original submission and substantially improve our work. Below, we address your concerns point by point.

Comparison with Schemonic

Thank you for pointing out Schemonic [1] as an important baseline. We briefly discussed this work in the Related Work section of the manuscript (Appendix A.3). Here, we provide a more detailed discussion of the differences between Schemonic and DBCC.

Following your suggestion, we reproduced Schemonic on Spider 2.0 and compared it with DBCC. The results are shown below:

Note on the experimental results. Unfortunately, evaluating SQL execution correctness on Spider 2.0 requires online access to the Snowflake databases. However, the Snowflake evaluation account has been unexpectedly unavailable since August 12, 2026 (please see the first news item in the README of the Spider 2.0 official repository for details). Therefore, we are unable to provide SQL execution accuracy for these newly conducted experiments and report only schema-linking performance and token cost. We sincerely apologize for this limitation.

MethodSmall SRRSmall NSRSmall NSPSmall TokenMedium SRRMedium NSRMedium NSPMedium TokenLarge SRRLarge NSRLarge NSPLarge Token
Uncompressed61.184.378.69.6K44.867.357.1166.0K0.02.950.02.64M
Schemonic60.984.478.39.6K44.867.557.6163.3K0.03.353.82.55M
Structural-only (Ours)60.683.875.57.5K50.081.457.429.9K47.869.571.6100.7K
Full DBCC (Ours)61.782.471.84.5K56.385.955.714.3K56.578.673.334.7K

The results show that DBCC outperforms Schemonic in schema-linking performance in the vast majority of cases, with the advantage becoming more pronounced as database size increases. DBCC also consistently achieves substantially lower token costs.

Our analysis is as follows:

  1. Schemonic primarily compresses the textual representation of a schema by abbreviating repeated identifier prefixes and grouping columns with identical annotations within a table. For example, it can define PA = CUSTOMER_ and write {PA}orders instead of CUSTOMER_orders, or replace a INT NOT NULL, b INT NOT NULL with [a b](INT NOT NULL). It also optimizes nesting arrangements and formulates the joint representation problem as an ILP. In contrast, DBCC explicitly exploits structural redundancy in large databases, including recurring column groups in wide tables and shared structures across homogeneous tables. These sources of redundancy are not addressed by Schemonic's prefix abbreviations and within-table annotation grouping.

  2. Scalability presents a further challenge for Schemonic. Most schemas in Schemonic's original evaluation contain only a few dozen columns or fewer, yet the Schemonic paper reports optimization runs reaching a five-minute timeout (see the last paragraph of Section 8.2 in the Schemonic paper [1]). In our reproduction, even smaller Spider 2.0 databases with 300--500 columns remained unsolved after hours. ILP optimization succeeded for only a few small databases; most cases fell back to descriptions close to the initial greedy solution.

AuthorsOpenReview ↗

Response to Reviewer V1o8 (Part II)

Comparison with ReFoRCE

Thank you for highlighting ReFoRCE's native table compressor. We apologize that this was not clearly explained in the original manuscript. In our integration experiment, DBCC replaces ReFoRCE's native table-compression stage, while the remainder of the ReFoRCE pipeline remains unchanged. Thus, the ReFoRCE baseline in Table 5 uses its native compression. On databases with more than 5,000 columns, replacing it with DBCC reduces the reported input token count from 16.6K to 4.4K (a 73.5% reduction) while increasing EX from 16.1% to 17.9%. These results demonstrate that DBCC provides additional benefits over ReFoRCE's existing compression method.

Manuscript Revision Explanation

We would like to once again express our gratitude for your constructive suggestions and acknowledge that the original manuscript has several shortcomings. In response to your feedback, we have revised our manuscript as follows:

  • We added a direct comparison with Schemonic on Spider 2.0-Snow and expanded the discussion of the methodological differences between Schemonic and DBCC, including the different sources of redundancy addressed by the two methods and Schemonic's scalability limitations on large schemas.

  • We clarified the integration protocols for all evaluated systems, including AutoLink, ReFoRCE, and Apex-SQL. In each case, the baseline retains its original database-context construction or compression procedure, whereas the corresponding + DBCC setting replaces only that stage with DBCC while leaving the remainder of the pipeline unchanged. For example, the ReFoRCE baseline retains its native table compressor, while ReFoRCE + DBCC replaces that compressor with DBCC.

  • We revised the related-work discussion to more accurately characterize Schemonic's structured grouping, abbreviation, and ILP-based optimization, and to distinguish these mechanisms from DBCC's cross-table structural and semantic componentization.

To facilitate quick identification of our modifications, we have highlighted the changes using special colored fonts. Please refer to the Guideline for Reviewers on the last page of the revised manuscript.

References:

[1] Generating Succinct Descriptions of Database Schemata for Cost-Efficient Prompting of Large Language Models. VLDB 2024.

[2] ReFoRCE: A Text-to-SQL Agent with Self-Refinement, Format Restriction, and Column Exploration. ICLR 2025.


We sincerely thank you once again for your thoughtful guidance. Your feedback has been immensely valuable to us, and incorporating your suggestions has significantly improved the quality of our manuscript. If you have any further questions or concerns, please feel free to contact us at any time. We are always available and look forward to further discussions with you.

Best regards,

All Authors of Submission 14265

Thank you for the additional experiments and clarifications. I have no further questions at this point and my overall assessment remains unchanged.

AuthorsOpenReview ↗

Thank you for acknowledging our responses

Dear Reviewer V1o8,

Thank you for carefully reading our previous response and for providing such positive and encouraging feedback. Your reply is truly inspiring to us, which suggests that some of the issues in the original manuscript have been properly clarified.

We would like to once again express our sincere gratitude for your recognition of the effectiveness of DBCC and the significant experimental improvements. At the same time, we greatly appreciate the concerns and suggestions you raised regarding the comparison with Schemonic and ReFoRCE. We will rigorously revise our manuscript in accordance with the content of our rebuttal to ensure its clarity and accuracy. We are deeply grateful for and welcome your continued oversight as we strive to advance DBCC toward bringing new insights and discoveries to the Text-to-SQL community.

Once again, thank you for your time, your effort, and your thoughtful and patient guidance.

Best wishes,

All authors of submission 14265

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.