Enhanced Schema Linking with Large Language Models via Self-Verification and Value Hints

Abstract

Schema linking, the task of identifying relevant database schema elements (tables and columns) for natural language queries, is a critical component in database-driven natural language interfaces. While existing approaches rely on question decomposition to handle complex queries, they often suffer from error propagation and low precision. In this paper, we propose a novel schema linking framework enhanced by self-verification (SV) and value hints (VHs) that significantly improves both precision and recall. Our approach introduces two key components: (1) self-verification (SV), an iterative refinement mechanism that validates and corrects initial predictions through explicit verification prompts, and (2) value hints (VHs), which explicitly guide the model to recognize database values mentioned in queries. We conduct comprehensive experiments on two benchmark datasets, Spider and BIRD, using two language models of 4B and 80B parameters. Our results demonstrate that SV + VH consistently improves performance across datasets, models, and method configurations, outperforming both decomposition-based approaches and compute-matched alternatives such as self-consistency under equivalent inference budgets.

1. Introduction

Schema linking—the process of identifying which database tables and columns are relevant to answering a given natural language question—is a fundamental task in database-driven natural language interfaces [1,2]. As organizations increasingly seek to democratize data access, enabling non-technical users to interact with complex databases through natural language has become critically important [3,4]. Schema linking serves as the bridge between ambiguous human language and structured database schemas.

Schema linking serves multiple critical functions in natural language database interfaces. It provides semantic disambiguation by mapping ambiguous natural language mentions to specific database objects [1]. For instance, when a user asks about “price,” schema linking determines whether this refers to products.unit_price or orders.total_price. Furthermore, schema linking can function as an independent access control layer, identifying potentially sensitive fields before query execution [5]. The task also enables interactive query refinement, where systems can present linking candidates for user confirmation in ambiguous scenarios.

Traditional schema linking approaches often rely on question decomposition, breaking complex queries into simpler sub-questions that can be independently linked to schema elements [6,7]. While decomposition can improve recall by ensuring all query aspects are addressed, it often introduces significant challenges. The decomposition process itself can be error-prone, and errors propagate through subsequent linking steps [5]. Moreover, decomposition-based approaches frequently exhibit low precision, identifying many irrelevant schema elements that can confuse downstream applications [8].

Recent advances in large language models (LLMs) have transformed schema linking research [5,9]. LLMs demonstrate remarkable few-shot learning capabilities, enabling effective schema linking with minimal task-specific training [10,11]. However, even state-of-the-art LLMs make errors in schema linking, particularly for complex queries involving multiple tables or implicit value references [8,12].

Self-verification and self-correction mechanisms have emerged as promising techniques for improving LLM outputs [13,14]. These approaches leverage the model’s ability to critically evaluate and refine its own predictions, often achieving significant improvements over single-pass generation. However, the effectiveness of self-correction in LLMs remains debated, with some studies suggesting that LLMs struggle to self-correct without external feedback [15]. While self-verification has been successfully applied to mathematical reasoning [13] and code generation [16], its application to schema linking remains unexplored.

In this paper, we propose an enhanced schema linking framework via self-verification and value hints that addresses the limitations of existing approaches. Our contributions are twofold:

1.

We introduce self-verification (SV), an iterative refinement mechanism that validates initial schema linking predictions through explicit verification prompts. The verification process checks for completeness (are all necessary tables and columns included?), connectivity (can selected tables be joined?), and precision (are there unnecessary elements?).

2.

We propose value hints (VHs), a technique that explicitly informs the model about database values mentioned in the query. This addresses a common failure mode where models miss columns needed for WHERE conditions because value matches are not explicitly highlighted.

We evaluate our approach on two widely used benchmarks: Spider [17] and BIRD [18]. Using two language models (Qwen3-4B and Qwen3-Next-80B-MoE), our experiments demonstrate that:

• SV + VH consistently outperforms compute-matched alternatives (self-consistency) under equivalent inference budgets, confirming that the gains stem from the structured verification design rather than additional compute alone.
• The combination of SV and VH achieves the best results among all evaluated methods under the same model and settings, with an SL F1 of 75.7% on BIRD (Decomp + SV + VH, three rounds) and 80.9% on Spider (SV + VH).
• SV + VH generalizes across model scales (4B, 80B parameters), with larger relative gains on smaller models.
• Multiple verification rounds progressively improve performance, with three rounds yielding 4.6% Column F1 improvement over single-round verification on BIRD.

2. Related Work

2.1. Schema Linking for Database Interfaces

Schema linking has evolved significantly with the introduction of cross-domain benchmarks. Spider [17] established the paradigm of evaluating generalization across unseen databases, while BIRD [18] introduced more realistic challenges including dirty data and complex domain knowledge. These benchmarks have driven substantial research into robust schema linking techniques [1,2].

Schema linking approaches can be broadly categorized into embedding-based and generation-based methods. Embedding-based approaches use neural encoders to compute similarity between question tokens and schema elements [19,20]. Generation-based approaches leverage language models to directly predict relevant schema elements [5,9]. Recent work has shown that generation-based approaches with LLMs achieve superior performance, particularly in cross-domain settings [21].

Lei et al. [1] conducted a comprehensive analysis of schema linking errors, identifying value linking (matching query values to database contents) as a major source of failures. Maamari et al. [8] argued that with sufficiently capable reasoning models, explicit schema linking may become less critical, though their experiments focused on very large models. Our work demonstrates that explicit schema linking with self-verification remains valuable even as model capabilities improve.

2.2. LLM-Based Schema Linking

The application of LLMs to schema linking has yielded remarkable improvements. Katsogiannis-Meimarakis et al. [5] introduced a decomposed approach that demonstrated strong performance on complex benchmarks. DAIL-SQL [9] focused on optimizing prompting strategies, demonstrating that example selection and representation significantly impact performance. C3-SQL [22] proposed iterative validation to correct errors. DIN-SQL [11] demonstrated that decomposing the text-to-SQL task into sub-problems with in-context learning significantly improves LLM performance, achieving state-of-the-art results on Spider and BIRD benchmarks.

Few-shot prompting has become the dominant paradigm for LLM-based schema linking [10,11]. Research has shown that demonstration selection based on question similarity improves performance [23,24]. Our work builds on these foundations while introducing verification-based refinement as a complementary technique.

2.3. Self-Verification in LLMs

Self-verification mechanisms have proven effective across various LLM applications. Weng et al. [13] demonstrated that LLMs can verify their mathematical reasoning through backward verification, achieving improvements over self-consistency approaches. Madaan et al. [14] introduced Self-Refine, an iterative refinement approach through self-feedback for code and text generation tasks, demonstrating that even state-of-the-art LLMs like GPT-4 can be further improved at test-time through iterative self-feedback. In contrast, Huang et al. [15] showed that LLMs often struggle to self-correct their reasoning without external feedback, highlighting the importance of structured verification prompts rather than naive self-correction.

In the context of structured prediction, self-correction has been applied to various generation tasks [16,25]. These approaches typically verify output correctness through semantic checks. Our work differs by applying self-verification to the schema linking stage, addressing errors at an early stage of the pipeline.

3. Methodology

3.1. Problem Formulation

Given a natural language question Q, a database schema $S=\{T_1,T_2,\dots ,T_n\}$ where each table $T_i=\{c_{i1},c_{i2},\dots ,c_{im}\}$ contains columns, and optionally a set of matched database values V, the schema linking task predicts a minimal relevant set of schema elements for the downstream task. Formally, it outputs a pair $(\widehat{T},\widehat{C})$, where $\widehat{T}\subseteq S$ and $\widehat{C}\subseteq {\bigcup }_i{T}_i$ such that: (i) every schema element required to interpret the semantics of Q is included (coverage) and (ii) no irrelevant elements are included (precision).

3.2. Baseline Approaches

We first describe two baseline approaches that form the foundation of our method.

3.2.1. Base Method

The Base method directly prompts an LLM to predict relevant tables and columns given the question and schema. The prompt structure includes:

• A system instruction (see Appendix A) describing the schema linking task;
• The serialized database schema with table and column information;
• The natural language question;
• Few-shot demonstrations selected based on question similarity.

The model outputs a JSON object containing predicted tables and columns:

• {"tables": ["table1", "table2"],
•  "columns": ["table1.col1", "table2.col2"]}

3.2.2. Decomposition Method (Decomp)

Following Katsogiannis-Meimarakis et al. [5], the decomposition method first breaks the question into simpler sub-questions, then performs schema linking for each sub-question, and finally aggregates the results. We adopt this methodology as our decomposition baseline because Katsogiannis-Meimarakis et al. [5] demonstrated superior schema linking performance on the BIRD benchmark compared to other decomposition-based approaches. While this can improve recall by ensuring all aspects of complex questions are addressed, it often introduces noise through incorrect decomposition or over-linking.

3.3. Self-Verification (SV)

Our self-verification mechanism introduces a second LLM pass that validates and corrects the initial prediction. The verification prompt (see Appendix A) explicitly asks the model to check:

1.

Completeness: Are all tables needed for JOINs included? Are columns for WHERE conditions and SELECT clauses present?

2.

Connectivity: If multiple tables are selected, can they be connected through foreign keys?

3.

Precision: Are there any extra tables or columns that are not actually needed?

The verification prompt takes the following form:

“Given the database schema, question, and initial prediction, verify and correct the prediction if necessary. Check that all necessary tables and columns are included, tables can be joined, and no unnecessary elements are selected.”

The model outputs a corrected JSON prediction, which may be identical to the initial prediction if no corrections are needed.

3.4. Value Hints (VHs)

A common failure mode in schema linking occurs when the question mentions specific values that exist in the database, but the model fails to identify the columns containing those values. This is particularly problematic for WHERE conditions.

We address this by preprocessing the question against database contents to identify value matches and then explicitly including these matches in the prompt:

“The question mentions these values that appear in the database:

- “California” → found in: customers.state

- “2024” → found in: orders.year

This suggests these columns are needed for WHERE conditions.”

This explicit guidance helps the model recognize implicit value references that might otherwise be missed.

VH Matching Pipeline

The value-matching pipeline operates as an offline preprocessing step before LLM inference. Our implementation adopts the bridge content encoder from the open-source RESDSQL framework [26] (BSD-3 License). The matching procedure is as follows:

1.

Tokenization and Normalization. The question is tokenized and each token is case-folded. A stopword list (common English words and single characters) is applied to filter out non-informative tokens. Multi-token n-grams (up to 6 tokens) are also extracted to handle multi-word entity mentions (e.g., “New York” and “United States”).

2.

Candidate Generation. For each column in the database schema, we retrieve a sample of distinct cell values (up to 100 per column). Numeric and date values are normalized to string form. Column names themselves are also included as candidates.

3.

Matching Strategy. Each question token (or n-gram) is compared against cell values using a two-stage matching approach:

• Longest Common Subsequence (LCS): We use difflib.SequenceMatcher to compute the LCS ratio between the token and each cell value, identifying pairs with high overlap.
• Fuzzy Matching: We apply rapidfuzz.fuzz.ratio to compute a character-level similarity score. A match is accepted if the similarity exceeds a threshold of $\tau =0.85$.

4.

Ranking and Selection. For each matched question token, we rank candidate columns by their matching score and select the top-2 column matches. Matches involving stopwords or overly common database values are filtered out to reduce noise.

The VH preprocessing is computationally lightweight. On the BIRD development set (1534 samples across 95 databases), preprocessing completes in 25.9–54.1 s total (16.9–35.3 ms per sample); on the Spider development set (1034 samples across 20 databases), it completes in 4.6 s total (4.5 ms per sample). This overhead is negligible compared to LLM inference time and is performed only once as an offline step.

3.5. Combining Components

Our framework allows flexible combination of components:

• Base: Single-pass generation;
• Decomp: Question decomposition + Base;
• Decomp + SV: Decomposition with verification;
• Decomp + VH: Decomposition with value hints;
• Decomp + SV + VH: Full system with all components;
• SV-only: Verification-only with full schema initialization;
• SV + VH: Verification with value hints, no decomposition;
• VH-only: Value hints without verification.

4. Experimental Setup

4.1. Datasets

We evaluate on two widely used schema linking benchmarks:

Spider [17]: A large-scale cross-domain dataset containing 10,181 questions across 200 databases. Spider features complex queries involving multiple tables, nested queries, and aggregations. We use the development set for evaluation.

BIRD [18]: A more challenging benchmark with 12,751 question–answer pairs across 95 large-scale databases. BIRD emphasizes real-world complexity, including dirty data, domain knowledge requirements, and external evidence. We use the development set for evaluation.

4.2. Implementation Details

We use Qwen3-4B-Instruct as our primary language model, served through vLLM for efficient inference. For model scale experiments, we additionally evaluate on Qwen3-Next-80B-MoE. Key hyperparameters include:

• Temperature: 0.0 (greedy decoding);
• Top-p: 1.0;
• Maximum tokens: 2048;
• Number of few-shot demonstrations: 3;
• Batch size: 20.

For demonstration selection, we compute semantic similarity between questions using SimCSE embeddings [27] and select the top-k most similar examples from the training set.

4.3. Evaluation Metrics

We evaluate schema linking performance using precision, recall, and F1 scores at three levels:

• Table level: Precision/recall/F1 for predicted tables;
• Column level: Precision/recall/F1 for predicted columns;
• Schema linking (SL): Combined metric considering both tables and columns, where a prediction is correct only if both the table set and column set exactly match the ground truth.

5. Results

5.1. Main Results

Table 1. Main experimental results on BIRD and Spider benchmarks. P/R/F1 denotes precision/recall/F1 scores (%). Best results in each column are bolded.

Method	BIRD			Spider
	Table F1	Column F1	SL F1	Table F1	Column F1	SL F1
Base	89.8	78.2	70.7	86.9	81.2	78.8
Decomp	87.8	63.8	71.0	85.2	67.8	73.3
Decomp + SV	89.3	74.2	73.3	86.3	74.8	76.2
Decomp + VH	86.9	67.2	72.1	84.7	68.1	73.4
Decomp + SV + VH	89.2	76.1	75.3	86.5	75.5	76.9
VH-only	91.2	79.6	71.3	86.7	81.2	79.2
SV-only	91.1	80.4	73.1	87.6	82.4	80.1
SV + VH	90.6	79.8	72.8	87.9	82.9	80.9

presents the main experimental results on BIRD and Spider benchmarks.

Key Observations:

• Decomposition hurts column-level precision. On BIRD, the Decomp method achieves only 63.8% Column F1, compared to 78.2% for the Base method. This 14.4% drop demonstrates that question decomposition introduces significant noise, likely due to over-linking across sub-questions.
• Self-verification substantially improves decomposition. Adding SV to Decomp improves Column F1 from 63.8% to 74.2% on BIRD (+10.4%) and from 67.8% to 74.8% on Spider (+7.0%). This validates our hypothesis that verification can filter out incorrectly linked elements.
• Non-decomposition methods outperform decomposition. The SV-only and SV + VH methods achieve the best overall performance without using decomposition. On BIRD, SV-only achieves 91.1% Table F1 and 80.4% Column F1, surpassing all decomposition variants.
• Value hints are most effective when combined with verification. The combination SV + VH achieves the best SL F1 on Spider (80.9%), demonstrating synergy between the two components. Value hints provide explicit guidance for WHERE conditions, while verification ensures precision.

Figure 1 visualizes these results, highlighting the performance differences across methods on both datasets.

5.2. Ablation: Verification Rounds

Table 2. Ablation study on the number of self-verification rounds (Decomp + SV + VH). Results show F1 scores (%) on BIRD and Spider.

SV Rounds	BIRD			Spider
	Table F1	Column F1	SL F1	Table F1	Column F1	SL F1
1-round	88.1	73.0	74.7	87.1	75.6	76.3
2-rounds	89.6	75.5	75.4	87.4	76.7	77.8
3-rounds	89.7	77.6	75.7	86.7	76.8	77.2

shows the effect of multiple verification rounds.

Multiple verification rounds progressively improve column-level performance. On BIRD, Column F1 improves from 73.0% (one round) to 77.6% (three rounds), a gain of 4.6%. This suggests that each verification round catches additional errors missed in previous rounds. However, the gains diminish after 2–3 rounds, indicating convergence of the verification process. Figure 2 visualizes this progressive improvement.

5.3. Compute-Matched Baselines

A natural concern is whether the gains from SV simply reflect a larger inference budget (more LLM calls) rather than the verification design itself. To address this, we compare SV against self-consistency (SC) [28], a widely used compute-matched alternative that spends the same inference budget by sampling multiple predictions and taking a majority vote. For SC, we set temperature $=0.7$ and aggregate predictions by selecting the tables and columns that appear in the majority of samples.

Table 3. Compute-matched comparison between SV + VH and self-consistency (SC). All methods use Qwen3-4B. LLM calls denotes the number of forward passes per query. SV + VH consistently outperforms SC under matched compute budgets.

Method	LLM Calls	BIRD			Spider
		Table F1	Col F1	SL F1	Table F1	Col F1	SL F1
Base	1	89.8	78.2	70.7	86.9	81.2	78.8
SC (2 rounds)	2	89.6	78.2	69.6	86.7	81.1	78.9
SV + VH (1 round)	2	91.9	80.3	71.5	87.4	81.8	79.3
SC (4 rounds)	4	89.9	78.3	70.1	86.7	81.0	78.6
SV + VH (3 rounds)	4	91.3	79.7	71.5	87.5	82.4	79.8

presents the results. SC (2 rounds) uses two LLM calls (matching SV + VH, one round) and SC (4 rounds) uses four calls (matching SV + VH, three rounds).

Under matched compute budgets, SV + VH consistently outperforms SC on all metrics across both datasets. SC yields negligible gains over the Base method—on BIRD, SC (4 rounds) achieves only 78.3% Column F1 versus 78.2% for base, while SV + VH (1 round) already reaches 80.3%. This demonstrates that the improvement from SV is attributable to the structured verification design (completeness, connectivity, and precision checks), not merely to additional inference passes.

5.4. Model Scale Experiments

To assess the generality of our method across model scales, we evaluate SV + VH on an additional model: Qwen3-Next-80B-MoE (80B MoE, approximately 20B activated parameters).

Table 4. Effect of SV + VH across different model scales. SV + VH improves performance on both small and large models, though the gains are more pronounced on smaller models. Note: Minor differences in Base method results compared to Table 1 are due to different random seeds used in these experiments.

Model	Method	BIRD			Spider
		Table F1	Col F1	SL F1	Table F1	Col F1	SL F1
Qwen3-4B	Base	89.9	78.3	70.7	86.6	80.9	78.7
	SV + VH (1r)	91.4	79.9	71.8	87.4	82.0	79.7
	SV + VH (3r)	91.5	80.0	71.4	87.2	82.2	80.3
Qwen3-Next -80B-MoE	Base	93.2	83.8	77.5	88.8	86.0	84.9
	SV + VH (1r)	93.2	84.0	78.2	89.7	87.0	86.1
	SV + VH (3r)	93.5	84.0	77.0	89.8	87.1	85.9

presents the results.

Several observations emerge from the model scale experiments:

• SV + VH is effective across model scales. On Qwen3-4B, SV + VH (one round) improves Column F1 by +1.6% on BIRD and +1.1% on Spider over the Base method. On the larger Qwen3-Next-80B-MoE, gains are smaller but still consistent: +0.2% Column F1 on BIRD and +1.0% on Spider. This pattern suggests that SV + VH provides complementary value that persists as model capability increases, though stronger models leave less room for improvement.
• Diminishing returns with stronger models. The relative improvement from SV + VH decreases as model capability increases (Qwen3-4B > Qwen3-Next-80B-MoE), consistent with the hypothesis that stronger models already perform implicit verification during generation.

5.5. Analysis

5.5.1. Precision–Recall Trade-Off

Figure 3 illustrates the precision–recall characteristics of different methods through scatter plots, showing the trade-off between precision and recall at both table and column levels.

The Decomp method achieves very high recall (95.9% for tables, 93.5% for columns) but suffers from extremely low column precision (48.4%). This means nearly half of predicted columns are incorrect. In contrast, SV-only maintains high recall while dramatically improving precision.

5.5.2. Error Analysis

We conducted manual error analysis on 50 randomly sampled errors from each method.

Base method errors:

• 42% missing columns for implicit value references;
• 28% missing tables needed for JOINs;
• 30% over-prediction of semantically similar columns.

Decomp method errors:

• 56% over-prediction from decomposition noise;
• 24% incorrect decomposition leading to wrong linking;
• 20% missing elements not covered by any sub-question.

SV-only method errors:

• 38% missing columns for complex implicit references;
• 32% under-pruning of related but unnecessary elements;
• 30% boundary cases with ambiguous relevance.

The analysis reveals that SV-only largely eliminates over-prediction errors while maintaining strong recall, explaining its superior performance. Figure 4 visualizes the error distribution for each method.

Figure 5 provides a comprehensive comparison of methods across all precision and recall metrics, illustrating how SV-only achieves superior balance across all dimensions.

6. Discussion

6.1. Why Does Self-Verification Work?

Our results demonstrate that self-verification substantially improves schema linking, particularly for precision. We hypothesize several reasons:

• Evaluation is easier than generation. The verification task asks the model to judge whether specific elements are necessary, which is cognitively simpler than generating the complete set from scratch. This aligns with findings in other domains showing that LLMs are better evaluators than generators [29].
• Explicit criteria focus attention. The verification prompt provides explicit checking criteria (completeness, connectivity, and precision) that guide the model’s attention to specific failure modes. This structured evaluation helps catch errors that might be missed in open-ended generation. This is consistent with the finding that LLMs require structured external guidance to effectively self-correct [15].
• Multiple perspectives reduce blind spots. Each verification round provides an opportunity to reconsider the prediction from a fresh perspective, catching errors that survived previous rounds.

6.2. When to Use Each Method?

Based on our experimental results, we provide the following recommendations:

• For high-precision requirements (e.g., minimizing false positives), use SV-only or SV + VH.
• For high-recall requirements (e.g., ensuring all relevant elements are captured), use Decomp + SV + VH with multiple verification rounds.
• When database values are frequently mentioned in queries, always enable value hints.
• For efficiency-critical applications, use the Base method with careful prompt engineering.

Figure 6 summarizes the component effects, showing how each technique contributes to the final performance.

6.3. Computational Cost Analysis

Table 5. Computational cost analysis per query on the Spider development set. Avg Latency includes all LLM calls for that method. VH preprocessing cost is excluded as it is a one-time offline step (see VH Matching Pipeline Section). Tokens = total input + output tokens.

Method	LLM Calls	Avg Latency (s)	Avg Tokens
Base	1	5.5	1916
SC (n = 2)	2	0.5	1946
SC (n = 4)	4	0.5	2005
SV + VH (1r)	2	7.0	2982
SV + VH (3r)	4	14.4	4938

quantifies the computational cost of each method variant. All measurements are averaged over the Spider development set using Qwen3-4B served via vLLM on a single GPU.

SV + VH (one round) approximately doubles the token cost and latency compared to the Base method, which is expected given the additional verification pass. SV + VH (three rounds) incurs approximately 2.6× the token cost and latency of the Base method, scaling linearly with the number of verification rounds. Note that SC achieves lower per-call latency because it uses parallel sampling, but as shown in Table 3, this budget does not translate to meaningful accuracy gains. For practical deployments, SV + VH (one round) offers the best cost-effectiveness trade-off, achieving most of the performance gain at only 2× the base cost.

6.4. Evaluation Metric Discussion

Our evaluation uses exact-set matching for both tables and columns, where a prediction is correct only if it exactly matches the ground truth set. We acknowledge that this metric can be strict in cases where multiple valid schema linkings exist for a given question—for example, when equivalent join paths exist or when surrogate keys could replace natural keys.

Regarding foreign key join columns, our SV verification prompt explicitly asks the model to include “foreign key columns for JOINs between selected tables.” The ground truth annotations in Spider and BIRD extract schema elements from gold SQL queries, which include JOIN columns. Therefore, our SV mechanism is aligned with the evaluation protocol rather than working against it. We verified that on both benchmarks, JOIN columns are consistently included in ground truth annotations when they appear in the gold SQL.

We note that a relaxed evaluation metric (e.g., crediting predictions that yield equivalent SQL) would likely benefit all methods equally and would not change the relative rankings. Developing such metrics is an important direction for future work in schema linking evaluation.

6.5. Limitations

Our work has several limitations:

• Computational overhead. Self-verification requires additional LLM calls, increasing latency and cost. As quantified in Table 5, SV + VH (one round) approximately doubles the inference cost, while SV + VH (three rounds) incurs 4× the LLM calls. For latency-sensitive applications, one-round verification offers the best efficiency–accuracy trade-off.
• Value matching preprocessing. The VH component requires offline preprocessing to identify database value matches. While this is lightweight for the evaluated benchmarks (4.5–35.3 ms per sample), it may become more expensive for very large databases with millions of rows. Strategies such as indexing or sampling could mitigate this for production deployment.
• Model dependence. While our model scale experiments (Table 4) demonstrate that SV + VH generalizes across two models of different sizes (4B and 80B), the optimal number of verification rounds may need to be tuned per model depending on its specific capabilities and error patterns.

7. Conclusions

We presented an enhanced schema linking framework via self-verification and value hints for database-driven natural language interfaces. Our approach introduces two key components: self-verification (SV) for iterative refinement and value hints (VHs) for explicit value guidance.

Comprehensive experiments on Spider and BIRD benchmarks demonstrate that SV + VH consistently outperforms both decomposition-based approaches and compute-matched alternatives such as self-consistency. Under equivalent inference budgets, the structured verification design of SV yields significantly larger gains than naive multi-sample voting, confirming that the improvements stem from the verification mechanism itself. The Decomp + SV + VH method with three verification rounds achieves the best SL F1 of 75.7% on BIRD, while SV + VH achieves 80.9% on Spider. Model scale experiments across two architectures (Qwen3-4B and Qwen3-Next-80B-MoE) confirm that SV + VH generalizes beyond a single model, with the largest relative gains observed on smaller models.

Our ablation studies reveal that multiple verification rounds progressively improve performance, with three rounds yielding 4.6% Column F1 improvement over single-round verification. This validates the effectiveness of iterative self-verification for structured prediction tasks.

Future work includes extending self-verification to other structured prediction tasks, exploring more efficient verification strategies, and investigating the interaction between schema linking and query understanding.