TEXT2DB: Schema-Driven Transformation

Updated 5 July 2026

TEXT2DB is a paradigm that converts free-form text into structured database artifacts by mapping natural language to relational tables, SQL queries, or database updates.
It employs diverse methodologies including schema-guided text-to-table generation, text-to-SQL conversion, and integration-aware information extraction to ensure factual consistency and constraint enforcement.
Applications range from synthetic benchmark generation to real-world database mediation, enhancing query explainability, schema induction, and operational reliability.

to=arxiv_search.search 大发快三怎么json {"query":"(Ahuja et al., 29 May 2025) TEXT2DB Map&Make schema guided text to table generation", "max_results": 5} to=arxiv_search.search 天天彩票提现json {"query":"TEXT2DB arXiv 2025 information extraction database update OPAL", "max_results": 10} to=arxiv_search.search 重庆时时彩的json {"query":"text-to-table generation arXiv LiveSum Text-Tuple-Table (Deng et al., 2024)", "max_results": 10} TEXT2DB denotes a family of database-grounded transformations that map natural language, unstructured documents, or document-borne tables into structured database artifacts such as relational tables, SQL queries, or explicit database updates. Recent work applies the label to schema-guided text-to-table generation, retrieval-augmented Text-to-SQL, integration-aware information extraction, document table extraction, and synthetic benchmark construction for key–value extraction. This suggests that, in current arXiv usage, TEXT2DB functions as an umbrella term for systems that align free-form textual evidence with database schemas, constraints, and downstream operations rather than as a single narrowly defined task (Ahuja et al., 29 May 2025, Gladkykh et al., 3 Apr 2025, Jiao et al., 28 Oct 2025).

1. Scope and task variants

Current formulations of TEXT2DB differ primarily in the target artifact they produce and in whether the target schema is induced, retrieved, or given a priori.

Formulation	Transformation	Representative paper
Schema-guided text-to-table	Unstructured text to one or more populated tables	Map&Make (Ahuja et al., 29 May 2025)
Text-to-SQL	Natural-language request to executable SQL	Datrics Text2SQL (Gladkykh et al., 3 Apr 2025)
Integration-aware IE	Documents plus instruction to database updates	OPAL / TEXT2DB (Jiao et al., 28 Oct 2025)
NLIDB with explanations	Natural-language query to SQL with explicit rationale	xDBTagger (Usta et al., 2022)
Document table extraction	Page images or PDFs to cell-level structured tables	Tablext (Colter et al., 2021)
Synthetic benchmark generation	Existing tables to grounded narratives for later extraction evaluation	StructText (Kashyap et al., 28 Jul 2025)

The broadest distinction is between representation generation and database action. In text-to-table systems, the output is usually a table or a set of relational tables that summarize or integrate information from text. In text-to-SQL systems, the output is a grounded query whose execution is expected to recover the intended result over an existing schema. In integration-aware IE, the output is not a query but a set of inserts, updates, or schema extensions applied directly to the database (Ahuja et al., 29 May 2025, Gladkykh et al., 3 Apr 2025, Jiao et al., 28 Oct 2025).

A second distinction concerns schema availability. Some systems induce latent schema from the text itself; others depend on extensive database documentation, examples, or compressed schema representations; still others assume a fixed, known relational schema and focus on alignment, linking, and constraint satisfaction (Ahuja et al., 29 May 2025, Gao et al., 28 Feb 2025, Liu et al., 26 Jun 2026).

2. Formal representations and schema grounding

One formalization of text-to-table generation casts the input as unstructured text $T = (t_1, t_2, \ldots, t_N)$ and the output as a set of relational tables $\{R_i\}$ with schemas $S_i = (A_i, K_i, C_i)$ , where $A_i$ is the set of attributes, $K_i$ is the key, and $C_i$ is a set of constraints including uniqueness, foreign keys, functional dependencies, and domain constraints. Cross-table constraints are represented through foreign keys, and the goal is to induce schemas and populate tuples while satisfying these constraints and maximizing factuality and consistency (Ahuja et al., 29 May 2025).

Within that formulation, text can first be decomposed into atomic propositions such as subject–predicate–object triples, attribute–value pairs, or event atoms. The extraction function $f: T \to A$ maps text to atoms, and the schema induction function $g: A \to S$ maps atoms to inferred schemas. This decomposition is designed to separate local factual extraction from later table-level integration, normalization, and aggregation (Ahuja et al., 29 May 2025).

A different formalization, central to integration-aware IE, defines TEXT2DB as a constrained update problem. Given a user instruction $I$ , a document set $X = \{x_1,\ldots,x_N\}$ , and a database $\{R_i\}$ 0, the system computes a set of database updates $\{R_i\}$ 1 such that $\{R_i\}$ 2 while satisfying primary-key uniqueness, referential integrity, and domain or validation predicates. This reframes extraction as database state transition rather than table generation alone (Jiao et al., 28 Oct 2025).

Text-to-SQL work adopts yet another intermediate representation. Datrics Text2SQL preprocesses a user request into a normalized form $\{R_i\}$ 3, a main clause $\{R_i\}$ 4, extracted entities $\{R_i\}$ 5, operations $\{R_i\}$ 6, and, during training, data sources $\{R_i\}$ 7. Example items are stored as structured tuples

$\{R_i\}$ 8

which are later retrieved to anchor SQL generation to schema elements and domain rules (Gladkykh et al., 3 Apr 2025).

A complementary metadata-centered formulation appears in automatic database description generation. There, a database schema $\{R_i\}$ 9 is paired with generated descriptions at database, table, and column granularity, using coarse-to-fine and fine-to-coarse passes to produce $S_i = (A_i, K_i, C_i)$ 0, $S_i = (A_i, K_i, C_i)$ 1, and $S_i = (A_i, K_i, C_i)$ 2. The purpose is not to populate tables directly, but to transform raw schemas into semantically legible contexts that improve subsequent Text-to-SQL linking (Gao et al., 28 Feb 2025).

3. Methodological families

Schema-guided text-to-table systems emphasize decomposition and integration. Map&Make is described as a versatile approach that “dissects” text into propositional atomic statements, extracts a latent schema, and then populates tables that capture “the qualitative nuances and the quantitative facts” in the original text. It is evaluated on Rotowire, noted for its complex and multi-table schema, and LiveSum, which requires numerical aggregation; the work also explicitly targets hallucination correction in Rotowire and reports better interpretability in text-to-table generation (Ahuja et al., 29 May 2025).

The Text–Tuple–Table pipeline, denoted $S_i = (A_i, K_i, C_i)$ 3, makes the intermediate representation explicit. It decomposes generation into Text-to-Tuple extraction, global information integration, and Tuple-to-Table generation. On the LiveSum football-commentary benchmark, the integration stage uses LLM-generated code to aggregate tuples under domain rules such as “goals are also shots,” “the second yellow card is also considered a red card,” and “penalty is also considered as free kicks.” The reported gains are large: for GPT-4, RMSE drops from 2.225 to 0.929 and error rate from 46.20% to 25.27%; for Claude 3 Opus, RMSE drops from 2.079 to 0.438 and error rate from 47.17% to 14.04% (Deng et al., 2024).

Retrieval-augmented Text-to-SQL systems instead center schema-aware context construction. Datrics Text2SQL builds a knowledge base from JSON-structured documentation, question–SQL examples, and domain-specific instructions. Retrieval uses cosine similarity, progressive percentile-based thresholds, metadata-filtered documentation search with $S_i = (A_i, K_i, C_i)$ 4 per query, and a cross-encoder trained on Quora Duplicate Questions for reranking. The framework distinguishes example-driven and documentation-driven SQL generation, but it does not specify AST parsing, constrained decoding, or execution-time validators (Gladkykh et al., 3 Apr 2025).

Metadata synthesis constitutes another methodological branch. Automatic database description generation for Text-to-SQL uses a dual-process design: coarse-to-fine generation starts from database-level context and descends to tables and columns, whereas fine-to-coarse generation starts from column semantics and aggregates upward. The method enforces concise descriptions—columns at most 20 words and tables at most 100 words—and reports an average Execution Accuracy improvement of 0.93 percentage points over no-description baselines on the BIRD development set, reaching 37% of human-level performance (Gao et al., 28 Feb 2025).

Explainable hybrid NLIDB systems replace end-to-end generation with interpretable tagging and synthesis. xDBTagger uses a bi-directional GRU + CRF sequence tagger to assign POS, Type, and Schema labels to tokens, then constructs SQL by traversing a schema graph and discovering shortest join paths. Explanations are provided textually, visually through schema graph highlighting, and locally through an adapted LIME wrapper. On imdb, scholar, and yelp, the system reports end-to-end translation accuracies of 61.83%, 58.96%, and 69.53%, respectively, and claims query translation efficiency improvements of up to 10000 times over other pipeline-based systems (Usta et al., 2022).

A further branch addresses document-borne tables rather than free text. Tablext combines a custom CNN, YOLOv3, computer-vision structure recognition, a cell-merging CNN, and OCR to extract tables from machine-readable or image-based documents. Its hybrid design deliberately allocates geometric tasks to heuristic CV methods and harder localization tasks to neural models. Reported results include adjacency-relation F1 of 0.9156 on ICDAR 2013 and F1 of 0.9313 on a diverse PDF dataset, with explicit support for scanned tables lacking machine-readable text (Colter et al., 2021).

4. Benchmarks and evaluation regimes

Evaluation in TEXT2DB is highly task-dependent. For numerical text-to-table generation, LiveSum is a central benchmark: it contains 3,771 English Premier League matches from 2014–2023, with 3,017 training and 754 test instances, average commentary length of 1,256 words, and eight event types—goals, shots, fouls, yellow cards, red cards, corner kicks, free kicks, and offsides. Primary metrics are RMSE and exact-match Error Rate over numeric cells, and the benchmark explicitly stratifies event types into easy, medium, and hard categories, with shots and fouls identified as the hardest (Deng et al., 2024).

StructText addresses the opposite direction: using real tables as gold structure and generating synthetic narratives to create extraction benchmarks. It operates at large scale, with 71,539 examples across 49 datasets, and evaluates generated narratives by combining LLM-as-judge rubrics for factuality, hallucination, and coherence with objective numeric and temporal matching. Reported judge scores are high for factuality and hallucination avoidance—SEC factuality 4.58 and hallucination 4.90 on a 1–5 scale—but coherence is markedly lower at 3.28. Numeric and temporal fidelity is also high, yet baseline TEXT2DB extraction remains difficult, with SEC column-identification F1 of 0.455 and value extraction precision/recall of 0.257/0.110 (Kashyap et al., 28 Jul 2025).

Integration-aware IE introduces a different benchmark structure. The OPAL paper defines 240 instances across 203 databases in 45 domains, covering data infilling, row population, and column addition. The average database in that benchmark has 2.5 tables, 56K rows, and 15 columns, and the average instruction updates 8.4 values. The primary metric is macro-F1 over exact-matched field updates in $S_i = (A_i, K_i, C_i)$ 5, and the full OPAL system reports 34.11 overall, with 42.44 on easy instances, 36.91 on medium, and 23.21 on hard ones (Jiao et al., 28 Oct 2025).

Text-to-SQL evaluations remain heterogeneous. The automatic description-generation paper reports Execution Accuracy on BIRD, whereas Datrics Text2SQL explicitly does not report standard benchmark metrics such as exact match or execution accuracy, focusing instead on retrieval behavior such as percentile thresholds, paraphrase-cluster structure, and the fact that documentation retrieval yields about 23–40 unique tables per question, approximately 30 on average, with Rand Index about 0.36 (Gao et al., 28 Feb 2025, Gladkykh et al., 3 Apr 2025).

The coexistence of these regimes indicates that TEXT2DB currently lacks a single universal metric. Cell-level RMSE and error rates, execution accuracy, exact SQL equivalence, macro-F1 over update tuples, referenceless self-consistency measures, and judge-based factuality all quantify different operational goals. This suggests that evaluation must remain coupled to the specific artifact the system is expected to produce.

5. Constraints, explainability, and context management

A persistent theme across TEXT2DB is that extraction quality alone is insufficient unless outputs are made compatible with schema constraints and operational database semantics. Integration-aware IE makes this explicit through database actions such as Link, Norm, DI, PR, and AC, which handle entity linking, normalization, data infilling, row population, and column addition. OPAL organizes these actions through three agents—Observer, Planner, and Analyzer—with up to 10 Planner revisions and up to 2 restarts, using schema summaries, in-context demonstrations, simulated tests, and integrity checks before execution (Jiao et al., 28 Oct 2025).

Explainability is another recurrent systems requirement. xDBTagger addresses black-box concerns by exposing token-level Type and Schema predictions, LIME-based contribution scores, and schema graph visualizations showing why intermediate relation tables appear in generated SQL. In this design, explainability is not an auxiliary visualization layer but part of the translation pipeline itself, coupling mapping decisions to explicit graph traversal and clause construction (Usta et al., 2022).

Metadata quality also becomes a systems primitive. Automatic description generation argues that table and column descriptions are crucial when explicit comments are missing, sparse, or stale. By generating database-, table-, and column-level descriptions and enforcing consistency between them, the method attempts to replace raw schema strings with semantically aligned schema views that improve downstream linking and join selection (Gao et al., 28 Feb 2025).

For real enterprise databases, context management becomes a dominant bottleneck. DBCC reformulates the issue as database context compression and introduces Support–Gain Component Factorization, with gain defined as

$S_i = (A_i, K_i, C_i)$ 6

where $S_i = (A_i, K_i, C_i)$ 7 is support and $S_i = (A_i, K_i, C_i)$ 8 is width. The compressed query-time representation is written as $S_i = (A_i, K_i, C_i)$ 9, combining compressed schema, compressed semantic metadata, and purified evidence. Reported effects are substantial: on the largest Spider 2.0-Snow subset, input context is reduced from 2.6M to 34.7K tokens; schema-linking strict recall rises from 0% to 56.5% under DeepSeek-V3.2 and to 63.1% under Claude Opus 4.7; and execution accuracy increases by 1.8–1.9% when integrated into three recent Text-to-SQL systems (Liu et al., 26 Jun 2026).

These developments show that TEXT2DB has evolved from an extraction problem into a broader database mediation problem. The mediation layer includes normalization, linking, key management, provenance, schema summarization, evidence purification, and constraint-aware repair, not only the initial mapping from text to structured tokens.

6. Limitations, recurring failure modes, and open directions

Despite rapid diversification, current TEXT2DB systems exhibit several recurring failure modes. In schema-guided text-to-table pipelines, reported weaknesses include schema misinduction, entity-linking errors, numeric misaggregation, and cross-table inconsistencies; the same descriptions emphasize the need for declarative constraints and repair strategies (Ahuja et al., 29 May 2025). In integration-aware IE, error analysis identifies planning errors, extraction errors, and integration errors, with planning errors accounting for about 34% of 100 analyzed failures and entity mislinking described as a major bottleneck for data infilling and column addition (Jiao et al., 28 Oct 2025).

Text-to-SQL systems retain their own structural limitations. Datrics does not specify validators, constrained decoding, or dialect adaptation, and future directions include public benchmarking, broader SQL coverage, and multi-turn query refinement (Gladkykh et al., 3 Apr 2025). xDBTagger does not support nested or subquery forms, set operations, or rich aggregation semantics beyond simple keyword triggers, and its portability to a new database still requires manual annotation of Type and Schema tags (Usta et al., 2022).

Document-oriented extraction systems are bounded by OCR and layout quality. Tablext notes failures involving special characters, adjacent tables with irregular geometry, low-contrast lines, heavy noise, and strong skew, with OCR identified as the most time-consuming stage (Colter et al., 2021). Synthetic benchmark generation exposes a different limitation: narratives can be factually faithful and non-hallucinatory while remaining difficult to parse back into machine-processable key–value pairs. StructText reports exactly this asymmetry, identifying coherence as the bottleneck dimension even when numeric and temporal fidelity are high (Kashyap et al., 28 Jul 2025).

Large-database compression also introduces its own trade-offs. DBCC reports that over-compression can make discriminative audit or status fields less salient, that cross-table keyword inconsistency remains problematic, and that missing or ambiguous external documentation limits evidence purification (Liu et al., 26 Jun 2026). This suggests that compression, like schema abstraction more generally, must remain reversible and query-sensitive.

Several directions recur across the literature: stronger constraint-aware planning, uncertainty estimation, conflict resolution against existing database contents, schema evolution support, multimodal ingestion, interactive clarification, and workload-aware adaptation of schema context (Jiao et al., 28 Oct 2025, Liu et al., 26 Jun 2026). Taken together, these directions indicate that TEXT2DB is converging toward a layered architecture in which extraction, schema understanding, database integrity, and operational explainability are treated as jointly necessary components rather than separable post hoc refinements.