WorksComputer Science
Back to the Future: The Evolving Universal Relation Model
Abstract
Document backed analytics need databases that can be built as queries arrive. Enterprises increasingly ask analytical queries over messy document collections such as contracts, invoices, reports, emails, policies, and tickets, where the relevant structure and facts are often not known in advance. RAG can retrieve and summarize supporting evidence, but it does not by itself produce reusable, joinable, governed database state. Schema first construction offers the opposite strength: once a database is built, it supports joins, aggregation, constraints, indexes, optimization, and transactions. Yet for document analytics, fixing the schema and extracting all possible fields upfront is both expensive and brittle, because later queries and new documents often surface concepts that were not modeled before. We propose the Evolving Universal Relation Model (EUR), a query first model for document backed analytics. Users ask natural language queries as if the document corpus exposed one conceptual relation over application concepts. Internally, the DBMS turns each query into controlled database evolution: it updates the logical schema when new concepts are needed, extracts and integrates the facts required to answer the query, and decides what durable database state should remain for future queries. Thus, in EUR, a query is not only evaluated; it also helps construct the database. Document backed analytics becomes query first universal access plus workload-driven database schema and instance evolution.
Introduction
The next enterprise database starts as documents. Traditional databases start with schemas; document-backed analytics start with queries. In compliance reporting, contract tracking, policy monitoring, and similar settings, users ask over contracts, invoices, reports, emails, policies, and tickets before the right schema is known. These queries are analytical, not merely conversational: they require joins, aggregations, comparisons, and trends. Yet the needed concepts and facts are scattered across messy documents and often become clear only as new queries arrive.
RAG only reads; analytics need databases. Retrieval-augmented generation (RAG) makes document collections searchable and conversational, but it does not provide a database contract. It retrieves evidence into a prompt and produces a response; it does not, by itself, leave behind stable identifiers, typed tuples, relationships, constraints, versions, indexes, or governed provenance. Analytical queries should not repeatedly reconstruct the same facts from text snippets. They need reusable database that can be joined, aggregated, checked, maintained, and optimized.
Schema-first construction freezes the design too early. The natural counter-move is to build the database upfront: declare entities and relationships, design tables, define mappings, and run extractors. This restores familiar DBMS benefits, but only if the schema, mappings, and required facts are already known. Classical models provide the right ideals, but under a schema-first assumption: Entity-Relationship (ER) [4] model captures entities, relationships, attributes, and constraints, while the relational model [5] provides declarative access and data independence over a declared schema. What is missing is a contract that preserves these ideals while the database is still being discovered from documents and queries.
Research gap: database construction should become query-first. Document-backed analytics need a stable query interface over application concepts, while the DBMS is still deciding what tables exist, where attributes belong, which facts to extract, and what durable state to keep. The challenge is not better retrieval alone, nor better upfront extraction alone. It is query-driven database construction: each query may reveal new concepts, require new facts, and improve the reusable database state for future queries.
Pay-as-you-go databases already challenged the need for complete semantic integration before useful access [7, 10]. The question we target is therefore not whether construction can be incremental, but how a DBMS should govern it: when a query requires concepts or facts that are not yet represented, how should the query-facing vocabulary, logical schema, and materialized instance evolve together while preserving logical path independence? Document-backed analytics needs a contract that makes these changes controlled effects of query processing, so that answering a query also builds reusable database state.
Back to the future: The EUR model. We propose the Evolving Universal Relation Model (EUR, pronounced “yur”): a query-first revival of the universal relation model (URM) [14] for document-backed analytics. Users pose queries as if the document collection exposed a single evolving universal relation over application concepts. Internally, the DBMS maintains three coupled levels: an evolving universal relation that defines the user-facing query interface; a logical schema that organizes concepts into entity and relationship tables; and a materialized instance containing extracted, integrated facts. Each query both returns an answer and triggers a controlled database evolution. Unlike schema-on-read, this interpretation is retained as durable database state; unlike schema-first ETL, the design evolves as the workload reveals what is needed.
A Motivating Example
Next, we illustrate EUR with a small course-analytics example. The key point is that a query does not directly create tables. It first reveals application-level vocabulary: attribute roles and semantic connections. EUR merges these revealed roles and connections into the evolving universal relation. The DBMS then derives a logical schema by decomposing this relation according to the semantic connections and (available) functional dependencies. Finally, the system extracts the document-backed facts needed for the current queries and materializes them as reusable database state.
Consider an example about course analytics over a document collection . Suppose contains the following document snippet.
Text snippet: In 2026, the CS department in the School of Engineering offers CS101, titled Introduction to AI, and CS201, titled Database Systems. CS101 has 3 credits, and CS201 has 4 credits. Alice Sara is a CS major and takes both CS101 and CS201.
A workload with two queries arrive over time:
For simplicity, let’s assume that initially, the database is empty.
First Query: Revealing the Course World
Query asks for courses, but it also mentions the conditions under which those courses should be selected: department, school, and year. The system therefore begins by identifying the attribute roles and semantic connections needed to interpret the query.
Attribute roles and semantic connections. The query reveals five attribute roles:
The query also reveals semantic connections among these roles, represented as predicates over subsets of the attribute roles:
Universal relation. The revealed roles and semantic connections are merged into the first query-facing universal relation w.r.t. [14]. is a conceptual relation, not a stored wide table:
It lets the query refer to without exposing how the DBMS will later organize these roles into tables. Under , the query is interpreted below, which is independent of any particular table decomposition:
The query has revealed the application vocabulary needed to answer it. At this stage, the system knows what concepts exist, but not yet how they should be organized into relational tables.
Logical schema. After is established, the DBMS chooses a logical schema underneath it. The design is not obtained by creating one table per attribute role. Instead, the DBMS decomposes the universal relation according to the semantic connections and (available) functional dependencies as:
Here, Course and Department are entity tables, while Offers is a relationship table. The attribute OfferingYear is placed in Offers because it describes a department-course offering.
This separation is why EUR keeps the universal relation distinct from the logical schema. is the user-facing query interface: it presents concepts and predicates without exposing tables or join paths. is the DBMS-facing design: it decomposes those concepts into entity and relationship tables for better management.
Materialized instance. The logical schema specifies what the DBMS can store, but the database is still empty. The system therefore identifies the materialization gap: the facts required to answer that are missing from the initial database instance . It then extracts and integrates those facts from the document snippet, producing the materialized instance , as shown in Figure 1(b).
Figure 1. Sample database evolution guided by queries.
Second Query: Reusing and Extending State
Query asks which of the courses identified by Alice Sara takes, and how many credits each course has. The query therefore reuses part of the database produced by : the course role and the course-offering scope already materialized in . At the same time, it reveals new information about students, enrollments, and course credits. As before, the system first interprets the query as attribute roles and semantic connections.
New attribute roles and semantic connections. The query reuses course role from and reveals three new attribute roles:
The new roles , , and are additional attributes over which the second query is interpreted.
Query also reveals new semantic connections as predicates:
Thus, extends the application vocabulary of from courses and offerings to students, enrollments, and credits.
Evolving universal relation. The newly revealed roles and predicates are merged with the existing universal relation. The resulting universal relation w.r.t. extends as:
The universal relation is again the query-facing interpretation of the workload. The user asks over the attributes together with the previously revealed course-offering attributes. The DBMS hides whether those roles are implemented by extending an existing table, creating a new entity table, or adding a relationship table.
Evolving logical schema. After is established, the DBMS extends the logical schema underneath it. The design reuses the entity and relationship tables from and adds only what is needed for the new query, annotated by .
This shows how schema evolution is driven by the query but mediated through the universal relation. manages the expanded query-facing attributes and predicates, while is one DBMS-chosen decomposition into entity and relationship tables.
Evolving materialized instance. The updated logical schema says what can be stored, but not all needed facts have been materialized yet. The database can reuse the course, department, and offering facts already extracted for . It only needs to extract the facts newly required by : course credits, student record, and the enrollment facts. Given the above requirement, the system then extracts required facts as shown in Figure 1(c).
The EUR Model
Classical Universal Relation Model (URM) assumes that the universal relation is defined upfront by its predicates and dependencies [14]. Our proposed Evolving Universal Model (EUR) keeps the one-relation interface, but changes how that relation is built: instead of requiring the full design before querying, the database evolves as queries arrive over the document collection. We now make this precise.
Evolution step. The EUR model captures application-bounded, query-driven evolution for document-backed databases. Given a coherent application , a document collection 1, and an evolving workload , EUR treats each workload increment as both a query to answer and a controlled database evolution step:
The application is the boundary of evolution: it defines the recurring intents, answer forms, governance rules, and evidence standards that make change controlled rather than open-ended. A workload increment may be a natural-language query, a batch of related queries, or an emerging query pattern. It is interpreted over application concepts, not over the tables that happen to exist.
Database state. After processing , the database state is:
Here, is the evolving universal relation: the user-facing conceptual relation. is the evolving logical design, organized into entity and relationship schemas. is the materialized instance extracted and integrated from documents.
Three coupled levels. As shown in Figure 2, each transition
Figure 2. Query-driven database evolution.
is implemented through three coupled levels: (1) Reveal: expose new attribute roles, concepts, predicates, and semantic connections, thereby evolving to ; (2) Organize: place the revealed concepts into entity and relationship schemas, thereby evolving to ; and (3) Materialize: extract, reconcile, validate, and store document-backed facts, thereby evolving to .
Thus, users continue to ask over a conceptual universal relation, while the DBMS evolves the universal relation, logical design, and materialized instance underneath.
Answer plus durable evolution. Each step has two outcomes: an answer to the current query and an updated durable database state . Existing Text-to-SQL [11] techniques can help produce the answer once the needed schema and facts are available. The distinctive role of EUR is to decide what state the query should induce when the needed roles, schemas, or facts are missing.
Latent limit state. For application , document collection , and long-running workload , the transition sequence
can be viewed as revealing finite approximations to an eventual application-bounded latent state . Here, denotes the latent universal relation: the semantic closure of the attribute roles and connections that the workload would eventually make relevant under . Each finite state is the governed approximation reached after the prefix , and each query decides which part of the latent state to start revealing, organizing, and materializing now.
Starting assumptions. An EUR database may start from either an initial database or an empty database. In production, applications often provide partial schemas, mappings, extracted facts, or coverage metadata upfront; this initializes some of , , and .
Reveal, Organize, Materialize
As shown in Figure below, each query is handled as a controlled evolution step with three parts. First, EUR reveals the concepts needed to understand the query. Second, it organizes those concepts into entity and relationship schemas. Third, it materializes the missing document-backed facts needed to answer the query.

Figure 3 (PDF p. 4).
Reveal: The Universal Relation Grows
At step , is the conceptual relation exposed to users. It records the query-facing vocabulary revealed so far: attribute roles that can be returned, filtered, grouped, or aggregated, and semantic connections that explain how those roles belong together. It is not a stored wide table and not the logical schema.
Query-revealed roles and connections. When arrives, EUR identifies additional roles and connections needed to interpret it:
The delta may introduce missing roles and connections, or reuse and refine concepts already present in .
Universal relation transition. The revealed delta is semantically merged into the accumulated universal relation:
The merge resolves aliases, reused concepts, compatible predicates, refined meanings, and provenance-related roles under the application interpretation policy. The result is the updated query-facing contract; storage decisions are deferred to the logical-schema step.
Organize: Roles Become Relations
The universal relation is the application-facing query contract. The logical schema is the DBMS-facing organization of that contract. As grows, EUR places revealed roles and semantic connections into entity and relationship schemas.
Incremental normalization. In traditional databases, normalization decomposes a known wide relation into smaller tables around entities and relationships. In EUR, this organization is incremental, because the universal relation and the evidence behind it arrive over time. Semantic connections in , together with available functional dependencies, guide whether a revealed role becomes an entity attribute, a relationship attribute, a key/foreign-key role, or part of a new relationship schema.
Given , the updated universal relation , and the newly revealed delta , EUR computes the schema delta:
It then applies this delta to obtain the updated logical schema:
Here, is the set of entity-table schemas and is the set of relationship-table schemas after step . In the monotonic version considered here, EUR only extends the schema by introducing entities, attributes, or relationships. More general evolution may revise earlier choices, such as moving attributes across tables or splitting and merging schemas; such changes require schema mappings and instance migration across versions.
Materialize: Gaps Become Facts
After determines what users can ask and determines how those roles and connections are organized, the instance must contain enough document-backed facts to support . Materialization is the execution side of evolution: the query exposes what is missing, and the system turns that gap into extracted, integrated, and reusable state.
Materialization gaps. Given the evolved schema and the previous instance, EUR derives a materialization gap and passes it to the document-to-database extraction layer:
Here, specifies the missing role values, entity tuples, relationship tuples, predicate regions, or evidence obligations needed to answer under the evolved universal relation and schema. The instance delta contains newly extracted and reconciled facts over , together with the evidence and provenance metadata needed to justify them.
Materialization boundary and policy. EUR decides what the query reveals and how it changes and ; the document-to-database layer decides how to close the resulting gap in . DataMosaic [15] studies how new queries and document updates trigger extraction, reconciliation, validation, and integration of facts.
Two materialization policies bracket the cost-reuse tradeoff. A schema-complete policy extracts all facts for newly revealed schema fragments, maximizing future reuse but risking over-extraction. A query-guided policy extracts only what is needed to answer while leaving behind useful reusable facts. Detailed extraction planning is left to the document-to-database layer.
Database Principles, Rewired
EUR does not discard classical database principles; it changes when they must operate. Documents provide the evidence; workloads provide the design signal. A DBMS must connect the two while preserving the principles that still matter: identity, logical path independence, physical data independence, optimization, provenance, constraints, and transactions. In EUR, the contract changes from managing a mostly fixed database to managing the transition as part of query processing. The universal relation, the logical entity/relationship design, the materialized instance, and the coverage state must evolve with the workload, while users continue to ask over a stable conceptual interface.
What Databases Already Got Right
Database systems already provide much of what document-backed analytics lacks. Chen’s ER model gives a language for stable entities, relationships, attributes, and constraints [4]. Codd’s relational model separates logical access from physical representation and access paths [5]. Ullman’s Universal Relation Model (URM) adds the user-facing ideal of logical path independence: users query attributes and predicates without choosing stored relations or join paths [14]. Together, these ideas express the contract that EUR inherits: users should ask about application concepts, while the DBMS manages logical design and physical access underneath.
This separation is exactly what document-backed applications need, but under a different timing assumption. Recent work argues that DBMSs should elevate ER concepts as first-class abstractions [6], which aligns with EUR: document analytics needs stable things, relationships, identifiers, constraints, and provenance, not merely text chunks, prompt contexts, or flat extracted tables. Relational systems also provide the execution discipline needed once state exists. Cost-based optimization [12], query answering using views and data integration [8], and provenance management [3] are all directly relevant to EUR. Text-to-SQL [11] techniques can help answer the current query once the needed schema and facts are available. The distinctive problem in EUR is what happens when they are not available: the query must also induce universal-relation fragments, logical schema deltas, materialization gaps, extraction tasks, and durable state for future use.
Relation to pay-as-you-go. Dataspaces and PAYGO established that useful access need not wait for complete semantic integration, and that integration effort should be invested incrementally as needs emerge [7, 10]. EUR shares this philosophy but targets a specific database-model question. Whereas PAYGO addresses web-scale heterogeneity through schema clusters, approximate mappings, and query routing, EUR targets application-bounded document analytics through an evolving universal relation. Each workload increment may jointly extend the query-facing vocabulary, reorganize its logical representation, and materialize missing facts. These changes are coupled effects of query processing, not independent improvements to source integration. EUR thus specializes the pay-as-you-go philosophy into a model and systems agenda for governing the database state that queries leave behind.
Why Schema-First Breaks
Classical DBMS contracts are schema-first. A catalog records relations after they are declared; an optimizer chooses plans over existing tables and indexes; storage assumes known layouts; maintenance begins from base data already inside the system. EUR changes this order. A workload increment may reveal a new attribute, add an entity type, extend an existing entity, introduce a relationship table, or require facts that have not yet been extracted from documents. The user should not have to follow these changes. Logical path independence means that the user continues to ask over the conceptual application domain, while the DBMS decides how concepts map to evolving tables, joins, stored facts, and coverage state.
The individual actions are not exotic. SQL already supports table creation, schema alteration, tuple insertion, and merge. EUR therefore does not require a new storage substrate merely to represent evolving tables. The challenge is control: today these operations are treated as occasional administrative changes or ordinary transactional writes, not as planned effects of query processing. Current DBMSs are not optimized for workloads in which queries repeatedly trigger small schema changes, document extraction jobs, new relationship tables, coverage updates, and new physical access paths.
Thus familiar components must be reinterpreted. The catalog must become an evolution catalog: it must record not only schemas, but also universal-relation roles, aliases, workload-induced scopes, schema versions, document mappings, materialization coverage, provenance, and confidence. Storage engines must support schemas whose attributes and relationships are discovered gradually. Record layouts, column files, compression dictionaries, statistics, and metadata generally assume that columns are declared first and changed infrequently. In EUR, adding attributes, creating relationship tables, backfilling columns, and reorganizing stored state become normal execution events rather than rare administrative operations.
Indexing exposes the same mismatch. Classical indexes such as -trees are excellent for range predicates over stable attributes, but they are not designed for attributes, tuples, and relationships discovered on demand. Creating, updating, and discarding indexes over newly extracted columns may cost more than the query they support. The optimizer must therefore choose among reuse, natural-language-to-query compilation over existing state, universal-relation evolution, logical schema evolution, extraction, validation, indexing, and over-materialization. Its cost model must account not only for disk I/O and CPU, but also for extraction cost, uncertainty, coverage gaps, and expected future reuse.
Evolution as the New DBMS Primitive
In EUR, a query should not merely consume an existing database; it should help shape the database that ought to exist. Each query exposes a small part of the application world, and the DBMS turns that exposure into lasting conceptual, logical, and materialized state. The user continues to ask over stable application concepts, while the system quietly lets the universal relation, schema, facts, coverage, and access structures grow with the workload.
This vision also repositions document extraction. The document-to-database layer is not an offline ETL stage, but the mechanism by which missing evidence becomes governed database state [15]. A query is complete only when it returns an answer and leaves behind reusable, validated, and accountable state for future queries.
The Stack That Evolves
We now turn the model contract into a systems agenda: what DBMS stack should manage when the universal relation, logical schema, and materialized instance are all evolving?
Storage for sparse, evolving coverage. Logical path independence is useful only if the physical layer can absorb evolution without exposing it to users. Row-oriented storage is a poor fit when attributes are added frequently and coverage is partial: adding an attribute may require changing layouts, rewriting records, refreshing statistics, and distinguishing true nulls from values not yet extracted. Columnar storage is a more natural starting point: newly revealed attributes can be appended as columns, missing values can remain sparse, and queries can scan only the attributes in scope. The columnar designs of C-Store [13] and MonetDB [2] provide useful foundations. The open problem is to adapt column storage to evolving coverage: columns may be materialized only for selected entities, documents, or workload scopes, and backfilled later with provenance links and coverage metadata.
Indexes that follow the workload. Hash indexes remain useful for point lookups and key-based joins, and B⁺-trees remain attractive for range predicates over stable attributes. But EUR creates a different regime: attributes, tuples, and relationships are discovered on demand, and a newly extracted column may be useful for only a few queries. Building, updating, and discarding indexes may cost more than the query they support. Packed-memory-array layouts, as used in cache-oblivious indexing [1], reduce reorganization cost under insertions, while database cracking [9] incrementally reorganizes columns as queries arrive. EUR needs adaptive indexes that track workload-induced scopes, partial coverage, universal-relation predicates, and expected reuse as part of the evolution plan.
Optimization as evolution planning. The optimizer cannot be only an access-path selector over fixed base tables. It must choose among answering over existing state, compiling natural language to queries, extending the universal relation, evolving the logical schema, extracting missing facts, building indexes, and over-materializing for reuse. Optimization therefore becomes a joint problem of query planning and evolution planning: the plan decides not only how to compute the answer, but also what durable state should remain afterward. The cost model must include document retrieval, LLM calls, extraction failures, validation, entity resolution, index maintenance, schema migration, coverage updates, and expected reuse, in addition to I/O and CPU. The objective is no longer cheapest current execution; it is cheapest useful evolution.
Normalization when meanings arrive late. In classical design, many-to-many relationships normally become relationship tables, while one-to-one and many-to-one relationships are often represented as attributes or foreign keys. In EUR, the cardinality and meaning of a relationship may not be known when it first appears in the universal relation. A system may initially materialize relationships uniformly as relationship tables; later workloads may reveal that some should collapse into entity attributes or foreign keys, while others should become richer relationship entities. The research problem is safe normalization and denormalization over partially materialized data while preserving provenance, coverage, schema versions, and previously answered-query semantics.
Continuous cleaning and constraints. Data quality problems are amplified when facts are extracted incrementally from heterogeneous evidence. Extracted tuples may be duplicated, incomplete, contradictory, or expressed in incompatible units and formats. Normalization, transformation, entity resolution, and constraint checking therefore become continuous operations rather than one-time cleaning steps. Constraints must distinguish database violations from evidence uncertainty: a key conflict may indicate a duplicate, an extraction error, an ambiguous entity, or genuinely conflicting evidence. EUR needs constraints that govern both schema evolution and materialized facts while preserving provenance and evidence.
Extraction as a physical operator. Extraction should not be an offline ETL script placed before the database. It should be a first-class physical operator whose input is a materialization gap and whose output is typed tuples, provenance, confidence, coverage updates, and failures [15]. This operator must support projection pushdown, predicate pushdown, batching, entity resolution, validation, and incremental maintenance. Treating extraction as an operator gives the optimizer something concrete to cost, reorder, cache, and combine with relational operators, while making missing evidence, conflicting evidence, and low-confidence values explicit outputs rather than hidden prompt artifacts.
Transactions over data and evolution. Transaction management must be revisited. In EUR, many writes may run concurrently: universal-relation changes add roles, schema-evolution actions add attributes or relationship tables, extraction jobs add tuples, validation jobs repair values, and user queries may read partially materialized state. The system needs isolation levels for evolving databases: should a query see freshly extracted tuples before validation, should related universal-relation, schema, and tuple deltas commit atomically, and should failed extraction calls roll back or leave partial evidence? Without such semantics, the same natural-language workload may produce non-repeatable answers, inconsistent coverage, and irreproducible schema states.
Semantic operators for multimodal evidence. EUR needs semantic operators that treat interpretation itself as part of query processing. Document collections mix text, tables, forms, figures, screenshots, and images; a query may require reading a clause, locating a table cell, comparing a chart, or linking a visual region to an entity. These operations should become typed operators with inputs, outputs, costs, confidence, provenance, and failure modes, so the optimizer can combine them with relational operators and the system can materialize their results as reusable state.
Conclusion
RAG made documents searchable; EUR asks the database question: what durable, governed state should each query leave behind? The answer is not a schema-first replica of the corpus, but a query-shaped database whose universal relation, logical schema, materialized facts, coverage, indexes, and constraints evolve together while preserving logical path independence for users. The agenda is clear: make evolution—universal-relation deltas, schema deltas, extraction deltas, coverage deltas, validation, indexing, and transactions—a first-class DBMS operation.
References
- [1]Michael A. Bender, Erik D. Demaine, and Martin Farach-Colton. 2005. Cache-Oblivious B-Trees. SIAM J. Comput. 35, 2 (2005), 341–358.
- [2]Peter A. Boncz, Martin L. Kersten, and Stefan Manegold. 2008. Breaking the memory wall in MonetDB. Commun. ACM 51, 12 (2008), 77–85.
- [3]Peter Buneman, Sanjeev Khanna, and Wang-Chiew Tan. 2001. Why and Where: A Characterization of Data Provenance. In ICDT.
- [4]Peter Pin-Shan Chen. 1976. The Entity-Relationship Model: Toward a Unified View of Data. ACM Transactions on Database Systems 1, 1 (1976), 9–36.
- [5]E. F. Codd. 1970. A Relational Model of Data for Large Shared Data Banks. Commun. ACM 13, 6 (1970), 377–387.
- [6]Amol Deshpande. 2025. Beyond Relations: A Case for Elevating to the Entity-Relationship Abstraction. https://www.cidrdbr.org/cidr2025/papers/p11-deshpande.pdf. CIDR 2025.
- [7]Michael J. Franklin, Alon Y. Halevy, and David Maier. 2005. From databases to dataspaces: a new abstraction for information management. SIGMOD Rec. 34, 4 (2005), 27–33.
- [8]Alon Y. Halevy. 2001. Answering Queries Using Views: A Survey. The VLDB Journal 10, 4 (2001), 270–294.
- [9]Stratos Idreos, Martin L. Kersten, and Stefan Manegold. 2007. Database Cracking. In CIDR.
- [10]Shawn R. Jeffery, Michael J. Franklin, and Alon Y. Halevy. 2008. Pay-as-you-go User Feedback for Database Systems. In Proceedings of the ACM SIGMOD International Conference on Management of Data (SIGMOD ’08). Association for Computing Machinery, 847–860.
- [11]Xinyu Liu, Shuyu Shen, Boyan Li, Peixian Ma, Runzhi Jiang, Yuxin Zhang, Ju Fan, Guoliang Li, Nan Tang, and Yuyu Luo. 2025. A Survey of Text-to-SQL in the Era of LLMs: Where Are We, and Where Are We Going? IEEE Trans. Knowl. Data Eng. 37, 10 (2025), 5735–5754.
- [12]P. Griffiths Selinger, M. M. Astrahan, D. D. Chamberlin, R. A. Lorie, and T. G. Price. 1979. Access Path Selection in a Relational Database Management System. In SIGMOD.
- [13]Michael Stonebraker, Daniel J. Abadi, Adam Batkin, Xuedong Chen, Mitch Cherniack, Miguel Ferreira, Edmond Lau, Amerson Lin, Samuel R. Madden, Elizabeth O’Neil, Patrick E. O’Neil, Alexander Rasin, Nga Tran, and Stanley B. Zdonik. 2005. C-Store: A Column-Oriented DBMS. In VLDB.
- [14]Jeffrey D. Ullman. 1982. The U. R. Strikes Back. In PODS.
- [15]Zhengxuan Zhang, Zhuowen Liang, Jiazhuo Chen, Haixuan Wang, and Nan Tang. 2026. Document-to-Database: Extraction Meets Relational Semantics. PVLDB. (2026).

