💻 computer science

Retrieve Only Relevant Tables Whether Few or Many: Adaptive Table Retrieval Method

This paper proposes an adaptive table retrieval method that dynamically adjusts the number of retrieved tables based on query requirements using adaptive thresholding and sliding-window reranking, thereby overcoming the limitations of fixed top-k strategies and improving performance on text-to-SQL benchmarks like Spider and BIRD.

Original authors: Taehee Kim, Seungbin Yang, Jihwan Kim, Jaegul Choo

Published 2026-05-20

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Taehee Kim, Seungbin Yang, Jihwan Kim, Jaegul Choo

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a detective trying to solve a mystery. You have a massive library of files (a database) containing thousands of documents, and you have a specific question you need to answer.

The Old Way (Fixed Top-K):
In the past, detectives had a strict rule: "No matter what the question is, you must grab exactly 5 files from the library to start your investigation."

The Problem: If your question is simple (e.g., "Who is the mayor?"), grabbing 5 files is wasteful. You might grab 4 irrelevant files that just clutter your desk and confuse you.
The Problem: If your question is complex (e.g., "Trace the money flow between three companies over five years"), grabbing only 5 files isn't enough. You might miss the crucial file that holds the key to the case, and your investigation fails.

This is exactly what happens in current computer systems that try to answer questions about databases (like converting "Show me movies by Spielberg" into a database query). They force the system to pick a fixed number of tables (like 5 or 10), regardless of whether the question needs 1 table or 100.

The New Way (ATR - Adaptive Table Retrieval):
The authors of this paper, Taehee Kim and colleagues, built a smarter detective system called ATR (Adaptive Table Retrieval).

Instead of a rigid rule, ATR acts like a seasoned detective who looks at the question first and asks: "How many files do I actually need to solve this?"

Here is how ATR works, using simple analogies:

1. The "Magic Threshold" (Adaptive Thresholding)

Imagine ATR has a special "magic line" drawn on the floor.

When the detective looks at a file, they assign it a score based on how relevant it is to the question.
If a file's score is above the magic line, it gets picked up.
If a file's score is below the line, it is left behind.
The Magic: The height of this magic line changes depending on the question. For a simple question, the line is high, so only the most obvious files are picked. For a complex question, the line lowers, allowing more necessary files to be gathered. This means ATR never grabs too few (missing clues) or too many (creating noise).

2. The "Sliding Window" (Efficiency)

Imagine the library is so huge that the detective can't look at every single file at once without getting a headache (computers run out of memory).

ATR uses a sliding window. It looks at a small group of files (a window), picks the best ones, and then slides the window over to the next group.
It's like reading a book by looking at a few pages at a time, remembering the best parts, and moving on, rather than trying to read the whole book in one giant gulp. This makes the process fast and efficient, even for massive databases.

3. The "Team Huddle" (Semantic Grouping)

Sometimes, files are useless on their own but become gold when combined.

ATR is trained to understand that certain files belong together (like a "Customer" file and an "Order" file). It learns to pull these "joinable" files closer together in its mind, ensuring that if it picks one, it's likely to pick the other if needed.

The Results: What Did They Find?

The team tested this new detective (ATR) against the old rigid methods on three major "mystery cases" (datasets called Spider, BIRD, and Spider 2.0).

Better Accuracy: Because ATR grabs exactly the right files, the computer's final answer (the SQL query) was much more accurate.
Less Noise: ATR didn't waste time reading irrelevant files. In the old method, irrelevant files often confused the computer, leading to wrong answers. ATR avoided this "noise."
Speed and Efficiency: By not grabbing unnecessary files, ATR used less computer memory and finished the job faster.
Handling Complexity: In the hardest test (Spider 2.0), where some questions required up to 366 different tables, the old methods failed miserably because they were stuck trying to grab a fixed, small number. ATR successfully grabbed all 366 when needed, and only 1 when that was enough.

In Summary:
The paper claims that by letting the computer decide how many tables to look at based on the specific question—rather than forcing a fixed number—we get better answers, faster results, and fewer mistakes. It's the difference between a robot blindly grabbing 5 books off a shelf and a smart librarian who grabs exactly the books needed to answer your question.

Technical Summary: Adaptive Table Retrieval (ATR)

Problem Definition

In Retrieval-Augmented Generation (RAG) for tasks like text-to-SQL, existing table retrieval methods rely on a fixed top- $k$ strategy. These approaches select a pre-determined number of tables ( $k$ ) with the highest similarity scores to a natural language query. However, the number of tables required to answer a specific query is inherently variable and unknown in advance. In complex, enterprise-level databases (e.g., Spider 2.0), ground-truth table requirements can range from 1 to over 300 tables per query.

A fixed $k$ strategy creates a fundamental trade-off:

Small $k$ : Risks missing essential tables (low recall), leading to insufficient evidence for accurate reasoning.
Large $k$ : Retrieves excessive irrelevant tables (noise), which inflates inference latency, increases token usage, and degrades downstream performance by confusing the generator.

Current methods fail to adapt to this variability, often retrieving undersized sets or oversized pools containing irrelevant data.

Methodology: Adaptive Table Retrieval (ATR)

The authors propose Adaptive Table Retrieval (ATR), a method that dynamically determines the number of tables to retrieve based on the specific requirements of each query, rather than relying on a static cutoff.

Core Mechanisms

Adaptive Thresholding:
- ATR introduces a learnable threshold token ( $T_{th}$ ) into the input sequence alongside the query and candidate tables.
- During inference, the model computes logits for both the table tokens ( $T_i$ ) and the threshold token.
- A table is selected if its logit score exceeds the logit of the threshold token. This allows the number of retrieved tables ( $k_q$ ) to vary per query.
- Training Objective ( $L_{AT}$ ): The model is trained to push logits of relevant tables above $T_{th}$ and irrelevant tables below it using a binary cross-entropy loss formulation.
Relevance Calibration ( $L_{RC}$ ):
- To sharpen the distinction between relevant and irrelevant tables, a binary cross-entropy loss maximizes the logit gap between the two groups, ensuring the threshold acts as a robust decision boundary.
Semantic Grouping ( $L_{SG}$ ):
- Recognizing that multi-table queries often require joining tables, ATR employs a contrastive learning objective. This pulls embeddings of joinable tables (those sharing join keys) closer together while pushing non-joinable tables apart. This captures inter-table relationships critical for complex reasoning.
Sliding-Window Reranking:
- To handle large table corpora efficiently without exceeding the quadratic complexity and length constraints of transformer encoders, ATR utilizes a sliding-window reranking algorithm.
- Instead of scoring all tables at once, the method processes tables in overlapping windows. It retains the top- $R$ tables from each window and merges them with the next batch, iteratively refining the ranking until all candidates are processed. This ensures scalability while maintaining the adaptive threshold logic.

Key Contributions

Identification of Fixed- $k$ Limitations: The paper demonstrates that rigid top- $k$ strategies are ill-suited for text-to-SQL tasks where ground-truth table counts vary significantly, leading to either missed evidence or noise injection.
Adaptive Framework: The proposal of ATR, which leverages query-dependent thresholding, relevance calibration, and semantic grouping losses to precisely retrieve necessary tables without iterative LLM interactions.
Scalable Inference: The integration of a sliding-window reranking mechanism that enables efficient processing of extensive table corpora, avoiding the computational cost of full-list reranking.

Experimental Results

The authors evaluated ATR on three benchmarks: Spider, BIRD, and Spider 2.0 (an enterprise-level benchmark with queries requiring up to 366 tables).

Retrieval Performance: ATR consistently outperformed top- $k$ $k$ baselines (including encoder-based, LLM-based, and reranker-based methods) across all datasets.
- On Spider, ATR improved Precision by >20% and F1 by >15% compared to baselines.
- On Spider 2.0, where table requirements vary wildly, ATR achieved Complete Recall scores at least 10% higher than other models, demonstrating robustness to varying query complexities.
Downstream Text-to-SQL Performance:
- ATR improved execution accuracy across all tested generators (Llama, Qwen, Gemma) and datasets.
- On Spider 2.0, ATR narrowed the performance gap to the "Oracle" setting (where the generator receives perfect ground-truth tables) to within 1.4% using Qwen2.5-Coder-7B.
Efficiency:
- ATR achieved higher execution accuracy with fewer input tokens compared to top- $k$ baselines. For instance, on Spider, it used 430 fewer tokens than the best-performing fixed- $k$ approach.
- The sliding-window strategy significantly reduced GPU memory consumption (up to 80.5% reduction in peak memory for Spider 2.0) compared to processing all tables simultaneously.
Comparison with Adaptive Document Retrieval: ATR outperformed existing adaptive document retrieval methods (e.g., FLARE, Adaptive-RAG) in both accuracy and end-to-end latency, primarily because it avoids iterative generator interactions.

Significance and Claims

The paper claims that ATR provides a practical and robust solution for large-scale database retrieval applications. By moving away from the rigidity of fixed- $k$ retrieval, ATR effectively balances the trade-off between recall and noise, ensuring that downstream LLMs receive the precise set of evidence required for accurate reasoning.

The authors emphasize that their method:

Eliminates the need for manual $k$ tuning, which is impossible given the variability of query complexity.
Operates efficiently without the high computational cost of iterative LLM-based retrieval loops.
Scales effectively to enterprise-level databases with thousands of tables and complex schemas.

The work concludes that adaptive retrieval is essential for advancing RAG in structured data domains, offering a foundation for future research in generalizing retrieval-augmented generation across diverse data types.