In large-scale enterprises and scientific domains, data is rarely stored in a single, clean format. Instead, it is trapped across heterogeneous relational databases, legacy systems, and streaming architectures. For domain experts—such as engineers diagnosing gas turbines or geologists analyzing oil fields—accessing this data requires navigating cryptic database schemas and writing complex SQL joins. As a result, data discovery and gathering can consume up to 70% to 80% of a practitioner's workday.
The traditional solution to this problem is physical data migration (ETL): extracting data from various sources, transforming it into a unified format (like RDF graphs), and loading it into a centralized repository. However, for massive or high-velocity industrial datasets, physical migration introduces severe storage redundancy, high computational overhead, and the risk of serving stale data.
Ontology-Based Data Access (OBDA), often realized via Virtual Knowledge Graphs (VKGs), solves this dilemma by moving the query to the data rather than the data to the query. It introduces a virtual semantic abstraction layer over existing data stores, allowing users to query data using familiar, high-level domain concepts while leaving the underlying data exactly where it is.
The Three-Tier Architecture
To understand why this approach works, we must look at its three core components: the conceptual ontology, the physical data sources, and the declarative mappings that connect them.
[ User / Application ]
│
▼ (SPARQL Query)
┌───────────────────────────┐
│ Semantic Ontology │ <-- High-level domain concepts
├───────────────────────────┤
│ Mapping Layer │ <-- Translates graph to SQL/Native
└───────────────────────────┘
│
▼ (Optimized SQL)
┌───────────────────────────┐
│ Physical Data Sources │ <-- Legacy RDBMS, Streams, etc.
└───────────────────────────┘
1. The Semantic Ontology
The ontology serves as a unified, conceptual vocabulary for the domain. Instead of interacting with specific table names and primary keys, users interact with classes (e.g., Turbine, Measurement) and properties (e.g., hasTemperature). As shown by Martin Giese et al. in the context of industrial big data, this abstraction completely masks underlying database complexities, allowing non-technical users to formulate queries using domain-specific terminology.
2. The Physical Data Sources
These are the underlying legacy systems—typically relational databases (RDBMS) or columnar files—that excel at high-performance storage and retrieval. By keeping these systems intact, the VKG approach leverages decades of database optimization without incurring migration costs.
3. The Mapping Layer
The magic of virtualization happens in the mapping layer. Mappings are declarative rules (often using a Global-As-View strategy) that link specific database queries to ontological terms. For example, a mapping might state: “For every row in the sensor_metadata table where type='temp', create a semantic instance of the class TemperatureSensor.”
Query Unfolding: How Virtualization Works
The core mechanism that makes a Virtual Knowledge Graph functional is query unfolding. When a user executes a graph query (typically written in SPARQL), the OBDA engine does not evaluate it against a graph database. Instead, it uses the mapping layer and ontology axioms to translate the graph query into optimized native queries (such as SQL) on the fly.
Consider a simplified scenario where an engineer wants to find all active turbines. They write a concise semantic query:
SELECT ?turbine WHERE { ?turbine a :ActiveTurbine }
The OBDA engine performs the following steps:
- Axiom Enrichment: The engine consults the ontology, which might contain a logical rule stating that an
ActiveTurbineis a subclass ofTurbinewhere the status is 'ON'. - Unfolding: The engine looks at the mapping layer to see which physical tables correspond to the
Turbineclass and its status attributes. - Translation: The engine translates the abstract graph query into a native SQL query:
sql SELECT turbine_id FROM turbine_register WHERE status = 'OPERATIONAL' - Execution: This SQL query is executed directly by the underlying relational database, which returns the raw rows. The OBDA engine then wraps these rows back into semantic concepts before presenting them to the user.
As Evgeny Kharlamov et al. demonstrate in industrial diagnostic systems, this virtualization strategy provides the benefits of high-level semantic reasoning without the performance overhead or storage redundancy of converting massive sensor datasets into physical RDF triples.
Why the Virtual Approach Wins
Building intuition for VKGs requires understanding why they outperform physical data warehousing in dynamic environments.
No Data Duplication or Latency
In domains like earth observation or industrial IoT, data changes rapidly. As George Vouros et al. observe, virtualizing geospatial data through ontology-based access avoids the high computational cost of full data conversion, ensuring that queries always return the most fresh, up-to-date information available from the native database.
Leveraging Mature Infrastructure
Graph databases are powerful, but relational databases have benefited from over forty years of query optimization research. By translating semantic queries into SQL, VKG systems allow standard relational databases to handle the heavy lifting. As noted by Chengfei Liu et al., representing structured data through a multi-layered conceptual framework allows relational systems to frequently outperform specialized graph-based storage engines for complex semantic queries.
Decoupling Intent from Implementation
When database schemas change due to system upgrades, traditional applications break because their hardcoded SQL queries no longer match the tables. In an OBDA architecture, the user's query remains identical. Only the low-level mapping layer needs to be updated. As Robert Meersman et al. argued in foundational work on semantic nets, decoupling logical query intent from physical storage structures removes the need for users to understand underlying table joins or normalization patterns.
Real-World Applications
The utility of this architecture spans numerous data-heavy industries:
- Oil and Gas Exploration: In systems like Optique 1.0, developed by Evgeny Kharlamov et al., OBDA acts as a conceptual layer over the Norwegian Petroleum Directorate's FactPages, drastically reducing data access times for geologists.
- Urban Planning and 3D Modeling: Linfang Ding et al. apply VKGs to query complex 3D city models (CityGML) stored in relational backends, enabling semantic web interoperability without losing relational storage performance.
- Cross-Domain Data Integration: In systems chemical biology, Bin Chen shows how semantic translation layers abstract internal database structures, replacing manual, database-specific joins with concise, concept-based queries across disparate biological datasets.
- Natural Language Interfaces: Systems like ATHENA, designed by Diptikalyan Saha et al., leverage domain ontologies as an intermediary layer to translate natural language questions into accurate SQL, capturing rich semantic relationships that are typically lost in raw relational schemas.
By treating the ontology as a lens through which legacy data is viewed, Virtual Knowledge Graphs successfully bridge the gap between human-centric conceptual thinking and machine-centric data storage.
Key Foundational Work
A Deductive Question Answering System on Relational Data Bases (1977) — contributed 2 concept elements to this direction.