RDF-star and SPARQL-star

1.3 Conformance

As well as sections marked as non-normative, all authoring guidelines, diagrams, examples, and notes in this specification are non-normative. Everything else in this specification is normative.

The key words MAY, MUST, and MUST NOT in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

3.1 Turtle-star

In this section, we present Turtle-star, an extension of the Turtle format [TURTLE] allowing the representation of RDF-star graphs. For the sake of conciseness, we only describe here the differences between Turtle-star and Turtle.

3.2 N-Triples-star

This section describes N-Triples-star, a minimal extension of the N-Triples format [N-TRIPLES] allowing a subject or an object of an RDF-star triple to be an embedded triple.

3.3 N-Quads-star

The [N-QUADS] format is extended to describe the N-Quads-star format using the same production updates described in the N-Triples-star Grammar.

An N-Quads-star document defines an RDF-star dataset composed of a single default graph, and zero or more named graphs, all of which are RDF-star graphs.

A conforming N-Quads-star parser MUST parse any valid N-Quads document and additionally parse the subject and object productions from N-Triples-star to generate RDF-star triples which are added to either the default graph or associated named graph, as appropriate.

4.1 Initial Definitions

In the following, we introduce a number of SPARQL-star-specific definitions, which rely on the following notions, defined in SPARQL 1.1 Query Language [SPARQL11-QUERY]: RDF term, query variable, triple pattern, property path pattern, property path expression, and solution mapping.

A SPARQL-star triple pattern is a 3-tuple that is defined recursively as follows:

1. Every SPARQL triple pattern is a SPARQL-star triple pattern;
2. If t and t' are SPARQL-star triple patterns, x is an RDF term or a query variable, and p is an IRI or a query variable, then (t, p, x), (x, p, t), and (t, p, t') are SPARQL-star triple patterns.

As for RDF-star triples, a SPARQL-star triple pattern MUST NOT contain itself.

A SPARQL-star basic graph pattern (BGP-star) is a set of SPARQL-star triple patterns.

A SPARQL-star property path pattern is a 3-tuple (s,p,o) where

• s is either an RDF term, a query variable, or a SPARQL-star triple pattern,
• p is a property path expression, and
• o is either an RDF term, a query variable, or a SPARQL-star triple pattern.

A SPARQL-star solution mapping μ is a partial function from the set of all query variables to the set of all RDF-star terms. The domain of μ, denoted by dom(μ), is the set of query variables for which μ is defined.

All notions related to SPARQL solution mappings carry over naturally to SPARQL-star solution mappings. In particular, the definition of compatibility extends naturally to SPARQL-star solution mappings: two SPARQL-star solution mappings μ₁ and μ₂ are compatible if, for every variable v that is both in dom(μ₁) and in dom(μ₂), μ₁(v) and μ₂(v) are the same RDF-star term. In this case, μ₁ ∪ μ₂ is also a SPARQL-star solution mapping. Moreover, for any SPARQL-star solution mapping μ we write card[Ω](μ) to denote the cardinality of μ in a multiset Ω of such mappings. Finally, given a BGP-star B and a SPARQL-star solution mapping μ, we write μ(B) to denote the result of replacing every variable v in B for which μ is defined with μ(v).

Next, we aim to carry over the notion of solutions for BGPs to BGP-star. To this end, we first define an auxiliary concept that carries over the notion of an RDF instance mapping [RDF11-MT] to RDF-star.

An RDF-star instance mapping σ is a partial function from the set of all blank nodes to the set of all RDF-star terms. The domain of σ, denoted by dom(σ), is the set of blank nodes for which σ is defined.

Similar to the corresponding notation for solution mappings, for an RDF-star instance mapping σ and a BGP-star B we write σ(B) to denote the result of replacing every blank node b in B for which σ is defined with σ(b).

Now we are ready to define the notion of solution for BGP-star.

Given a BGP-star B and an RDF-star graph G, a SPARQL-star solution mapping μ is a solution for the BGP-star B over G if it has the following two properties

• dom(μ) is equivalent to the set of query variables in B, and
• there exists an RDF-star instance mapping σ such that dom(σ) is equivalent to the set of blank nodes in B and μ(σ(B)) is a subgraph of G.

4.2 Grammar

SPARQL-star is defined to follow the same grammar as SPARQL, except for the EBNF productions specified below, which replace the productions having the same number (if any) in the original grammar.

This introduces a notation for embedded triple patterns (productions [174] and following), which is similar to the one defined for embedded triples in § 3.1 Turtle-star, but accepting also variables. These embedded triple patterns are allowed in the subject ([75], [81]) and object ([80], [105]) positions of SPARQL-star triple patterns, as well as in BIND statements ([60]).

:bob :age 42 {| :source <http://example.org/~bob/> |}.

:bob :age 42.
<< :bob :age 42 >> :source <http://example.org/~bob/>.

4.3 Translation to the Algebra

Based on the SPARQL grammar, the SPARQL specification defines the process of converting graph patterns and solution modifiers in a SPARQL query string into a SPARQL algebra expression [SPARQL11-QUERY, Section 18.2]. This process must be adjusted to consider the extended grammar introduced above. In the following, any step of the conversion process that requires adjustment is discussed.

4.4 Evaluation Semantics

The SPARQL specification defines a function eval(D(G), algebra expression) as the evaluation of an algebra expression with respect to a dataset D having active graph G [SPARQL11-QUERY, Section 18.6]. Recall that the dataset D in the context of SPARQL-star is an RDF-star dataset and, thus, the active graph G is an RDF-star graph, and so is any other graph in dataset D. The definition of the eval function is recursive; the two base cases of this definition for SPARQL-star are given as follows:

1. For every BGP-star B, eval(D(G), B) is a multiset Ω that consists of all SPARQL-star solution mappings that are a solution for the BGP-star B over G. For every such mapping μ, card[Ω](μ) is the number of distinct RDF-star instance mappings σ such that dom(σ) is equivalent to the set of blank nodes in B and μ(σ(B)) is a subgraph of G. (For any SPARQL-star solution mapping μ' that is not a solution for B over G, we have that card[Ω](μ')=0; i.e., μ' is not in Ω.)
2. For any algebra expression E of the form TR(tp, ?v) where tp is a SPARQL-star triple pattern and ?v is a variable (as introduced in § 4.3.5 Translate BIND Clauses with an Embedded Triple Pattern), eval(D(G), E) is a multiset Ω that consists of as many SPARQL-star solution mappings as there are solution mappings in Ω', where Ω'=eval(D(G),{tp}), such that for every μ' in Ω' there exists a μ in Ω that has the following four properties:
   1. dom(μ) = dom(μ') ∪ {?v}
   2. μ and μ' are compatible
   3. μ(?v) = μ'(tp)
   4. card[Ω](μ) = card[Ω'](μ')

For any other algebra expression, the SPARQL specification defines algebra operators [SPARQL11-QUERY]. These definitions can be extended naturally to operate over multisets of SPARQL-star solution mappings (instead of ordinary solution mappings). Given this extension, the recursive steps of the definition of the eval function for SPARQL-star are the same as in the SPARQL specification.

4.5 Query Result Formats

In SPARQL, queries can take four forms: SELECT, CONSTRUCT, DESCRIBE, and ASK - see SPARQL1.1 Query, Section 16 [SPARQL11-QUERY]. The first of these returns a sequence of solution mappings that contain variable bindings. The second and third both return an RDF graph, and the last returns a boolean value.

The result of the ASK query form is not changed by the introduction of RDF-star, and the result of the CONSTRUCT and DESCRIBE forms can be represented by Turtle-star. However, since the SELECT form deals with returning individual RDF terms, the specific serialization formats for representing such query results need to be extended so that the new embedded triple RDF term can be represented. In this section, we propose extensions for the two most common formats for this purpose: SPARQL 1.1 Query Results JSON Format, and SPARQL Query Results XML Format (Second Edition).

<< <http://example.org/alice> <http://example.org/name> "Alice" >>

{
  "type": "triple",
  "value": {
     "subject": {
        "type": "uri",
        "value" "http://example.org/alice"
     },
     "predicate": {
        "type": "uri",
        "value" "http://example.org/name"
     },
     "object": {
        "type": "literal",
        "value" "Alice",
        "datatype": "http://www.w3.org/2001/XMLSchema#string"
     },
  }
}

<< <http://example.org/alice> <http://example.org/name> "Alice" >>

<triple>
    <subject>
        <uri>http://example.org/alice</uri>
    </subject>
    <predicate>
        <uri>http://example.org/name</uri>
    </predicate>
    <object>
        <literal datatype='http://www.w3.org/2001/XMLSchema#string'>Alice</literal>
    </object>
</triple>

6.1 Mapping RDF-star abstract syntax to RDF

We consider six IRIs ST, PT, OT, SS, PS and OS that will have a special meaning in our mapping.

We define a mapping L that maps any IRI or literal t to a literal with

• xsd:string as its datatype, and
• the canonical N-Triples representation of t as its lexical form [N-TRIPLES]. If t is itself a literal with the xsd:string datatype, the representation MUST be a simple literal.

Given an RDF-star graph G, the following steps transform it into an RDF graph that we call unstar(G).

1. Pick an RDF-star triple (s, p, o) in the constituents of G such that neither s nor o is an embedded triple.
2. Mint a fresh blank node b, and replace by b all occurrences of (s, p, o) in the subject or object position of an asserted or embedded triple of G.
3. Add the following asserted triples to G:
   • (b, ST, s)
   • (b, PT, p)
   • (b, OT, o) unless o is an ill-typed literal
   • (b, SS, L(s)) unless s is blank node
   • (b, PS, L(p))
   • (b, OS, L(o)) unless o is blank node
4. Repeat the steps above until there are no embedded triples left in G.

After these steps, unstar(G) is an RDF graph, as it contains no embedded triples. Note that if G was already an RDF graph, then unstar(G) = G.

6.2 Entailment of RDF-star graphs

Following RDF 1.1 Semantics, we extend the notions of satisfiability and entailment for RDF-star graphs. Given two RDF-star graphs G and H:

• We say that G is (simply) satisfiable (resp. unsatisfiable) if and only if unstar(G) is (simply) satisfiable (resp. unsatisfiable).
• We say that H is (simply) entailed by (resp. equivalent to) G if and only if unstar(H) is (simply) entailed by (resp. equivalent to) unstar(G).
• Other notions of satisfiability and entailment, such as RDF entailment or RDFS entailment, can be extended in the same way for RDF-star graphs.