SPARQL 1.1 Property Paths

1 Introduction

A property path is a possible route through a graph between two graph nodes. A trivial case is a property path of length exactly 1, which is a triple pattern. Property paths allow for more concise expression of some SPARQL basic graph patterns and also add the ability to match arbitrary length paths.

2 Outstanding Issues

This section notes significant areas of discussion. Comments from the community are actively sought on these matters, as well as the rest of the document. Please send comments to public-rdf-dawg-comments@w3.org

• The use of "^" as a unary and binary operator may be confusing. An alterative is to just have a unary form and require "/^" in paths to combine an inverse property into a path. The N3 path syntax includes binary and unary "^".
• While property paths as currently specified can be used to access RDF lists (e.g. rdf:rest*/rdf:first), the Working Group notes that this would be more useful if results were returned in the order they occur in the RDF list. This presents significant complexity in the context of the existing SPARQL algebra.
• The WG has discussed providing access to the length of matched paths, which would provide greater functionality but would complicate path evaluation. At this time, the WG's primary aim is to specify a core set of functionality while not blocking future enhancements.
• How does this interact with inference when SPARQL is used with systems carrying out inference as part of query processing?
• Paths expressions match once even if there are multiple possible paths between two points (c.f. SPARQL BGP)

3 Path Language

A property path expression (or just 'path') is similar to a string regular expression but over properties, not characters. Query evaluation determines all matches of a path expression and binds subject or object as appropriate. Only one match per route through the graph is recorded - no duplicates for any given path expression.

In the description below, uri is either a URI or a prefixed name and elt is a path element, which may itself be composed of path syntax constructs.

A zero occurrence of a path element always matches.

Precedence:

• URI, prefixed names
• Groups
• Unary operators *, ?, + and {} forms
• Unary ^ inverse links
• Binary operators / and ^
• Binary operator |

Precedence is left-to-right within groups.

4 Path Terminology

Paths are "simple" if they involve only operators / (sequence), ^ (inverse, unary or binary) and the form {n}, for some single integer n. Such paths are fixed length. They are translated to triple patterns in the transformation to the SPARQL algebra and do not require special path-evaluation at runtime.

A path of just a URI is still a single triple pattern.

A path is "complex"  if it involves one or more of the operators *,?, + and {} (except {n}). Such paths require an algebra extension.

A path of length zero connects a graph node to itself.

Cycles in paths are possible and are handled.

Paths do not need to be anchored at one end or the other, although this can lead to large numbers of result because the whole graph is searched.

5 Examples

See also uses cases.

{
  ?x foaf:mbox <mailto:alice@example> .
  ?x foaf:knows/foaf:name ?name .
 }

{ 
  ?x foaf:mbox <mailto:alice@example> .
  ?x foaf:knows/foaf:knows/foaf:name ?name .
 }

{  ?x  foaf:mbox <mailto:alice@example> .
   ?x  foaf:knows [ foaf:knows [ foaf:name ?name ]]. }

{
  ?x  foaf:mbox <mailto:alice@example> .
  ?x  foaf:knows ?a1 .
  ?a1 foaf:knows ?a2 .
  ?a2 foaf:name ?name .
}

{ ?x foaf:mbox <mailto:alice@example> .
   ?x foaf:knows/foaf:knows ?y .
   FILTER ( ?x != ?y )
   ?y foaf:name ?name 
}

{ ?x foaf:mbox <mailto:alice@example> }

{ <mailto:alice@example> ^foaf:mbox ?x }

{
  ?x foaf:knows^foaf:knows ?y .  
  FILTER(?x != ?y)
}

{
  ?x foaf:mbox <mailto:alice@example> .
  ?x foaf:knows+/foaf:name ?name .
 }

{ <http://example/thing> rdf:type/rdfs:subClassOf* ?type }

{ ?x rdf:type/rdfs:subClassOf* ?type }

6 Syntax

This syntax will be incorporated into the main SPARQL grammar if the time-permitting feature is accepted.

7 Algebra

@@Will need to introduce temporary variables to expand simple paths.

8 Evaluation

@@Unfinished section

Path evaluation yields a set of bindings of variables (excluding any system-generated variables). If there are two or more paths, from <a> to <b>, only a unique solution is returned.

Cycles are permitted and included in matches. Cycle detection is necessary.

Triple patterns are equivalent to a path of length exactly one.