R2RML

The Triples Map is the core construct that defines a rule for generating RDF triples from logical database rows. Each map specifies:

• A Logical Table: The source of rows (a base table, SQL view, or valid SQL query).
• A Subject Map: Defines how to generate the subject IRI or blank node for each row.
• Predicate-Object Maps: A set of rules that, paired with the subject, generate predicate-object pairs to form complete triples.

A Logical Table identifies the set of database rows used as input for a Triples Map. It can be defined in three ways:

• Base Table or View: Referenced directly by its name.
• R2RML View: A valid SQL query whose results are treated as a virtual table. This enables complex joins and transformations before mapping.
• SQL Query: An alternative syntax for defining an R2RML view. The logical table provides the column values referenced in subsequent mapping rules.

A Term Map is a rule for generating an RDF term (an IRI, blank node, or literal). It is a foundational component used within Subject, Predicate, and Object Maps. Key types include:

• Constant-valued Term Map: Always generates the same predefined IRI or literal.
• Column-valued Term Map: Generates a term based on the value of a specified database column, often with an optional string transformation template ({COLUMN}).
• Template-valued Term Map: Uses a string template that can concatenate column values and constants to build IRIs (e.g., http://example.com/employee/{EMP_ID}).

The Subject Map is a special Term Map within a Triples Map that defines the subject of all triples produced by that map. It specifies:

• The IRI or blank node identifier for the resource being described.
• Optional Graph Maps to place the triples into named graphs.
• Optional Class IRIs (using rr:class) to assert an rdf:type for the subject. A Subject Map is required for every Triples Map, as every triple must have a subject.

A Predicate-Object Map is a rule that, together with a subject from the Subject Map, creates one or more predicate-object pairs to form triples. It consists of:

• One or more Predicate Maps: Term Maps that generate the predicate IRI (e.g., foaf:name).
• One or more Object Maps (or Referencing Object Maps): Term Maps that generate the object of the triple, which can be a literal, IRI, or blank node. A single Predicate-Object Map can generate multiple triples for the same subject if it contains multiple predicate-object pairings.

A Referencing Object Map (often called a Foreign Key Map) is a special type of Object Map that generates an object by referencing the subject of another Triples Map. This is the primary mechanism for creating links (owl:ObjectProperty relationships) between resources. It defines:

• A Parent Triples Map: The Triples Map whose subjects are referenced.
• Join Conditions: Specifies how a column in the child logical table (e.g., DEPT_ID) matches a column in the parent logical table (e.g., ID). This creates RDF triples that connect entities, forming the graph structure.

R2RML provides a non-invasive bridge to modernize legacy relational systems without disrupting existing applications. It allows organizations to expose decades of operational data stored in SQL databases as a standards-based knowledge graph. This enables:

• Incremental adoption of semantic technologies.
• Reuse of existing ETL investments by adding a semantic mapping layer.
• Connection of siloed databases (e.g., CRM, ERP) into a unified RDF model for cross-system queries.

A core use case is creating virtual knowledge graphs (VKGs). Instead of physically replicating terabytes of relational data into a triplestore, R2RML mappings define a virtual RDF view. Queries in SPARQL are translated on-the-fly into optimized SQL, enabling real-time access to current data. This is critical for:

• Data virtualization scenarios requiring a single graph query endpoint.
• Enforcing data sovereignty by leaving sensitive data in its original, governed database.
• Integrating live transactional data into semantic applications without latency from batch replication.

R2RML serves as the translation layer in a semantic data fabric. It maps heterogeneous relational schemas from different departments or acquisitions into a unified ontology (e.g., schema.org, a custom enterprise ontology). This resolves structural conflicts and creates a consistent business vocabulary. Key functions include:

• Schema alignment: Mapping CUSTOMER.ID (Sales DB) and CLIENT.CLIENT_NO (Service DB) to a single ex:Customer class.
• Data value transformation: Converting status codes (e.g., 'A') to human-readable IRIs (e.g., <http://example.com/status/Active>).
• Provenance tracking: Using R2RML's named graphs to tag which source database each triple originated from.

R2RML is essential for building deterministic factual grounding in Retrieval-Augmented Generation (RAG) systems. It transforms reliable enterprise relational data into a high-quality knowledge graph that serves as a verifiable source for large language models. This application:

• Eliminates hallucinations by tethering LLM responses to mapped, structured facts.
• Enables complex multi-hop reasoning across relationships (e.g., "Find projects for customers in the healthcare sector") that are explicit in the database but implicit in documents.
• Provides audit trails, as every generated answer can be traced back to specific database records via the R2RML mapping.

By providing a standardized RDF view of relational data, R2RML enables query federation across hybrid data landscapes. A SPARQL endpoint powered by R2RML can participate in federated queries that join data from:

• Other knowledge graphs (triplestores).
• Document databases via companion standards like RML.
• Public linked open data clouds. This allows for complex analytics that were previously impossible, such as enriching internal customer data with demographic information from DBpedia, all within a single query.

R2RML mappings act as executable documentation of how business concepts map to physical data. This is vital for data governance, regulatory compliance (like GDPR), and auditability. Use cases include:

• Defining PII (Personally Identifiable Information) in semantic terms: Mapping a EMPLOYEES.SSN column to a foaf:PersonalID property with appropriate access tags.
• Supporting "Right to be Forgotten": The mapping shows exactly which database records correspond to a semantic entity, enabling precise deletion.
• Maintaining data lineage: The mapping itself is a key artifact that links the business ontology (the "what") to the system-of-record database (the "where").

A Virtual Knowledge Graph is a system that provides a unified, queryable RDF graph interface over underlying heterogeneous data sources without physically materializing all the triples. It uses R2RML or RML mapping definitions to translate SPARQL queries in real-time into the native query languages of the source systems (e.g., SQL, MongoDB queries). This enables on-demand access to fresh data and is a key architectural pattern for logical data fabrics, avoiding large-scale ETL and data duplication.

An ontology is a formal, machine-readable specification of a conceptual model for a domain. It defines:

• Classes (types of things, like Person or Product).
• Properties (relationships and attributes, like worksFor or hasPrice).
• Constraints and logical rules (like a Person has exactly one birthdate). R2RML mappings do not define an ontology; they map database schemas to instances of one. The target RDF vocabulary (e.g., classes and properties from an OWL or RDFS ontology) is referenced within the R2RML mapping rules to give semantic meaning to the mapped data.

Data Virtualization is an integration pattern that provides a unified, abstracted view of data from multiple disparate sources in real-time, without requiring physical movement or replication. A Virtual Knowledge Graph implemented with R2RML is a form of semantic data virtualization. The R2RML mapping layer acts as the virtualization engine, presenting relational data as a virtual RDF graph. This pattern is central to logical data fabrics, enabling agile access while leaving source systems of record intact.

Semantic Integration is the process of combining data from disparate sources by resolving schematic and data-level conflicts to achieve a unified, meaningful view. R2RML is a key technical enabler for semantic integration at the data access layer. It solves the schematic heterogenity problem by mapping disparate relational schemas to a common, shared ontology (RDF model). This allows queries to be written in terms of business concepts (e.g., Customer, Order) rather than underlying table and column names, enabling true interoperability.