Ontology-Based Data Access (OBDA)

• Ontology-Based Data Access (OBDA) is a paradigm linking heterogeneous data sources to a shared ontology through declarative mappings.
• It separates data storage from conceptual access with a three-layer architecture: data sources, ontology, and mapping assertions.
• Recent advances extend OBDA with query rewriting, graph and streaming support, and learning-assisted ontology population for optimized performance.

Searching arXiv for recent and foundational work on OBDA to ground the article in current literature. Ontology-Based Data Access (OBDA) is a paradigm in which data sources are connected to an ontology by declarative mappings, so that users query a shared conceptual vocabulary rather than source schemas directly. In the standard formulation, an OBDA system is “composed of three main levels”: data sources, ontology, and mappings; semantically, an OBDA specification $$\mathcal{P}=\langle \mathcal{T},\mathcal{M},\mathcal{S}\rangle$$ generates, for each database instance $D$, a virtual ABox $A_{\mathcal{M},D}$, and query answering is defined by certain answers $$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$ (Calautti et al., 2024, Botoeva et al., 2015). This architecture has made OBDA a central approach to ontology-mediated querying over heterogeneous relational data, while later work has extended it toward richer mappings, graph and streaming backends, provenance, bag semantics, and learning-assisted ontology population.

1. Core architecture and semantics

At its most canonical, OBDA separates extensional storage from intensional access. The ontology supplies the conceptual schema and shared vocabulary; the mappings specify how source tuples are transformed into ontology predicates; and users query only at the ontology level. In one standard formalization, mapping assertions have the form

$$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$

where $A$ is a concept name, $P$ a role name, and $\varphi,\varphi'$ are SQL queries over the source schema (Botoeva et al., 2015). In another standard presentation, an OBDA mapping is written

$$\Phi(\vec{x}) \rightsquigarrow \Psi(\vec{y}, \vec{t}),$$

with $\Phi(\vec{x})$ a conjunctive query over the source schema and $D$0 a conjunctive query over the ontology alphabet (Namici, 2018).

The virtual ABox viewpoint is fundamental. Given a database $D$1, mappings induce

$D$2

so ontology-mediated answering is not performed over raw source tuples but over ontology facts virtually generated from them (Botoeva et al., 2015). In RDF-oriented implementations, this same mechanism is often described as the generation of a virtual RDF graph (Namici, 2018).

A concrete example illustrates the workflow. A tabular source may contain device records with descriptions; a mapping detects rows whose description contains “Circuit Breaker” and produces a triple

$D$3

from source tuples of the form

$D$4

Users can then issue SPARQL queries such as

$D$5

while the OBDA system translates them transparently over the integrated data layer (Calautti et al., 2024).

This division between ontology, mappings, and sources is sometimes described in TBox/ABox terms. The ontology corresponds to the conceptual layer; mapped assertions form an ABox-like population; and mappings are the semantic bridge from external schemas to ontology facts. A recurrent theme in later OBDA work is that the power, cost, and limitations of the paradigm are largely determined by how much semantics is kept in the ontology, how much is compiled into mappings, and how efficiently the resulting ontology-mediated queries can be translated to source-level evaluation (Botoeva et al., 2015).

2. Rewriting-centered query answering

The classical computational appeal of OBDA lies in rewriting. Query answering is reduced to ordinary database evaluation by compiling ontology reasoning into a new query. In the rewriting-based view,

$D$6

for all databases $D$7 and tuples $D$8, where $D$9 is a rewriting that can be evaluated without direct use of the ontology (Podolskii, 2015). This is why DL-Lite$A_{\mathcal{M},D}$0, the logic underpinning OWL 2 QL, has been the “current language of choice” for OBDA: it was designed to guarantee first-order rewritability and to delegate query answering to the underlying relational engine (Botoeva et al., 2015).

The price is limited ontology expressivity. DL-Lite does not naturally express disjunctive information or recursive existential patterns such as

$A_{\mathcal{M},D}$1

which already fall outside the fragment (Botoeva et al., 2015). One response has been to rewrite not only queries, but whole OBDA specifications. In “Beyond OWL 2 QL in OBDA,” expressive Horn ontologies are transformed into DL-Lite specifications by pushing part of the ontology semantics into the mapping layer via Datalog compilation and ET-mappings. The core exactness criterion is $A_{\mathcal{M},D}$2-CQ inseparability, and the central result states that if $A_{\mathcal{M},D}$3, then

$A_{\mathcal{M},D}$4

are $A_{\mathcal{M},D}$5-CQ inseparable for $A_{\mathcal{M},D}$6 (Botoeva et al., 2015).

The rewriting literature also shows that logical reducibility does not imply succinctness. A circuit-complexity analysis of OBDA rewritings established sharp distinctions between FO-, PE-, and NDL-rewritings. For general conjunctive queries and arbitrary-depth ontologies, PE-rewritings may require exponential size, NDL-rewritings may require exponential size, and polynomial-size FO-rewritings need not exist unless $A_{\mathcal{M},D}$7. By contrast, for linear or tree-like queries with depth-1 ontologies, polynomial-size rewritings exist in all three formalisms (Podolskii, 2015). The practical implication is that “first-order rewritable” does not, by itself, guarantee an evaluable translation.

3. Expressive power, verification, and reverse reformulation

A foundational line of work treats ontology-mediated queries as query languages in their own right. For UCQ-based OMQs, $A_{\mathcal{M},D}$8 has the same expressive power as monadic disjunctive Datalog, and the same framework establishes tight links with CSP, coMMSNP, and query containment (Bienvenu et al., 2013). These characterizations show that OBDA is not merely a methodology for engineering semantic views over databases; it also sits at a precise location in descriptive complexity.

Within deployed OBDA systems, an important practical issue is whether an ontology-and-mapping layer already supports a desired source query. “Query Expressibility and Verification in Ontology-Based Data Access” formalizes this through source-side expressibility and target-side verification. For GAV mappings and (U)CQs, both problems are $A_{\mathcal{M},D}$9-complete in DL-Lite; between $$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$0 and $$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$1, they are coNExpTime-complete for rooted source queries and 2ExpTime-complete for unrestricted ones (Lutz et al., 2020). These results make explicit that OBDA bootstrapping and maintenance are themselves nontrivial reasoning problems.

A newer development studies the reverse of classical rewriting: not ontology query $$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$2 source query, but source query $$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$3 ontology query. In the existential-rule setting $$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$4, a source query $$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$5 may admit a complete, sound, or perfect ontology abstraction $$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$6, depending on whether

$$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$7

or both, hold for all $$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$8 (Leclère et al., 23 Jun 2026). Perfect abstractions often fail because mappings lose answer variables or collapse source distinctions, so the theory introduces minimally complete and maximally sound abstractions. A central result is that the language $$cert(q,\mathcal{P},D)=cert(q,\langle \mathcal{T},A_{\mathcal{M},D}\rangle)$$9, which extends UCQs with a restricted inequality predicate and a predicate $$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$0 marking database constants, expresses all minimally complete abstractions and hence all perfect abstractions when they exist. Maximally sound abstractions are characterized via maximum recovery from data exchange (Leclère et al., 23 Jun 2026). This establishes reverse reformulation as a distinct branch of OBDA theory rather than a trivial inversion of classical rewriting.

4. Mappings, standards, and optimization

Mappings are not only the semantic bridge of OBDA; they are also its main optimization surface. Standardization has concentrated on R2RML, the W3C recommendation for expressing mappings from relational databases to RDF datasets. In interoperable OBDA settings, OWL 2 provides the ontology language, SPARQL the query language, R2RML the mapping language, and relational databases the sources. R2RML support in Mastro enabled direct comparison with Ontop on shared OBDA specifications, but the same study also showed that mapping portability and performance portability are not identical: arbitrary Mastro view conjunctions and view constraints cannot be represented in R2RML without loss of efficiency (Namici, 2018).

Optimization beyond ordinary database keys and foreign keys requires OBDA-native constraints. “OBDA Constraints for Effective Query Answering” introduces two such notions: exact predicates and virtual functional dependencies. Exact predicates state that ontology reasoning does not add new answers beyond the mappings already defining a predicate, which allows redundant unions in $$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$1-mappings to be pruned. Virtual functional dependencies are constraints over the virtual RDF graph generated by mappings and ontology; they allow elimination of redundant joins, especially self-joins produced when several RDF properties are extracted from the same underlying table or view (Hovland et al., 2016). The paper proves that these optimizations preserve the exposed graph or the SQL answers, and reports substantial reductions in SQL size, unfolding time, and timeouts.

A complementary optimization line argues that even the shape of the final SQL matters. “Cost-Driven Ontology-Based Data Access” shows that translating to UCQs is not always the best choice. Alternative translations, especially cover-based JUCQ rewritings, can be “orders of magnitude more efficient” under suitable conditions on ontology, mappings, and source statistics. To choose between equivalent translations, the paper introduces a cost model with OBDA-specific cardinality estimation that accounts jointly for ontology, mappings, and data (Lanti et al., 2017). The significance is methodological: the best OBDA translation is not determined solely by logical equivalence, but by the interaction between rewriting structure and relational cost.

The mapping layer has also been generalized beyond monotonic first-order implications. In an ASP-based framework for GLAV mappings, rule bodies may contain positive and negative ontology queries, enabling defaults, exceptions, and extensional constraints in the mapping layer itself. The resulting “mapping programs” support ontology-aware exceptions, but unrestricted reasoning is undecidable; under suitable restrictions, $$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$2-answer set existence is NP$$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$3-complete, where $$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$4 captures ontology entailment (Lupp et al., 2016). This marks a boundary between classical OBDA mappings and nonmonotonic mapping semantics.

5. Semantic and computational extensions

Several extensions depart from the classical set-based, relational, static picture of OBDA. One concerns duplicates. Under bag semantics, mappings retain duplicate tuples “as is the case in standard databases,” which is essential for database-style aggregates. This changes the computational landscape sharply: conjunctive query answering becomes coNP-hard in data complexity even for $$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$5. A positive result survives for rooted CQs, which admit a canonical universal bag model and rewritability to $$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$6-queries, a bag generalization of relational calculus (Nikolaou et al., 2017).

Another extension concerns explanation. Provenance-aware OBDA enriches source tuples, mappings, and ontology axioms with semiring annotations. For a Boolean CQ $$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$7, provenance is computed as

$$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$8

so derivations are represented algebraically as products and sums of source, mapping, and ontology annotations (Calvanese et al., 2019). A distinctive result is that these provenance polynomials may be infinite because ontology reasoning can generate infinitely many derivations; finiteness is recovered under idempotent semirings. Combined complexity of provenance-annotated query answering is NP-complete for the DL-Lite setting studied (Calvanese et al., 2019).

Streaming and analytical OBDA relax the assumption that sources are static. An analytics-aware extension of DL-Lite introduces aggregate concepts

$$\varphi(x)\leadsto A(x) \qquad\text{or}\qquad \varphi'(x,x')\leadsto P(x,x'),$$9

treats aggregates as first-class ontology constructs, and combines static and streaming data through STARQL and SQL$A$0-level unfolding (Kharlamov et al., 2016). The same line adds Materialised Window Signatures and cost-aware execution over live and archived streams. Related work on streams with application time does not modify OBDA semantics directly, but gives criteria for deciding whether an unfolded select-project-join stream query can be evaluated in constant space; this is proposed as a way to judge bounded-memory feasibility after the standard OBDA rewriting-and-unfolding pipeline (Schiff et al., 2020).

OBDA has also moved beyond relational backends. For property graphs, a rewriting framework over a restricted fragment of $A$1 rewrites navigational NCQs into UC2RPQs and then into Cypher, showing that graph-native OBDA need not remain confined to DL-Lite or to conjunctive relational queries. The main correctness theorem states that for every ABox $A$2, tuples are certain answers to the ontology-mediated NCQ iff they are answers to the rewritten query over $A$3 (Löhnert et al., 2024).

6. Systems, applications, and empirical evaluation

OBDA has produced a diverse systems ecosystem. OntoProx rewrites Horn ontologies and mappings into DL-Lite specifications; Aber-OWL provides ontology-based semantic access to biological data and literature by computing inferred class sets from Manchester OWL queries and injecting them into literature or SPARQL retrieval (Botoeva et al., 2015, Hoehndorf et al., 2014). OntoProv extends Ontop with provenance, and ExaStream provides a backend for analytics-aware OBDA over streams (Calvanese et al., 2019, Kharlamov et al., 2016).

Applied deployments show that OBDA’s practical bottlenecks are often upstream of reasoning proper. In renewable energy, MLA-OBDA augments a traditional OBDA stack with a machine-learning component inserted “between the data sources and the data mappings.” The goal is not probabilistic query answering, but ontology population from fragmented, weakly structured source descriptions. The framework uses dynamic class management over ontology hierarchies: fix $A$4, choose a threshold $A$5, repeatedly replace underrepresented class $A$6 by its parent $A$7, then train a classifier on the coarsened label set (Calautti et al., 2024). On industrial data with 50,125 text entries, BERT with dynamic class management improved BL1 macro F1 from $A$8 to $A$9 and BL2 macro F1 from $P$0 to $P$1, while weighted F1 changed little (Calautti et al., 2024). The broader implication is explicit in the paper: classical OBDA does not solve ABox acquisition from weakly structured sources.

Benchmarking has likewise become OBDA-specific. VIG is a data scaler for OBDA benchmarks that uses mappings and ontology information to preserve OBDA-relevant properties such as fixed-domain values, mapping-induced joins, and certain disjointness effects, while generating each value in constant time (Lanti et al., 2016). It is currently used in the NPD benchmark and is designed to produce CSV output importable into any RDBMS (Lanti et al., 2016). This reflects a wider trend: OBDA evaluation increasingly depends on preserving not only schema shape, but also the semantic structure induced by mappings and ontologies.

Across these systems and applications, several recurrent open issues remain. Exact finite rewritings may not exist; bag semantics and provenance weaken classical tractability; graph and streaming settings require query languages beyond UCQs; and practical deployments often need constraints, source-aware cost models, or learning-based ontology population. This suggests that OBDA is no longer a single rewriting technique, but a family of architectures organized around a shared principle: conceptual access through ontologies, with mappings mediating between logical vocabulary and operational data systems.