Improving Table Retrieval with Question Generation from Partial Tables (2025)

Abstract: Recent advances in open-domain question answering over tables have widely adopted large language models (LLMs) under the Retriever-Reader architecture. Prior works have effectively leveraged LLMs to tackle the complex reasoning demands of the Reader component, such as text-to-text, text-to-SQL, and multi-hop reasoning. In contrast, the Retriever component has primarily focused on optimizing the query representation—training retrievers to retrieve relevant tables based on questions, or to select keywords from questions for matching table segments. However, little attention has been given to enhancing how tables themselves are represented in embedding space to better align with questions. To address this, we propose QGpT (Question Generation from Partial Tables), a simple yet effective method that uses an LLM to generate synthetic questions based on small portions of a table. These questions are generated to simulate how a user might query the content of the table currently under consideration. The generated questions are then jointly embedded with the partial table segments used for generation, enhancing semantic alignment with user queries. Without the need to embed entire tables, our method significantly improves retrieval performance across multiple benchmarks for both dense and late-interaction retrievers.

## introduction table-based question answering (table-qa) has drawn increasing attention in recent years, beginning with early works on wiki-style tables @xcite . these early table-qa tasks typically operate under the assumption that the relevant table is provided alongside the question. while this assumption simplifies the problem and allows a focused evaluation of reasoning over structured data, it fails to reflect the challenges of real-world open-domain usage scenarios. in practical settings, users do not typically specify which table to consult. instead, they ask questions in natural language, and the system must first determine which tables might contain the relevant information before reasoning. the assumption of a known target table is thus insufficient in many realistic applications, where the answer may reside in any one of potentially thousands of tables within a large corpus. to address this gap, recent research has moved toward integrating table retrieval into the qa pipeline. this shift is marked by the adoption of retriever-reader architectures @xcite , where a retriever component is responsible for identifying candidate tables, followed by a reader module that performs qa over the retrieved tables. as a pioneering study, nq-tables @xcite provides naturally phrased questions and their corresponding answer tables extracted from the natural questions dataset @xcite , and transforms tapas @xcite , a bert-based table reader, into a dense table retriever (dtr) by adopting the dpr @xcite training paradigm. yet another study named cltr @xcite integrates the rci (row-column intersection; @xcite model with bm25 @xcite for table retrieval, and introduces the e2e-wtq dataset for rci retriever fine-tuning. however, studies such as nq-tables and cltr operate under the assumption that the answer to a question resides in a specific cell within a single, relatively short table. while this setting facilitates controlled evaluation, it significantly limits the generalizability of these approaches to realworld applications, where answering questions often requires reasoning over multiple or lengthy tables. therefore, mmqa @xcite extend the table-qa paradigm by introducing complex reasoning tasks that integrate question answering with text-to-sql, using the spider dataset (yu et al., 2018) as a foundation. they propose a multi-table retrieval (mtr) setting, in which a single question may require retrieving and reasoning over multiple relevant tables. their approach decomposes the original query into sub-queries, enabling independent retrieval and re-ranking of candidate tables. building on the idea of query decomposition, tablerag @xcite adopts a similar strategy by splitting questions into schema-level and cell-level components and performing separate retrieval for each. additionally, it segments tables into schema and content parts, allowing scalable retrieval across corpora with millions of cells, and focuses on retrieving localized table segments to improve efficiency and accuracy. in summary, table -qa has evolved from simple single-table, short-answer settings @xcite @xcite to more complex, multi-table, and reasoning-intensive tasks @xcite . nevertheless, practical deployment remains challenging due to the growing size and noise of real-world tables. traditional retrievers @xcite @xcite struggle to capture fulltable context in token limits, while more recent approaches @xcite @xcite primarily rely on table segmentation based on rows, columns, or schema structures to improve matching between query keywords and table fragments. these methods focus on keywordlevel matching rather than learning a semantically rich representation of the table that aligns with user questions. moreover, they are often bound to dataset-specific assumptions or require retriever fine-tuning @xcite . to tackle this issue, we propose question generation from partial tables (qgpt), a simple yet effective table retrieval method for long and complex table-qa tasks. our approach requires only a small snippet of the table and leverages llms to generate simulated questions that are likely to be asked. these questions are jointly embedded with the partial table snippet, enabling a dense representation with minimal token budget while improving retrieval accuracy. as shown in figure 1 , qgpt is applied during the offline phase to augment the table corpus. during inference, it can adapt to various retrievers without fine-tuning, and enhances the performance of both dense and late-interaction retrievers @xcite . our qgpt framework offers a lightweight and generalizable solution that improves semantic alignment between questions and tables, reduces context size, and maintains retrieval performance in increasingly large and complex table settings. table descriptions, and generating synthetic questions. 2 related work 2.1 table question answering (tableqa) early tableqa tasks typically assume the target table is known, focusing on reasoning within a single table. wiki-tablequestions (pasupat and liang, 2015) is a pioneering dataset that provides semi-structured wikipedia tables with questions involving simple answering. wikisql (zhong et al., 2017) reframes the task as a text-to-sql problem, enabling structured query-based answering. spider (yu et al., 2018) introduces higher complexity by requiring reasoning over multiple tables and supporting diverse sql logic. subsequent works began exploring more natural question formulations and open-ended scenarios. fetaqa (nan et al., 2022) introduced free-form, multi-hop reasoning questions requiring sentencelevel answers across multiple rows. openwik-itable (kweon et al., 2023) expanded wikisql and wikitablequestions by incorporating a larger table collection and more natural question expressions. more recently, mimotable (li et al., 2025) uses real-world spreadsheets of varying size and complexity, containing multi-sheet structures and nested tables. it categorizes difficulty levels based on file count, number of sheets, and header complexity, making it one of the most comprehensive tableqa benchmarks. overall, the evolution of tableqa datasets has shifted from "single-table, structured qa pairs" to "multi-table, semantically ambiguous, natural language" tasks. however, most of these datasets do not consider the open-domain setting where tables must be retrieved from a large corpus before answering. 2.2 table retrieval in open-domain qa a core challenge in open-domain tableqa is efficiently retrieving relevant tables from large corpora. ott-qa (chen et al., 2020) introduces table retrieval from wikipedia to support open-domain question answering, highlighting the need for integrated retriever-reader systems. nq-tables (herzig et al., 2021) converts questions from natural questions (kwiatkowski et al., 2019) into table-based qa pairs and incorporates a retrieval subtask. e2e-wtq (pan et al., 2021) extends wikitablequestions into a retrieval setting and proposes cell-level table retrieval (cltr), focusing on cell-level semantic matching. li-rage @xcite combines the concept of joinable tables with late-interaction retrievers @xcite , enabling joint training of retrievers and readers for better performance. tablerag @xcite decomposes questions and tables into schema-level and cell-level components, enabling compression of million-cell tables into retrievable chunks. mmqa @xcite introduces multi-table retrieval (mtr), which leverages llms like gpt-4 @xcite for query decomposition without retriever fine-tuning. it further employs llm-based retrievers such as tablellama @xcite and sgpt @xcite . ## conclusion in this work, we propose qgpt (question generation from partial tables), a simple yet effective framework to enhance