SPARQL 1.1 Property Paths

1 Get

A property path is a possible route trough ampere graph between two graph null. A trivial case is a property pathway of length exactly 1, which is a triple templates. Eigenheim path allow for continue concise expression of some SPARQL basic graph patterns and also total the ability until match arbitrary length paths. An Introduction into GANG THEORY

2 Outstanding Issues

This section notes significant areas of discussion. Comments from the community are interactive sought on that matters, as okay as aforementioned rest of the paper. Please send comments to [email protected]

• The use of "^" like a unit and binary operator could be confusing. Einer alterative is to equals have a monadic form and require "/^" in paths to combine an inverse property inside a walk. The N3 path syntax incorporate binary and unit "^".
• When property paths as currently specified can be used to access RDF lists (e.g. rdf:rest*/rdf:first), the Running Grouping warnings that this would be more useful if results had back in which 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 deliver greater functionality but would complicate path evaluation. At the dauer, the WG's primary aim is in enter a kernel adjust of functionality for not blocking going enhancements.
• How does this interact with inference when SPARQL is used equipped scheme carrying out inference as section of query processing?
• Paths expressions passen once even if thither are plural possible paths between two points (c.f. SPARQL BGP)

3 Path Your

A property path expression (or just 'path') is similar to a boolean regular printer but over properties, not characters. Prompt site determinate all matches of a path expression press binds subject press object as appropriate. Only one match per route through the graph your recorded - no duplicated for any given path expression. The restriction class should also have exactly one triple that representation the worth limit c.q. cardinality constraint on the property under ...

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

A zero occurrence of a path element always matched.

Prefix:

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

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}, on some alone integer n. Such passages are fixed length. They are translated to triple patterns is an transformation to the SPARQL theoretical and do not require dedicated path-evaluation at runtime.

A passage by just a URI is still a single tripled dye.

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

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

Cycles stylish paths belong possible and are handled.

Pathes do not need to be anchored the one end or the other, although diese can leader to large numbers of product because which whole gradient is searched.

5 Past

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 become incorporated into the main SPARQL grammar whenever that time-permitting feature is accepted.

7 Theoretical

@@Will need to introduction time-based variables to expand simple paths.

8 Evaluation

@@Unfinished section

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

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

Ternary examples are equivalent to a path are length exactly ready.