RML

The Logical Source (rml:logicalSource) defines the raw data to be processed. It specifies the access method (e.g., a file path, database query, or API endpoint) and the reference formulation that dictates how to access values within the data structure (e.g., JSONPath for JSON, XPath for XML, or column names for CSV). This component abstracts the physical data location and format, making the mapping reusable across different data retrieval scenarios.

A Subject Map (rr:subjectMap) defines the rule for generating the subject of each RDF triple. It is the central node to which all predicates and objects are attached. The subject is typically created using a template (rr:template) that concatenates a base IRI with values from the source data (e.g., http://example.com/person/{ID}). Alternatively, it can be a constant IRI or a blank node. Each Triples Map must have exactly one Subject Map.

The Predicate-Object Map (rr:predicateObjectMap) associates one or more predicates and their corresponding objects to the subject. It contains:

• A Predicate Map (rr:predicateMap): Defines the property (predicate) IRI, often a constant like foaf:name.
• An Object Map (rr:objectMap) or Referencing Object Map (rr:parentTriplesMap): Defines the value (object). The object can be:
  • A literal generated from a source column/field.
  • An IRI, created via a template.
  • A blank node.
  • Another subject, via a Referencing Object Map, which creates a relationship between two entities defined in different Triples Maps.

The Triples Map (rr:TriplesMap) is the core container unit of an RML mapping. It binds together a Logical Source, a Subject Map, and one or more Predicate-Object Maps. Each Triples Map defines a rule for generating a set of RDF triples (subject-predicate-object) from each logical record (row, object, element) in the source. A complete mapping document is composed of multiple, potentially interconnected Triples Maps.

Term Maps (rr:TermMap) are the abstract rules for generating RDF terms (subjects, predicates, objects). They specify the term type (IRI, blank node, or literal) and its value. A key subtype is a Reference-valued Term Map, where the term's value is dynamically generated from the source data using a reference (rml:reference). For example, in a JSON source, rml:reference might be "$.firstName", instructing the mapper to extract the value from that JSONPath location to create a literal object.

Function Maps (fnml:functionValue) enable complex data transformations within the mapping process. They allow the application of functions (from libraries like FnO) to source values before they become RDF terms. Common use cases include:

• String manipulation: Concatenation, case conversion, substring extraction.
• Data type conversion: Casting strings to xsd:dateTime or xsd:integer.
• Mathematical operations: Calculations on numerical data.
• Conditional logic: Generating different values based on source data conditions. This moves mapping beyond simple direct copying into the realm of data cleansing and enrichment.

RML is the foundational tool for constructing enterprise knowledge graphs from siloed operational data. It provides a declarative mapping language to define how records in source systems correspond to RDF triples (subject-predicate-object). This process, known as knowledge graph materialization, creates a persistent, queryable graph that serves as a single source of truth.

• Key Activity: Defining mappings from CSV customer files, JSON API responses, and XML product catalogs into a unified ontology.
• Outcome: Enables complex SPARQL queries across previously disconnected data domains.

Instead of physically materializing all data, RML mappings can power a virtual knowledge graph (VKG). In this architecture, a query engine uses RML definitions to federate queries in real-time across the original source systems. The graph is an on-demand, integrated view without massive data duplication.

• Key Benefit: Provides immediate semantic integration for analytics without lengthy ETL processes.
• Technical Mechanism: An RML processor acts as a virtual RDFizer, translating a SPARQL query into source-specific queries (e.g., SQL, MongoDB queries) and mapping the results back to RDF.

RML is the core mapping engine within a semantic data fabric. It operationalizes the fabric's semantic layer by providing the executable instructions that transform raw data into contextualized, ontology-aligned knowledge. This bridges the gap between physical data storage and business-centric conceptual models.

• Architectural Role: Sits within the semantic integration pipeline, often alongside tools for ontology alignment and entity resolution.
• Business Value: Delivers semantic interoperability, allowing different departments to access data with consistent, shared meaning.

Domain teams use RML to publish data products as linked data. By mapping a domain-owned dataset (e.g., a product catalog in a PostgreSQL database) to a shared enterprise ontology, the team exposes its data as a standards-compliant RDF graph. This graph can be consumed directly via SPARQL or integrated into the broader knowledge graph.

• Data Mesh Alignment: Enforces the data-as-a-product principle by providing a standardized interface (RDF/SPARQL) for domain data.
• Governance: Mappings document the exact relationship between source schema and target ontology, providing clear data lineage.

RML feeds deterministic factual grounding for Retrieval-Augmented Generation (RAG) systems. By transforming enterprise data into a knowledge graph, RML creates a verifiable source of facts. A Graph RAG architecture can then traverse this graph to retrieve connected subgraphs as context for a large language model, drastically reducing hallucinations.

• Process: Raw documents and databases → RML → Knowledge Graph → Graph Retrieval → LLM Context.
• Advantage over Vector Search: Provides explicit relationships and logical provenance for retrieved information.

RML acts as a modernization wrapper for legacy systems (mainframes, old SQL databases) by exposing their data as linked data. Organizations can thus integrate decades-old data into modern AI and analytics platforms without replacing the core transactional systems. The mappings serve as a declarative abstraction layer.

• Typical Source: Relational databases mapped using RML's basis in the R2RML standard.
• Strategic Outcome: Unlocks legacy data for use in digital twins, advanced analytics, and compliance reporting without disruptive migration.

Semantic integration is the overarching process of combining data from disparate sources by resolving schematic and data-level conflicts. It uses shared ontologies and semantic mappings (like those defined in RML) to create a unified, meaningful view.

• Goal: Achieve semantic interoperability, where exchanged data has unambiguous, shared meaning.
• Role of Mappings: RML mappings are the executable specifications that drive this integration, transforming raw data into a coherent knowledge graph.

A Virtual Knowledge Graph is a system that provides a unified, graph-based view over heterogeneous data sources in real-time using mapping definitions, without requiring the physical materialization of the entire graph.

• On-Demand Access: Data is transformed into RDF at query time via mappings (RML/R2RML).
• Key Benefit: Eliminates the latency and storage overhead of ETL, offering a live, integrated view.
• Architecture: The VKG engine uses RML documents to understand how to query and map each underlying source.

An ontology is a formal, explicit specification of a shared conceptualization. It defines the classes, properties, and relationships (the vocabulary) for a particular domain, providing the semantic schema for a knowledge graph.

• Mapping Target: RML mappings transform data into instances (individuals) of the classes and properties defined in a target ontology (e.g., OWL, RDFS).
• Semantic Context: The ontology gives meaning to the generated RDF triples, ensuring all data conforms to a consistent, logical model.

A semantic pipeline is an automated workflow that ingests, transforms, enriches, and integrates raw data into a knowledge graph. RML is a core component within such pipelines, responsible for the declarative transformation and mapping stage.

• Typical Stages: Ingestion → Cleaning → Mapping (RML) → Entity Linking/Lifting → Materialization/Storage.
• Orchestration: RML processors (like the RMLMapper or SDM-RDFizer) are executed as steps within larger data pipeline frameworks (e.g., Apache Airflow, Nextflow).