1.2.1 Namespaces

In this document, examples assume the following namespace prefix bindings unless otherwise stated:

1.2.2 Data Descriptions

This document uses theTurtle [TURTLE]data format to show each triple explicitly. Turtle allows IRIs to be abbreviated with prefixes:

@prefix dc:   <http://purl.org/dc/elements/1.1/> .@prefix :     <http://example.org/book/> .:book1  dc:title  "SPARQL Tutorial" .

1.2.3 Result Descriptions

Result sets are illustrated in tabular form.

A 'binding' is a pair (variable,RDF term). In this result set, there are threevariables:x,y andz (shown as column headers). Each solution is shown as one row in the body of the table.  Here, there is a single solution, in which variablex is bound to"Alice", variabley is bound to<http://example/a>, and variablez is not bound to an RDF term. Variables are not required to be bound in a solution.

1.2.4 Terminology

The SPARQL language includes IRIs, a subset of RDF URI References that omits spaces. Note that all IRIs in SPARQL queries are absolute; they may or may not include a fragment identifier [RFC3987, section 3.1]. IRIs include URIs [RFC3986] and URLs. The abbreviated forms (relative IRIs and prefixed names) in the SPARQL syntax are resolved to produce absolute IRIs.

The following terms are defined inRDF Concepts and Abstract Syntax[CONCEPTS] and used in SPARQL:

• IRI (corresponds to the Concepts and Abstract Syntax term "RDF URI reference")
• literal
• lexical form
• plain literal
• language tag
• typed literal
• datatype IRI (corresponds to the Concepts and Abstract Syntax term "datatype URI")
• blank node

In addition, we define the following terms:

• RDF Term, which includes IRIs, blank nodes and literals
• Simple Literal, which covers literals without language tag or datatype IRI

Data:

<http://example.org/book/book1> <http://purl.org/dc/elements/1.1/title> "SPARQL Tutorial" .

SELECT ?titleWHERE{  <http://example.org/book/book1> <http://purl.org/dc/elements/1.1/title> ?title .}

@prefix foaf:  <http://xmlns.com/foaf/0.1/> ._:a  foaf:name   "Johnny Lee Outlaw" ._:a  foaf:mbox   <mailto:jlow@example.com> ._:b  foaf:name   "Peter Goodguy" ._:b  foaf:mbox   <mailto:peter@example.org> ._:c  foaf:mbox   <mailto:carol@example.org> .

Query:

PREFIX foaf:   <http://xmlns.com/foaf/0.1/>SELECT ?name ?mboxWHERE  { ?x foaf:name ?name .    ?x foaf:mbox ?mbox }

@prefix dt:   <http://example.org/datatype#> .@prefix ns:   <http://example.org/ns#> .@prefix :     <http://example.org/ns#> .@prefix xsd:  <http://www.w3.org/2001/XMLSchema#> .:x   ns:p     "cat"@en .:y   ns:p     "42"^^xsd:integer .:z   ns:p     "abc"^^dt:specialDatatype .

Note that, in Turtle,"cat"@en is an RDF literal with a lexical form "cat" and a language tag "en";"42"^^xsd:integer is a typed literal with the datatypehttp://www.w3.org/2001/XMLSchema#integer; and"abc"^^dt:specialDatatype is a typed literal with the datatypehttp://example.org/datatype#specialDatatype.

2.3.1 Matching Literals with Language Tags

Language tags in SPARQL are expressed using@ and the language tag, as defined inBest Common Practice 47 [BCP47].

This following query has no solution because"cat" is not the same RDF literal as"cat"@en:

SELECT ?v WHERE { ?v ?p "cat" }

SELECT ?v WHERE { ?v ?p "cat"@en }

2.3.2 Matching Literals with Numeric Types

Integers in a SPARQL query indicate an RDF typed literal with the datatypexsd:integer. For example:42 is a shortened form of "42"^^<http://www.w3.org/2001/XMLSchema#integer>.

The pattern in the following query has a solution with variablev bound to:y.

SELECT ?v WHERE { ?v ?p 42 }

Section 4.1.2 defines SPARQL shortened forms forxsd:float andxsd:double.

2.3.3 Matching Literals with Arbitrary Datatypes

The following query has a solution with variablev bound to:z. The query processor does not have to have any understanding of the values in the space of the datatype. Because the lexical form and datatype IRI both match, the literal matches.

SELECT ?v WHERE { ?v ?p "abc"^^<http://example.org/datatype#specialDatatype> }

@prefix foaf:  <http://xmlns.com/foaf/0.1/> ._:a  foaf:name   "Alice" ._:b  foaf:name   "Bob" .

PREFIX foaf:   <http://xmlns.com/foaf/0.1/>SELECT ?x ?nameWHERE  { ?x foaf:name ?name }

The results above could equally be given with different blank node labels because the labels in the results only indicate whether RDF terms in the solutions are the same or different.

@prefix foaf:  <http://xmlns.com/foaf/0.1/> .          _:a  foaf:givenName   "John" ._:a  foaf:surname  "Doe" .

PREFIX foaf:   <http://xmlns.com/foaf/0.1/>SELECT ( CONCAT(?G, " ", ?S) AS ?name )WHERE  { ?P foaf:givenName ?G ; foaf:surname ?S }

PREFIX foaf:   <http://xmlns.com/foaf/0.1/>SELECT ?nameWHERE  {    ?P foaf:givenName ?G ;       foaf:surname ?S    BIND(CONCAT(?G, " ", ?S) AS ?name)}

Data:

@prefix org:    <http://example.com/ns#> ._:a  org:employeeName   "Alice" ._:a  org:employeeId     12345 ._:b  org:employeeName   "Bob" ._:b  org:employeeId     67890 .

PREFIX foaf:   <http://xmlns.com/foaf/0.1/>PREFIX org:    <http://example.com/ns#>CONSTRUCT { ?x foaf:name ?name }WHERE  { ?x org:employeeName ?name }

@prefix foaf: <http://xmlns.com/foaf/0.1/> .      _:x foaf:name "Alice" ._:y foaf:name "Bob" .

which can be serialized inRDF/XML as:

<rdf:RDF    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"    xmlns:foaf="http://xmlns.com/foaf/0.1/"    >  <rdf:Description>    <foaf:name>Alice</foaf:name>  </rdf:Description>  <rdf:Description>    <foaf:name>Bob</foaf:name>  </rdf:Description></rdf:RDF>

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>SELECT  ?titleWHERE   { ?x dc:title ?title          FILTER regex(?title, "^SPARQL")         }

Query Result:

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>SELECT  ?titleWHERE   { ?x dc:title ?title          FILTER regex(?title, "web", "i" )         }

Query Result:

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>PREFIX  ns:  <http://example.org/ns#>SELECT  ?title ?priceWHERE   { ?x ns:price ?price .          FILTER (?price < 30.5)          ?x dc:title ?title . }

Query Result:

4.1.1 Syntax for IRIs

Theiri production designates the set of IRIs [RFC3987]; IRIs are a generalization of URIs [RFC3986] and are fully compatible with URIs and URLs. ThePrefixedName production designates a prefixed name. The mapping from a prefixed name to an IRI is described below. IRI references (relative or absolute IRIs) are designated by theIRIREF production, where the '<' and '>' delimiters do not form part of the IRI reference. Relative IRIs match theirelative-ref reference in section 2.2 ABNF for IRI References and IRIs in [RFC3987] and are resolved to IRIs as described below.

The set of RDF terms defined in RDF Concepts and Abstract Syntax includes RDF URI references while SPARQL terms include IRIs. RDF URI references containing "<", ">", '"' (double quote), space, "{", "}", "|","\", "^", and "`" are not IRIs. The behavior of a SPARQL query against RDF statements composed of such RDF URI references is not defined.

<http://example.org/book/book1>

BASE <http://example.org/book/><book1>

PREFIX book: <http://example.org/book/>book:book1

4.1.2 Syntax for Literals

The general syntax for literals is a string (enclosed in either double quotes,"...", or single quotes,'...'), with either an optional language tag (introduced by@) or an optional datatype IRI or prefixed name (introduced by^^).

As a convenience, integers can be written directly (without quotation marks and an explicit datatype IRI) and are interpreted as typed literals of datatypexsd:integer; decimal numbers for which there is '.' in the number but no exponent are interpreted asxsd:decimal; and numbers with exponents are interpreted asxsd:double. Values of typexsd:boolean can also be written astrue orfalse.

To facilitate writing literal values which themselves contain quotation marks or which are long and contain newline characters, SPARQL provides an additional quoting construct in which literals are enclosed in three single- or double-quotation marks.

Examples of literal syntax in SPARQL include:

• "chat"
• 'chat'@fr with language tag "fr"
• "xyz"^^<http://example.org/ns/userDatatype>
• "abc"^^appNS:appDataType
• '''The librarian said, "Perhaps you would enjoy 'War and Peace'."'''
• 1, which is the same as"1"^^xsd:integer
• 1.3, which is the same as"1.3"^^xsd:decimal
• 1.300, which is the same as"1.300"^^xsd:decimal
• 1.0e6, which is the same as"1.0e6"^^xsd:double
• true, which is the same as"true"^^xsd:boolean
• false, which is the same as"false"^^xsd:boolean

Tokens matching the productionsINTEGER,DECIMAL,DOUBLE andBooleanLiteral are equivalent to a typed literal with the lexical value of the token and the corresponding datatype (xsd:integer,xsd:decimal,xsd:double,xsd:boolean).

4.1.3 Syntax for Query Variables

A query variable is marked by the use of either "?" or "$"; the "?" or "$" is not part of the variable name. In a query,$abc and?abc identify the same variable. Thepossible names for variables are given in theSPARQL grammar.

4.1.4 Syntax for Blank Nodes

Blank nodes in graph patterns act as variables, not as references to specific blank nodes in the data being queried.

Blank nodes are indicated by either the label form, such as "_:abc", or the abbreviated form "[]". A blank node that is used in only one place in the query syntax can be indicated with[]. A unique blank node will be used to form the triple pattern. Blank node labels are written as "_:abc" for a blank node with label "abc". The same blank node label cannot be used in two different basic graph patterns in the same query.

The[:p :v] construct can be used in triple patterns. It creates a blank node label which is used as the subject of all contained predicate-object pairs. The created blank node can also be used in further triple patterns in the subject and object positions.

The following two forms

[ :p "v" ] .

[] :p "v" .

allocate a unique blank node label (here "b57") and are equivalent to writing:

_:b57 :p "v" .

This allocated blank node label can be used as the subject or object of further triple patterns. For example, as a subject:

[ :p "v" ] :q "w" .

which is equivalent to the two triples:

_:b57 :p "v" ._:b57 :q "w" .

and as an object:

:x :q [ :p "v" ] .

which is equivalent to the two triples:

:x  :q _:b57 ._:b57 :p "v" .

Abbreviated blank node syntax can be combined with other abbreviations forcommon subjects andcommon predicates.

  [ foaf:name  ?name ;    foaf:mbox  <mailto:alice@example.org> ]

This is the same as writing the following basic graph pattern for some uniquely allocated blank node label, "b18":

  _:b18  foaf:name  ?name .  _:b18  foaf:mbox  <mailto:alice@example.org> .

4.2.1 Predicate-Object Lists

Triple patterns with a common subject can be written so that the subject is only written once and is used for more than one triple pattern by employing the ";" notation.

    ?x  foaf:name  ?name ;        foaf:mbox  ?mbox .

This is the same as writing the triple patterns:

    ?x  foaf:name  ?name .    ?x  foaf:mbox  ?mbox .

4.2.2 Object Lists

If triple patterns share both subject and predicate, the objects may be separatedby ",".

    ?x foaf:nick  "Alice" , "Alice_" .

is the same as writing the triple patterns:

   ?x  foaf:nick  "Alice" .   ?x  foaf:nick  "Alice_" .

Object lists can be combined with predicate-object lists:

   ?x  foaf:name ?name ; foaf:nick  "Alice" , "Alice_" .

is equivalent to:

   ?x  foaf:name  ?name .   ?x  foaf:nick  "Alice" .   ?x  foaf:nick  "Alice_" .

4.2.3 RDF Collections

RDF collections can be written in triple patterns using the syntax "(element1 element2 ...)". The form "()" is an alternative for the IRIhttp://www.w3.org/1999/02/22-rdf-syntax-ns#nil. When used with collection elements, such as(1 ?x 3 4), triple patterns with blank nodes are allocated for the collection. The blank node at the head of the collection can be used as a subject or object in other triple patterns. The blank nodes allocated by the collection syntax do not occur elsewhere in the query.

(1 ?x 3 4) :p "w" .

is syntactic sugar for (noting thatb0,b1,b2 andb3 do not occur anywhere else in the query):

    _:b0  rdf:first  1 ;          rdf:rest   _:b1 .    _:b1  rdf:first  ?x ;          rdf:rest   _:b2 .    _:b2  rdf:first  3 ;          rdf:rest   _:b3 .    _:b3  rdf:first  4 ;          rdf:rest   rdf:nil .    _:b0  :p         "w" .

RDF collections can be nested and can involve other syntactic forms:

(1 [:p :q] ( 2 ) ) .

is syntactic sugar for:

    _:b0  rdf:first  1 ;          rdf:rest   _:b1 .    _:b1  rdf:first  _:b2 .    _:b2  :p         :q .    _:b1  rdf:rest   _:b3 .    _:b3  rdf:first  _:b4 .    _:b4  rdf:first  2 ;          rdf:rest   rdf:nil .    _:b3  rdf:rest   rdf:nil .

4.2.4 rdf:type

The keyword "a" can be used as a predicate in a triple pattern and is an alternative for the IRI http://www.w3.org/1999/02/22-rdf-syntax-ns#type. This keyword is case-sensitive.

  ?x  a  :Class1 .  [ a :appClass ] :p "v" .

is syntactic sugar for:

  ?x    rdf:type  :Class1 .  _:b0  rdf:type  :appClass .  _:b0  :p        "v" .

5.1.1 Blank Node Labels

When using blank nodes of the form_:abc,  labels for blank nodes are scoped to the basic graph pattern.  A label can be used in only a single basic graph pattern in any query.

5.1.2 Extending Basic Graph Pattern Matching

SPARQL evaluates basic graph patterns using subgraph matching, which is defined for simple entailment. SPARQL can be extended to other forms of entailment givencertain conditions as described below. The document SPARQL 1.1 Entailment Regimes describes several specific entailment regimes.

5.2.1 Empty Group Pattern

The group pattern:

{ }

matches any graph (including the empty graph) with one solution that does not bind any variables. For example:

SELECT ?xWHERE {}

matches with one solution in which variablex is not bound.

5.2.2 Scope of Filters

A constraint, expressed by the keywordFILTER, is a restriction on solutions over the whole group in which the filter appears. The following patterns all have the same solutions:

 {  ?x foaf:name ?name .    ?x foaf:mbox ?mbox .    FILTER regex(?name, "Smith") }

 {  FILTER regex(?name, "Smith")    ?x foaf:name ?name .    ?x foaf:mbox ?mbox . }

 {  ?x foaf:name ?name .    FILTER regex(?name, "Smith")    ?x foaf:mbox ?mbox . }

5.2.3 Group Graph Pattern Examples

  {    ?x foaf:name ?name .    ?x foaf:mbox ?mbox .  }

is a group of one basic graph pattern and that basic graph pattern consists of two triple patterns.

  {    ?x foaf:name ?name . FILTER regex(?name, "Smith")    ?x foaf:mbox ?mbox .  }

is a group of one basic graph pattern and a filter, and that basic graph pattern consists of two triple patterns; the filter does not break the basic graph pattern into two basic graph patterns.

  {    ?x foaf:name ?name .    {}    ?x foaf:mbox ?mbox .  }

is a group of three elements, a basic graph pattern of one triple pattern, an empty group, and another basic graph pattern of one triple pattern.

The syntactic form:

{ OPTIONAL {pattern } }

is equivalent to:

{ { } OPTIONAL {pattern } }

TheOPTIONAL keyword is left-associative :

pattern OPTIONAL {pattern } OPTIONAL { pattern }

is the same as:

{pattern OPTIONAL {pattern } } OPTIONAL { pattern }

In an optional match, either the optional graph pattern matches a graph, thereby defining and adding bindings to one or more solutions, or it leaves a solution unchanged without adding any additional bindings.

Data:

@prefix foaf:       <http://xmlns.com/foaf/0.1/> .@prefix rdf:        <http://www.w3.org/1999/02/22-rdf-syntax-ns#> ._:a  rdf:type        foaf:Person ._:a  foaf:name       "Alice" ._:a  foaf:mbox       <mailto:alice@example.com> ._:a  foaf:mbox       <mailto:alice@work.example> ._:b  rdf:type        foaf:Person ._:b  foaf:name       "Bob" .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT ?name ?mboxWHERE  { ?x foaf:name  ?name .         OPTIONAL { ?x  foaf:mbox  ?mbox }       }

@prefix dc:   <http://purl.org/dc/elements/1.1/> .@prefix :     <http://example.org/book/> .@prefix ns:   <http://example.org/ns#> .:book1  dc:title  "SPARQL Tutorial" .:book1  ns:price  42 .:book2  dc:title  "The Semantic Web" .:book2  ns:price  23 .

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>PREFIX  ns:  <http://example.org/ns#>SELECT  ?title ?priceWHERE   { ?x dc:title ?title .          OPTIONAL { ?x ns:price ?price . FILTER (?price < 30) }        }

@prefix foaf:       <http://xmlns.com/foaf/0.1/> ._:a  foaf:name       "Alice" ._:a  foaf:homepage   <http://work.example.org/alice/> ._:b  foaf:name       "Bob" ._:b  foaf:mbox       <mailto:bob@work.example> .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT ?name ?mbox ?hpageWHERE  { ?x foaf:name  ?name .         OPTIONAL { ?x foaf:mbox ?mbox } .         OPTIONAL { ?x foaf:homepage ?hpage }       }

PREFIX dc10:  <http://purl.org/dc/elements/1.0/>PREFIX dc11:  <http://purl.org/dc/elements/1.1/>SELECT ?titleWHERE  { { ?book dc10:title  ?title } UNION { ?book dc11:title  ?title } }

Query result:

PREFIX dc10:  <http://purl.org/dc/elements/1.0/>PREFIX dc11:  <http://purl.org/dc/elements/1.1/>SELECT ?x ?yWHERE  { { ?book dc10:title ?x } UNION { ?book dc11:title  ?y } }

PREFIX dc10:  <http://purl.org/dc/elements/1.0/>PREFIX dc11:  <http://purl.org/dc/elements/1.1/>SELECT ?title ?authorWHERE  { { ?book dc10:title ?title .  ?book dc10:creator ?author }         UNION         { ?book dc11:title ?title .  ?book dc11:creator ?author }       }

8.1.1 Testing For the Absence of a Pattern

TheNOT EXISTS filter expression tests whether a graph pattern does not match the dataset, given the values of variables in the group graph pattern in which the filter occurs. It does not generate any additional bindings.

@prefix  :       <http://example/> .@prefix  rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .@prefix  foaf:   <http://xmlns.com/foaf/0.1/> .:alice  rdf:type   foaf:Person .:alice  foaf:name  "Alice" .:bob    rdf:type   foaf:Person .

PREFIX  rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX  foaf:   <http://xmlns.com/foaf/0.1/> SELECT ?personWHERE {    ?person rdf:type  foaf:Person .    FILTER NOT EXISTS { ?person foaf:name ?name }}

8.1.2 Testing For the Presence of a Pattern

The filter expressionEXISTS is also provided. It tests whether the pattern can be found in the data; it does not generate any additional bindings.

PREFIX  rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX  foaf:   <http://xmlns.com/foaf/0.1/> SELECT ?personWHERE {    ?person rdf:type  foaf:Person .    FILTER EXISTS { ?person foaf:name ?name }}

@prefix :       <http://example/> .@prefix foaf:   <http://xmlns.com/foaf/0.1/> .:alice  foaf:givenName "Alice" ;        foaf:familyName "Smith" .:bob    foaf:givenName "Bob" ;        foaf:familyName "Jones" .:carol  foaf:givenName "Carol" ;        foaf:familyName "Smith" .

PREFIX :       <http://example/>PREFIX foaf:   <http://xmlns.com/foaf/0.1/>SELECT DISTINCT ?sWHERE {   ?s ?p ?o .   MINUS {      ?s foaf:givenName "Bob" .   }}

8.3.1 Example: Sharing of variables

@prefix : <http://example/> .:a :b :c .

SELECT *{   ?s ?p ?o  FILTER NOT EXISTS { ?x ?y ?z }}

evaluates to a result set with no solutions because{ ?x ?y ?z } matches given any?s ?p ?o, soNOT EXISTS { ?x ?y ?z } eliminates any solutions.

whereas withMINUS, there is no shared variable between the first part (?s ?p ?o) and the second (?x ?y ?z) so no bindings are eliminated.

SELECT *{    ?s ?p ?o    MINUS      { ?x ?y ?z }}

Results:

8.3.2 Example: Fixed pattern

Another case is where there is a concrete pattern (no variables) in the example:

PREFIX : <http://example/>SELECT * {   ?s ?p ?o   FILTER NOT EXISTS { :a :b :c }}

evaluates to a result set with no query solutions:

whereas

PREFIX : <http://example/>SELECT * {   ?s ?p ?o   MINUS { :a :b :c }}

evaluates to result set with one query solution:

Results:

because there is no match of bindings and so no solutions are eliminated.

8.3.3 Example: Inner FILTERs

Differences also arise because in a filter, variables from the group arein scope. In this example, theFILTER inside theNOT EXISTS has access to the value of ?n for the solution being considered.

@prefix : <http://example.com/> .:a :p 1 .:a :q 1 .:a :q 2 .:b :p 3.0 .:b :q 4.0 .:b :q 5.0 .

When usingFILTER NOT EXISTS, the test is on each possible solution to?x :p ?n:

PREFIX : <http://example.com/>SELECT * WHERE {        ?x :p ?n        FILTER NOT EXISTS {                ?x :q ?m .                FILTER(?n = ?m)        }}

whereas withMINUS, theFILTER inside the pattern does not have a value for ?n and it is always unbound:

PREFIX : <http://example/>SELECT * WHERE {        ?x :p ?n        MINUS {                ?x :q ?m .                FILTER(?n = ?m)        }}

Data:

@prefix dc:   <http://purl.org/dc/elements/1.1/> .@prefix :     <http://example.org/book/> .@prefix ns:   <http://example.org/ns#> .:book1  dc:title     "SPARQL Tutorial" .:book1  ns:price     42 .:book1  ns:discount  0.2 .:book2  dc:title     "The Semantic Web" .:book2  ns:price     23 .:book2  ns:discount  0.25 .

Query:

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>PREFIX  ns:  <http://example.org/ns#>SELECT  ?title ?price{  ?x ns:price ?p .   ?x ns:discount ?discount   BIND (?p*(1-?discount) AS ?price)   FILTER(?price < 20)   ?x dc:title ?title . }

Equivalent query (BIND ends the basic graph pattern; theFILTER applies to the whole group graph pattern):

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>PREFIX  ns:  <http://example.org/ns#>SELECT  ?title ?price{  { ?x ns:price ?p .     ?x ns:discount ?discount     BIND (?p*(1-?discount) AS ?price)   }   {?x dc:title ?title . }   FILTER(?price < 20)}

Results:

10.2.1 VALUES syntax

VALUES allows multiple variables to be specified in thedata block; there is a special syntax for the common case of specifyingjust one variable and some values.

In the following example, there is a table of two variables,?x and?y. The second row has no value for?y.

VALUES (?x ?y) {  (:uri1 1)  (:uri2 UNDEF)}

Optionally, when there is a single variable and some values:

VALUES ?z { "abc" "def" }

which is the same as using the general form:

VALUES (?z) { ("abc") ("def") }

10.2.2 VALUES Examples

AVALUES block of data can appear in a query pattern orat the end of aSELECT query, including asubquery.

@prefix dc:   <http://purl.org/dc/elements/1.1/> .@prefix :     <http://example.org/book/> .@prefix ns:   <http://example.org/ns#> .:book1  dc:title  "SPARQL Tutorial" .:book1  ns:price  42 .:book2  dc:title  "The Semantic Web" .:book2  ns:price  23 .

PREFIX dc:   <http://purl.org/dc/elements/1.1/> PREFIX :     <http://example.org/book/> PREFIX ns:   <http://example.org/ns#> SELECT ?book ?title ?price{   VALUES ?book { :book1 :book3 }   ?book dc:title ?title ;         ns:price ?price .}

If a variable has no value for a particular solution in theVALUES clause, the keywordUNDEF is used instead of an RDF term.

PREFIX dc:   <http://purl.org/dc/elements/1.1/> PREFIX :     <http://example.org/book/> PREFIX ns:   <http://example.org/ns#> SELECT ?book ?title ?price{   ?book dc:title ?title ;         ns:price ?price .   VALUES (?book ?title)   { (UNDEF "SPARQL Tutorial")     (:book2 UNDEF)   }}

In this example, theVALUES might have been specifiedto execute over the results of theSELECT query:

PREFIX dc:   <http://purl.org/dc/elements/1.1/> PREFIX :     <http://example.org/book/> PREFIX ns:   <http://example.org/ns#> SELECT ?book ?title ?price{   ?book dc:title ?title ;         ns:price ?price .}VALUES (?book ?title){ (UNDEF "SPARQL Tutorial")  (:book2 UNDEF)}

This is a different query but, in the example situation, has the same results.

Data:

@prefix : <http://books.example/> .:org1 :affiliates :auth1, :auth2 .:auth1 :writesBook :book1, :book2 .:book1 :price 9 .:book2 :price 5 .:auth2 :writesBook :book3 .:book3 :price 7 .:org2 :affiliates :auth3 .:auth3 :writesBook :book4 .:book4 :price 7 .

Query:

PREFIX : <http://books.example/>SELECT (SUM(?lprice) AS ?totalPrice)WHERE {  ?org :affiliates ?auth .  ?auth :writesBook ?book .  ?book :price ?lprice .}GROUP BY ?orgHAVING (SUM(?lprice) > 10)

Results:

#Default graph@prefix dc: <http://purl.org/dc/elements/1.1/> .<http://example.org/bob>    dc:publisher  "Bob" .<http://example.org/alice>  dc:publisher  "Alice" .

#Named graph: http://example.org/bob@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:a foaf:name "Bob" ._:a foaf:mbox <mailto:bob@oldcorp.example.org> .

#Named graph: http://example.org/alice@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:a foaf:name "Alice" ._:a foaf:mbox <mailto:alice@work.example.org> .

#Default graph@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:x foaf:name "Bob" ._:x foaf:mbox <mailto:bob@oldcorp.example.org> ._:y foaf:name "Alice" ._:y foaf:mbox <mailto:alice@work.example.org> .

#Named graph: http://example.org/bob@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:a foaf:name "Bob" ._:a foaf:mbox <mailto:bob@oldcorp.example.org> .

#Named graph: http://example.org/alice@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:a foaf:name "Alice" ._:a foaf:mbox <mailto:alice@work.example> .

In an RDF merge, blank nodes in the merged graph are not shared with blank nodes from the graphs being merged.

13.2.1 Specifying the Default Graph

EachFROM clause contains an IRI that indicates a graph to be used to form the default graph. This does not put the graph in as a named graph.

In this example, the RDF Dataset contains a single default graph and no named graphs:

# Default graph (located at http://example.org/foaf/aliceFoaf)@prefix  foaf:  <http://xmlns.com/foaf/0.1/> ._:a  foaf:name     "Alice" ._:a  foaf:mbox     <mailto:alice@work.example> .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT  ?nameFROM    <http://example.org/foaf/aliceFoaf>WHERE   { ?x foaf:name ?name }

If a query provides more than oneFROM clause, providing more than one IRI to indicate the default graph, then the default graph is theRDF merge of the graphs obtained from representations of the resources identified by the given IRIs.

13.2.2 Specifying Named Graphs

A query can supply IRIs for the named graphs in the RDF Dataset using theFROM NAMED clause. Each IRI is used to provide one named graph in the RDF Dataset. Using the same IRI in two or moreFROM NAMED clauses results in one named graph with that IRI appearing in the dataset.

# Graph: http://example.org/bob@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:a foaf:name "Bob" ._:a foaf:mbox <mailto:bob@oldcorp.example.org> .

# Graph: http://example.org/alice@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:a foaf:name "Alice" ._:a foaf:mbox <mailto:alice@work.example> .

...FROM NAMED <http://example.org/alice>FROM NAMED <http://example.org/bob>...

TheFROM NAMED syntax suggests that the IRI identifies the corresponding graph, but the relationship between an IRI and a graph in an RDF dataset is indirect. The IRI identifies a resource, and the resource is represented by a graph (or, more precisely: by a document that serializes a graph). Forfurther details see [WEBARCH].

13.2.3 Combining FROM and FROM NAMED

TheFROM clause andFROM NAMED clause can be used in the same query.

#Default graph (located at http://example.org/dft.ttl)@prefix dc: <http://purl.org/dc/elements/1.1/> .<http://example.org/bob>    dc:publisher  "Bob Hacker" .<http://example.org/alice>  dc:publisher  "Alice Hacker" .

#Named graph: http://example.org/bob@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:a foaf:name "Bob" ._:a foaf:mbox <mailto:bob@oldcorp.example.org> .

#Named graph: http://example.org/alice@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:a foaf:name "Alice" ._:a foaf:mbox <mailto:alice@work.example.org> .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>PREFIX dc: <http://purl.org/dc/elements/1.1/>SELECT ?who ?g ?mboxFROM <http://example.org/dft.ttl>FROM NAMED <http://example.org/alice>FROM NAMED <http://example.org/bob>WHERE{   ?g dc:publisher ?who .   GRAPH ?g { ?x foaf:mbox ?mbox }}

The RDF Dataset for this query contains a default graph and two named graphs. TheGRAPH keyword is described below.

The actions required to construct the dataset are not determined by thedataset description alone. If an IRI is given twice in a datasetdescription, either by using twoFROM clauses, or aFROM clause and aFROM NAMED clause, then it does not assume that exactly one or exactlytwo attempts are made to obtain an RDF graph associated with the IRI.Therefore, no assumptions can be made about blank node identity intriples obtained from the two occurrences in the dataset description.In general, no assumptions can be made about the equivalence of the graphs.

# Named graph: http://example.org/foaf/aliceFoaf@prefix  foaf:     <http://xmlns.com/foaf/0.1/> .@prefix  rdf:      <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .@prefix  rdfs:     <http://www.w3.org/2000/01/rdf-schema#> ._:a  foaf:name     "Alice" ._:a  foaf:mbox     <mailto:alice@work.example> ._:a  foaf:knows    _:b ._:b  foaf:name     "Bob" ._:b  foaf:mbox     <mailto:bob@work.example> ._:b  foaf:nick     "Bobby" ._:b  rdfs:seeAlso  <http://example.org/foaf/bobFoaf> .<http://example.org/foaf/bobFoaf>     rdf:type      foaf:PersonalProfileDocument .

# Named graph: http://example.org/foaf/bobFoaf@prefix  foaf:     <http://xmlns.com/foaf/0.1/> .@prefix  rdf:      <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .@prefix  rdfs:     <http://www.w3.org/2000/01/rdf-schema#> ._:z  foaf:mbox     <mailto:bob@work.example> ._:z  rdfs:seeAlso  <http://example.org/foaf/bobFoaf> ._:z  foaf:nick     "Robert" .<http://example.org/foaf/bobFoaf>     rdf:type      foaf:PersonalProfileDocument .

13.3.1 Accessing Graph Names

The query below matches the graph pattern against each of the named graphs in the dataset and forms solutions which have thesrc variable bound to IRIs of the graph being matched. The graph pattern is matched with the active graph being each of the named graphs in the dataset.

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT ?src ?bobNickFROM NAMED <http://example.org/foaf/aliceFoaf>FROM NAMED <http://example.org/foaf/bobFoaf>WHERE  {    GRAPH ?src    { ?x foaf:mbox <mailto:bob@work.example> .      ?x foaf:nick ?bobNick    }  }

13.3.2 Restricting by Graph IRI

The query can restrict the matching applied to a specific graph by supplying the graph IRI. This sets the active graph to the graph named by the IRI. This query looks for Bob's nick as given in the graphhttp://example.org/foaf/bobFoaf.

PREFIX foaf: <http://xmlns.com/foaf/0.1/>PREFIX data: <http://example.org/foaf/>SELECT ?nickFROM NAMED <http://example.org/foaf/aliceFoaf>FROM NAMED <http://example.org/foaf/bobFoaf>WHERE  {     GRAPH data:bobFoaf {         ?x foaf:mbox <mailto:bob@work.example> .         ?x foaf:nick ?nick }  }

13.3.3 Restricting Possible Graph IRIs

A variable used in theGRAPH clause may also be used in anotherGRAPH clause or in a graph pattern matched against the default graph in the dataset.

The query below uses the graph with IRIhttp://example.org/foaf/aliceFoaf to find the profile document for Bob; it then matches another pattern against that graph. The pattern in the secondGRAPH clause finds the blank node (variablew) for the person with the same mail box (given by variablembox) as found in the firstGRAPH clause (variablewhom), because the blank node used to match for variablewhom from Alice's FOAF file is not the same as the blank node in the profile document (they are in different graphs).

PREFIX  data:  <http://example.org/foaf/>PREFIX  foaf:  <http://xmlns.com/foaf/0.1/>PREFIX  rdfs:  <http://www.w3.org/2000/01/rdf-schema#>SELECT ?mbox ?nick ?ppdFROM NAMED <http://example.org/foaf/aliceFoaf>FROM NAMED <http://example.org/foaf/bobFoaf>WHERE{  GRAPH data:aliceFoaf  {    ?alice foaf:mbox <mailto:alice@work.example> ;           foaf:knows ?whom .    ?whom  foaf:mbox ?mbox ;           rdfs:seeAlso ?ppd .    ?ppd  a foaf:PersonalProfileDocument .  } .  GRAPH ?ppd  {      ?w foaf:mbox ?mbox ;         foaf:nick ?nick  }}

13.3.4 Named and Default Graphs

Query patterns can involve both the default graph and the named graphs. In this example, an aggregator has read in a Web resource on two different occasions. Each time a graph is read into the aggregator, it is given an IRI by the local system. The graphs are nearly the same but the email address for "Bob" has changed.

In this example, the default graph is being used to record the provenance information and the RDF data actually read is kept in two separate graphs, each of which is given a different IRI by the system. The RDF dataset consists of two named graphs and the information about them.

RDF Dataset:

#Default graph@prefix dc: <http://purl.org/dc/elements/1.1/> .@prefix g:  <tag:example.org,2005-06-06:> .@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .g:graph1 dc:publisher "Bob" .g:graph1 dc:date "2004-12-06"^^xsd:date .g:graph2 dc:publisher "Bob" .g:graph2 dc:date "2005-01-10"^^xsd:date .

#Graph: locally allocated IRI: tag:example.org,2005-06-06:graph1@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:a foaf:name "Alice" ._:a foaf:mbox <mailto:alice@work.example> ._:b foaf:name "Bob" ._:b foaf:mbox <mailto:bob@oldcorp.example.org> .

#Graph: locally allocated IRI: tag:example.org,2005-06-06:graph2@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:a foaf:name "Alice" ._:a foaf:mbox <mailto:alice@work.example> ._:b foaf:name "Bob" ._:b foaf:mbox <mailto:bob@newcorp.example.org> .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>PREFIX dc:   <http://purl.org/dc/elements/1.1/>SELECT ?name ?mbox ?dateWHERE  {  ?g dc:publisher ?name ;        dc:date ?date .    GRAPH ?g      { ?person foaf:name ?name ; foaf:mbox ?mbox }  }

@prefix foaf:        <http://xmlns.com/foaf/0.1/> ._:a  foaf:name       "Alice" ._:a  foaf:mbox       <mailto:alice@work.example> ._:b  foaf:name       "Bob" ._:b  foaf:mbox       <mailto:bob@work.example> .

PREFIX foaf:       <http://xmlns.com/foaf/0.1/>SELECT ?nameWHERE { ?x foaf:name ?name }

Data:

@prefix  foaf:  <http://xmlns.com/foaf/0.1/> ._:x    foaf:name   "Alice" ._:x    foaf:mbox   <mailto:alice@example.com> ._:y    foaf:name   "Alice" ._:y    foaf:mbox   <mailto:asmith@example.com> ._:z    foaf:name   "Alice" ._:z    foaf:mbox   <mailto:alice.smith@example.com> .

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>SELECT ?name WHERE { ?x foaf:name ?name }

The modifiersDISTINCT andREDUCED affect whether duplicates are included in the query results.

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>SELECT DISTINCT ?name WHERE { ?x foaf:name ?name }

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>SELECT REDUCED ?name WHERE { ?x foaf:name ?name }

16.1.1 Projection

Specific variables and their bindings are returned when a list of variable names is given in the SELECT clause. The syntaxSELECT * is an abbreviation that selects all of the variables that arein-scope at that point in the query. It excludes variables only used inFILTER, in the right-hand side ofMINUS, and takes account of subqueries.

Use ofSELECT * is only permitted when the query does not have aGROUP BY clause.

@prefix  foaf:  <http://xmlns.com/foaf/0.1/> ._:a    foaf:name   "Alice" ._:a    foaf:knows  _:b ._:a    foaf:knows  _:c ._:b    foaf:name   "Bob" ._:c    foaf:name   "Clare" ._:c    foaf:nick   "CT" .

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>SELECT ?nameX ?nameY ?nickYWHERE  { ?x foaf:knows ?y ;       foaf:name ?nameX .    ?y foaf:name ?nameY .    OPTIONAL { ?y foaf:nick ?nickY }  }

{  "head": {    "vars": [ "nameX" , "nameY" , "nickY" ]  } ,  "results": {    "bindings": [      {        "nameX": { "type": "literal" , "value": "Alice" } ,        "nameY": { "type": "literal" , "value": "Bob" }      } ,      {        "nameX": { "type": "literal" , "value": "Alice" } ,        "nameY": { "type": "literal" , "value": "Clare" } ,        "nickY": { "type": "literal" , "value": "CT" }      }    ]  }}

<?xml version="1.0"?><sparql xmlns="http://www.w3.org/2005/sparql-results#">  <head>    <variable name="nameX"/>    <variable name="nameY"/>    <variable name="nickY"/>  </head>  <results>    <result>      <binding name="nameX">        <literal>Alice</literal>      </binding>      <binding name="nameY">        <literal>Bob</literal>      </binding>   </result>    <result>      <binding name="nameX">        <literal>Alice</literal>      </binding>      <binding name="nameY">        <literal>Clare</literal>      </binding>      <binding name="nickY">        <literal>CT</literal>      </binding>    </result>  </results></sparql>

16.1.2 SELECT Expressions

As well as choosing which variables from the pattern matching are included in the results, the SELECT clause can also introduce new variables. The rules of assignment in SELECT expression are the same as for assignment in BIND. The expression combines variable bindings already in the query solution, or defined earlier in the SELECT clause, to produce a binding in the query solution.

The scoping for(expr AS v) applies immediately. InSELECT expressions, the variable may be used in an expression later in the sameSELECT clause and may not be be assigned again in the sameSELECT clause.

Example:

@prefix dc:   <http://purl.org/dc/elements/1.1/> .@prefix :     <http://example.org/book/> .@prefix ns:   <http://example.org/ns#> .:book1  dc:title  "SPARQL Tutorial" .:book1  ns:price  42 .:book1  ns:discount 0.2 .:book2  dc:title  "The Semantic Web" .:book2  ns:price  23 .:book2  ns:discount 0.25 .

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>PREFIX  ns:  <http://example.org/ns#>SELECT  ?title (?p*(1-?discount) AS ?price){ ?x ns:price ?p .  ?x dc:title ?title .   ?x ns:discount ?discount }

New variables can also be used in expressions if they are introduced earlier, syntactically, in the same SELECT clause:

PREFIX  dc:  <http://purl.org/dc/elements/1.1/>PREFIX  ns:  <http://example.org/ns#>SELECT  ?title (?p AS ?fullPrice) (?fullPrice*(1-?discount) AS ?customerPrice){ ?x ns:price ?p .   ?x dc:title ?title .    ?x ns:discount ?discount }

@prefix  foaf:  <http://xmlns.com/foaf/0.1/> ._:a    foaf:name   "Alice" ._:a    foaf:mbox   <mailto:alice@example.org> .

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>PREFIX vcard:   <http://www.w3.org/2001/vcard-rdf/3.0#>CONSTRUCT   { <http://example.org/person#Alice> vcard:FN ?name }WHERE       { ?x foaf:name ?name }

@prefix vcard: <http://www.w3.org/2001/vcard-rdf/3.0#> .<http://example.org/person#Alice> vcard:FN "Alice" .

16.2.1Templates with Blank Nodes

A template can create an RDF graph containing blank nodes. The blank node labels are scoped to the template for each solution. If the same label occurs twice in a template, then there will be one blank node created for each query solution, but there will be different blank nodes for triples generated by different query solutions.

@prefix  foaf:  <http://xmlns.com/foaf/0.1/> ._:a    foaf:givenname   "Alice" ._:a    foaf:family_name "Hacker" ._:b    foaf:firstname   "Bob" ._:b    foaf:surname     "Hacker" .

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>PREFIX vcard:   <http://www.w3.org/2001/vcard-rdf/3.0#>CONSTRUCT { ?x  vcard:N _:v .            _:v vcard:givenName ?gname .            _:v vcard:familyName ?fname }WHERE {    { ?x foaf:firstname ?gname } UNION  { ?x foaf:givenname   ?gname } .    { ?x foaf:surname   ?fname } UNION  { ?x foaf:family_name ?fname } . }

@prefix vcard: <http://www.w3.org/2001/vcard-rdf/3.0#> ._:v1 vcard:N         _:x ._:x vcard:givenName  "Alice" ._:x vcard:familyName "Hacker" ._:v2 vcard:N         _:z ._:z vcard:givenName  "Bob" ._:z vcard:familyName "Hacker" .

The use of variablex in the template, which in this example will be bound to blank nodes with labels_:a and_:b in the data, causes different blank node labels (_:v1 and_:v2) in the resulting RDF graph.

16.2.2 Accessing Graphs in the RDF Dataset

UsingCONSTRUCT, it is possible to extract parts or the whole of graphs from the target RDF dataset. This first example returns the graph (if it is in the dataset) with IRI labelhttp://example.org/aGraph; otherwise, it returns an empty graph.

CONSTRUCT { ?s ?p ?o } WHERE { GRAPH <http://example.org/aGraph> { ?s ?p ?o } . }

The access to the graph can be conditional on other information. For example, if the default graph contains metadata about the named graphs in the dataset, then a query like the following one can extract one graph based on information about the named graph:

PREFIX  dc: <http://purl.org/dc/elements/1.1/>PREFIX app: <http://example.org/ns#>PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>CONSTRUCT { ?s ?p ?o } WHERE {   GRAPH ?g { ?s ?p ?o } .   ?g dc:publisher <http://www.w3.org/> .   ?g dc:date ?date .   FILTER ( app:customDate(?date) > "2005-02-28T00:00:00Z"^^xsd:dateTime ) . }

whereapp:customDate identifies anextension function to turn the date format into anxsd:dateTime RDF term.

16.2.3 Solution Modifiers and CONSTRUCT

The solution modifiers of a query affect the results of aCONSTRUCT query. In this example, the output graph from theCONSTRUCT template is formed from just two of the solutions from graph pattern matching. The query outputs a graph with the names of the people with the top two sites, rated by hits. The triples in the RDF graph are not ordered.

@prefix foaf: <http://xmlns.com/foaf/0.1/> .@prefix site: <http://example.org/stats#> ._:a foaf:name "Alice" ._:a site:hits 2349 ._:b foaf:name "Bob" ._:b site:hits 105 ._:c foaf:name "Eve" ._:c site:hits 181 .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>PREFIX site: <http://example.org/stats#>CONSTRUCT { [] foaf:name ?name }WHERE{ [] foaf:name ?name ;     site:hits ?hits .}ORDER BY desc(?hits)LIMIT 2

@prefix foaf: <http://xmlns.com/foaf/0.1/> ._:x foaf:name "Alice" ._:y foaf:name "Eve" .

16.2.4 CONSTRUCT WHERE

A short form for the CONSTRUCT query form is provided for the case where the template and the pattern are the same and the pattern is just a basic graph pattern (noFILTERs and no complex graph patterns are allowed in the short form).The keywordWHERE is required in the short form.

The following two queries are the same; the first is a short form of the second.

PREFIX foaf: <http://xmlns.com/foaf/0.1/>CONSTRUCT WHERE { ?x foaf:name ?name }

PREFIX foaf: <http://xmlns.com/foaf/0.1/>CONSTRUCT { ?x foaf:name ?name } WHERE{ ?x foaf:name ?name }

@prefix foaf:       <http://xmlns.com/foaf/0.1/> ._:a  foaf:name       "Alice" ._:a  foaf:homepage   <http://work.example.org/alice/> ._:b  foaf:name       "Bob" ._:b  foaf:mbox       <mailto:bob@work.example> .

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>ASK  { ?x foaf:name  "Alice" }

true

<?xml version="1.0"?><sparql xmlns="http://www.w3.org/2005/sparql-results#">  <head></head>  <boolean>true</boolean></sparql>

On the same data, the following returns no match because Alice'smbox is not mentioned.

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>ASK  { ?x foaf:name  "Alice" ;          foaf:mbox  <mailto:alice@work.example> }

false

16.4.1 Explicit IRIs

TheDESCRIBE clause itself can take IRIs to identify the resources. The simplestDESCRIBE query is just an IRI in theDESCRIBE clause:

DESCRIBE <http://example.org/>

16.4.2 Identifying Resources

The resources to be described can also be taken from the bindings to a query variable in a result set. This enables description of resources whether they are identified by IRI or by blank node in the dataset:

PREFIX foaf:   <http://xmlns.com/foaf/0.1/>DESCRIBE ?xWHERE    { ?x foaf:mbox <mailto:alice@org> }

The propertyfoaf:mbox is defined as being an inverse functional property in the FOAF vocabulary. If treated as such, this query will return information about at most one person. If, however, the query pattern has multiple solutions, the RDF data for each is the union of all RDF graph descriptions.

PREFIX foaf:   <http://xmlns.com/foaf/0.1/>DESCRIBE ?xWHERE    { ?x foaf:name "Alice" }

More than one IRI or variable can be given:

PREFIX foaf:   <http://xmlns.com/foaf/0.1/>DESCRIBE ?x ?y <http://example.org/>WHERE    {?x foaf:knows ?y}

16.4.3 Descriptions of Resources

The RDF returned is determined by the information publisher. It may be information the service deems relevant to the resources being described.It may include information about other resources: for example, the RDF data for a book may also include details about the author.

A simple query such as

PREFIX ent:  <http://org.example.com/employees#>DESCRIBE ?x WHERE { ?x ent:employeeId "1234" }

@prefix foaf:   <http://xmlns.com/foaf/0.1/> .@prefix vcard:  <http://www.w3.org/2001/vcard-rdf/3.0> .@prefix exOrg:  <http://org.example.com/employees#> .@prefixrdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .@prefix owl:    <http://www.w3.org/2002/07/owl#>_:a     exOrg:employeeId    "1234" ;foaf:mbox_sha1sum   "bee135d3af1e418104bc42904596fe148e90f033" ;        vcard:N         [ vcard:Family       "Smith" ;           vcard:Given        "John"  ] .foaf:mbox_sha1sum  rdf:type  owl:InverseFunctionalProperty .

which includes the blank node closure for thevcard vocabulary vcard:N. Other possible mechanisms for deciding what information to return include Concise Bounded Descriptions [CBD].

For a vocabulary such as FOAF, where the resources are typically blank nodes, returning sufficient information to identify a node such as the InverseFunctionalPropertyfoaf:mbox_sha1sum as well as information like name and other details recorded would be appropriate. In the example, the match to theWHERE clause was returned, but this is not required.

PREFIX a:      <http://www.w3.org/2000/10/annotation-ns#>PREFIX dc:     <http://purl.org/dc/elements/1.1/>PREFIX xsd:    <http://www.w3.org/2001/XMLSchema#>SELECT ?annotWHERE { ?annot  a:annotates  <http://www.w3.org/TR/rdf-sparql-query/> .        ?annot  dc:date      ?date .        FILTER ( ?date > "2005-01-01T00:00:00Z"^^xsd:dateTime ) }

17.2.1 Invocation

SPARQL defines a syntax for invoking functions on a list of arguments. Unless otherwise noted, these are invoked as follows:

• Argument expressions are evaluated, producing argument values. The order of argument evaluation is not defined.
• Numeric arguments are promoted as necessary to fit the expected types for that function or operator.
• The function or operator is invoked on the argument values.

If any of these steps fails, the invocation generates an error. The effects of errors are defined inFilter Evaluation.

There are also "functional forms" which have different evaluation rules to functions as specified by each such form.

17.2.2 Effective Boolean Value (EBV)

Effective boolean value is used to calculate the arguments to the logical functionslogical-and,logical-or, andfn:not, as well as evaluate the result of aFILTER expression.

The XQuery Effective Boolean Value rules rely on the definition of XPath'sfn:boolean. The following rules reflect the rules forfn:boolean applied to the argument types present in SPARQL queries:

• The EBV of any literal whose type isxsd:boolean ornumeric is false if the lexical form is not valid for that datatype (e.g. "abc"^^xsd:integer).
• If the argument is atyped literal with adatatype ofxsd:boolean, and it has a valid lexical form, the EBV is the value of that argument.
• If the argument is aplain literal or atyped literal with adatatype ofxsd:string, the EBV is false if the operand value has zero length; otherwise the EBV is true.
• If the argument is anumeric type or atyped literal with a datatype derived from anumeric type, and it has a valid lexical form, the EBV is false if the operand value is NaN or is numerically equal to zero; otherwise the EBV is true.
• All other arguments, including unbound arguments, produce a type error.

An EBV oftrue is represented as atyped literal with a datatype ofxsd:boolean and a lexical value of "true"; an EBV of false is represented as atyped literal with a datatype ofxsd:boolean and a lexical value of "false".

17.3.1 Operator Extensibility

SPARQL language extensions may provide additional associations between operators and operator functions; this amounts to adding rows to the table above. No additional operator may yield a result that replaces any result other than a type error in the semantics defined above. The consequence of this rule is that SPARQLFILTERs will produceat least the same intermediate bindings after applying aFILTER as an unextended implementation.

Additional mappings of the '<' operator are expected to control the relative ordering of the operands, specifically, when used in anORDER BY clause.

17.4.1 Functional Forms

xsd:booleanBOUND (variablevar)

@prefix foaf:        <http://xmlns.com/foaf/0.1/> .@prefix dc:          <http://purl.org/dc/elements/1.1/> .@prefix xsd:          <http://www.w3.org/2001/XMLSchema#> ._:a  foaf:givenName  "Alice"._:b  foaf:givenName  "Bob" ._:b  dc:date         "2005-04-04T04:04:04Z"^^xsd:dateTime .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>PREFIX dc:   <http://purl.org/dc/elements/1.1/>PREFIX xsd:   <http://www.w3.org/2001/XMLSchema#>SELECT ?givenName WHERE { ?x foaf:givenName  ?givenName .         OPTIONAL { ?x dc:date ?date } .         FILTER ( bound(?date) ) }

PREFIX foaf: <http://xmlns.com/foaf/0.1/>PREFIX dc:   <http://purl.org/dc/elements/1.1/>SELECT ?name WHERE { ?x foaf:givenName  ?name .         OPTIONAL { ?x dc:date ?date } .         FILTER (!bound(?date)) }

rdfTermIF (expression1,expression2,expression3)

rdfTermCOALESCE(expression, ....)

xsd:booleanNOT EXISTS {pattern }

xsd:booleanEXISTS {pattern }

xsd:booleanxsd:booleanleft||xsd:booleanright

xsd:booleanxsd:booleanleft&&xsd:booleanright

xsd:booleanRDF termterm1=RDF termterm2

@prefix foaf:       <http://xmlns.com/foaf/0.1/> ._:a  foaf:name       "Alice"._:a  foaf:mbox       <mailto:alice@work.example> ._:b  foaf:name       "Ms A."._:b  foaf:mbox       <mailto:alice@work.example> .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT ?name1 ?name2WHERE { ?x foaf:name  ?name1 ;        foaf:mbox  ?mbox1 .        ?y foaf:name  ?name2 ;        foaf:mbox  ?mbox2 .        FILTER (?mbox1 = ?mbox2 && ?name1 != ?name2)      }

@prefix a:          <http://www.w3.org/2000/10/annotation-ns#> .@prefix dc:         <http://purl.org/dc/elements/1.1/> ._:b   a:annotates   <http://www.w3.org/TR/rdf-sparql-query/> ._:b   dc:date       "2004-12-31T19:00:00-05:00"^^<http://www.w3.org/2001/XMLSchema#dateTime> .

PREFIX a:      <http://www.w3.org/2000/10/annotation-ns#>PREFIX dc:     <http://purl.org/dc/elements/1.1/>PREFIX xsd:    <http://www.w3.org/2001/XMLSchema#>SELECT ?annotatesWHERE { ?annot  a:annotates  ?annotates .        ?annot  dc:date      ?date .        FILTER ( ?date = xsd:dateTime("2005-01-01T00:00:00Z") )       }

xsd:booleansameTerm (RDF termterm1,RDF termterm2)

@prefix foaf:       <http://xmlns.com/foaf/0.1/> ._:a  foaf:name       "Alice"._:a  foaf:mbox       <mailto:alice@work.example> ._:b  foaf:name       "Ms A."._:b  foaf:mbox       <mailto:alice@work.example> .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT ?name1 ?name2WHERE { ?x foaf:name  ?name1 ;        foaf:mbox  ?mbox1 .         ?y foaf:name  ?name2 ;         foaf:mbox  ?mbox2 .         FILTER (sameTerm(?mbox1, ?mbox2) && !sameTerm(?name1, ?name2))      }

@prefix :          <http://example.org/WMterms#> .@prefix t:         <http://example.org/types#> ._:c1  :label        "Container 1" ._:c1  :weight       "100"^^t:kilos ._:c1  :displacement  "100"^^t:liters ._:c2  :label        "Container 2" ._:c2  :weight       "100"^^t:kilos ._:c2  :displacement  "85"^^t:liters ._:c3  :label        "Container 3" ._:c3  :weight       "85"^^t:kilos ._:c3  :displacement  "85"^^t:liters .

PREFIX  :      <http://example.org/WMterms#>PREFIX  t:     <http://example.org/types#>SELECT ?aLabel1 ?bLabelWHERE { ?a  :label        ?aLabel .        ?a  :weight       ?aWeight .        ?a  :displacement ?aDisp .        ?b  :label        ?bLabel .        ?b  :weight       ?bWeight .        ?b  :displacement ?bDisp .        FILTER ( sameTerm(?aWeight, ?bWeight) && !sameTerm(?aDisp, ?bDisp)) }

booleanrdfTermIN (expression,...)

(lhs = expression1) || (lhs = expression2) || ...

booleanrdfTermNOT IN (expression,...)

(lhs != expression1) && (lhs != expression2) && ...

17.4.2 Functions on RDF Terms

xsd:booleanisIRI (RDF termterm)xsd:booleanisURI (RDF termterm)

@prefix foaf:       <http://xmlns.com/foaf/0.1/> ._:a  foaf:name       "Alice"._:a  foaf:mbox       <mailto:alice@work.example> ._:b  foaf:name       "Bob" ._:b  foaf:mbox       "bob@work.example" .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT ?name ?mbox WHERE { ?x foaf:name  ?name ;            foaf:mbox  ?mbox .         FILTER isIRI(?mbox) }

xsd:booleanisBlank (RDF termterm)

@prefix a:          <http://www.w3.org/2000/10/annotation-ns#> .@prefix dc:         <http://purl.org/dc/elements/1.1/> .@prefix foaf:       <http://xmlns.com/foaf/0.1/> ._:a   a:annotates   <http://www.w3.org/TR/rdf-sparql-query/> ._:a   dc:creator    "Alice B. Toeclips" ._:b   a:annotates   <http://www.w3.org/TR/rdf-sparql-query/> ._:b   dc:creator    _:c ._:c   foaf:given    "Bob"._:c   foaf:family   "Smith".

PREFIX a:      <http://www.w3.org/2000/10/annotation-ns#>PREFIX dc:     <http://purl.org/dc/elements/1.1/>PREFIX foaf:   <http://xmlns.com/foaf/0.1/>SELECT ?given ?familyWHERE { ?annot  a:annotates  <http://www.w3.org/TR/rdf-sparql-query/> .  ?annot  dc:creator   ?c .  OPTIONAL { ?c  foaf:given   ?given ; foaf:family  ?family } .  FILTER isBlank(?c)}

xsd:booleanisLiteral (RDF termterm)

@prefix foaf:       <http://xmlns.com/foaf/0.1/> .              _:a  foaf:name       "Alice"._:a  foaf:mbox       <mailto:alice@work.example> ._:b  foaf:name       "Bob" ._:b  foaf:mbox       "bob@work.example" .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT ?name ?mboxWHERE { ?x foaf:name  ?name ;        foaf:mbox  ?mbox .        FILTER isLiteral(?mbox) }

xsd:booleanisNumeric (RDF termterm)

simple literalSTR (literalltrl)simple literalSTR (IRIrsrc)

@prefix foaf:       <http://xmlns.com/foaf/0.1/> ._:a  foaf:name       "Alice"._:a  foaf:mbox       <mailto:alice@work.example> ._:b  foaf:name       "Bob" ._:b  foaf:mbox       <mailto:bob@home.example> .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT ?name ?mbox WHERE { ?x foaf:name  ?name ;            foaf:mbox  ?mbox .         FILTER regex(str(?mbox), "@work\\.example$") }

simple literalLANG (literalltrl)

@prefix foaf:       <http://xmlns.com/foaf/0.1/> ._:a  foaf:name       "Robert"@en._:a  foaf:name       "Roberto"@es._:a  foaf:mbox       <mailto:bob@work.example> .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT ?name ?mbox WHERE { ?x foaf:name  ?name ;            foaf:mbox  ?mbox .         FILTER ( lang(?name) = "es" ) }

iriDATATYPE (literalliteral)

@prefix foaf:       <http://xmlns.com/foaf/0.1/> .@prefix eg:         <http://biometrics.example/ns#> .@prefix xsd:        <http://www.w3.org/2001/XMLSchema#> ._:a  foaf:name       "Alice"._:a  eg:shoeSize     "9.5"^^xsd:float ._:b  foaf:name       "Bob"._:b  eg:shoeSize     "42"^^xsd:integer .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>PREFIX xsd:  <http://www.w3.org/2001/XMLSchema#>PREFIX eg:   <http://biometrics.example/ns#>SELECT ?name ?shoeSize WHERE { ?x foaf:name  ?name ; eg:shoeSize  ?shoeSize .         FILTER ( datatype(?shoeSize) = xsd:integer ) }

iriIRI(simple literal)iriIRI(xsd:string)iriIRI(iri)iriURI(simple literal)iriURI(xsd:string)iriURI(iri)

blank nodeBNODE()

blank nodeBNODE(simple literal)

blank nodeBNODE(xsd:string)

literalSTRDT(simple literal lexicalForm,IRI datatypeIRI)

literalSTRLANG(simple literal lexicalForm,simple literal langTag)

iriUUID()

simple literalSTRUUID()

17.4.3 Functions on Strings

xsd:integerSTRLEN(string literal str)

string literalSUBSTR(string literal source,xsd:integer startingLoc)

string literalSUBSTR(string literal source,xsd:integer startingLoc,xsd:integer length)

string literalUCASE(string literal str)

string literalLCASE(string literal str)

xsd:booleanSTRSTARTS(string literal arg1,string literal arg2)

xsd:booleanSTRENDS(string literal arg1,string literal arg2)

xsd:booleanCONTAINS(string literal arg1,string literal arg2)

literalSTRBEFORE(string literal arg1,string literal arg2)

literalSTRAFTER(string literal arg1,string literal arg2)

simple literalENCODE_FOR_URI(string literal ltrl)

string literalCONCAT(string literalltrl1 ...string literalltrln)

xsd:booleanlangMatches (simple literallanguage-tag,simple literallanguage-range)

@prefix dc:       <http://purl.org/dc/elements/1.1/> ._:a  dc:title         "That Seventies Show"@en ._:a  dc:title         "Cette Série des Années Soixante-dix"@fr ._:a  dc:title         "Cette Série des Années Septante"@fr-BE ._:b  dc:title         "Il Buono, il Bruto, il Cattivo" .

PREFIX dc: <http://purl.org/dc/elements/1.1/>SELECT ?title WHERE { ?x dc:title  "That Seventies Show"@en ;            dc:title  ?title .         FILTER langMatches( lang(?title), "FR" ) }

PREFIX dc: <http://purl.org/dc/elements/1.1/>SELECT ?title WHERE { ?x dc:title  ?title .         FILTER langMatches( lang(?title), "*" ) }

xsd:booleanREGEX (string literaltext,simple literalpattern)xsd:booleanREGEX (string literaltext,simple literalpattern,simple literalflags)

@prefix foaf:       <http://xmlns.com/foaf/0.1/> ._:a  foaf:name       "Alice"._:b  foaf:name       "Bob" .

PREFIX foaf: <http://xmlns.com/foaf/0.1/>SELECT ?name WHERE { ?x foaf:name  ?name         FILTER regex(?name, "^ali", "i") }

string literalREPLACE (string literal arg,simple literal pattern,simple literal replacement )string literalREPLACE (string literal arg,simple literal pattern,simple literal replacement,simple literal flags)

17.4.4 Functions on Numerics

numericABS (numericterm)

numericROUND (numericterm)

numericCEIL (numericterm)

numericFLOOR (numericterm)

xsd:doubleRAND ( )

17.4.5 Functions on Dates and Times

xsd:dateTimeNOW ()

xsd:integerYEAR (xsd:dateTimearg)

xsd:integerMONTH (xsd:dateTimearg)

xsd:integerDAY (xsd:dateTimearg)

xsd:integerHOURS (xsd:dateTimearg)

xsd:integerMINUTES (xsd:dateTimearg)

xsd:decimalSECONDS (xsd:dateTimearg)

xsd:dayTimeDurationTIMEZONE (xsd:dateTimearg)

simple literalTZ (xsd:dateTimearg)

17.4.6 Hash Functions

simple literalMD5 (simple literalarg)

simple literalMD5 (xsd:stringarg)

simple literalSHA1 (simple literalarg)

simple literalSHA1 (xsd:stringarg)

simple literalSHA256 (simple literalarg)

simple literalSHA256 (xsd:stringarg)

simple literalSHA384 (simple literalarg)

simple literalSHA384 (xsd:stringarg)

simple literalSHA512 (simple literalarg)

simple literalSHA512 (xsd:stringarg)

18.1.1 RDF Terms

SPARQL is defined in terms of IRIs [RFC3987]. IRIs are a subset of RDF URI References that omits the use of spaces.

This definition ofRDF Term collects together several basic notions from theRDF data model, butupdated to refer to IRIs rather than RDF URI references.

18.1.2 Simple Literal

18.1.3 RDF Dataset

18.1.4 Query Variables

18.1.5 Triple Patterns

This definition of Triple Pattern includes literal subjects.This has been noted by RDF-core.

"[The RDF core Working Group] noted that it is aware of no reason why literals shouldnot be subjects and a future WG with a less restrictive charter mayextend the syntaxes to allow literals as the subjects of statements."

Because RDF graphs may not contain literal subjects, any SPARQL triple pattern with a literal as subject will fail to match on any RDF graph.

18.1.6 Basic Graph Patterns

The empty graph pattern is a basic graph pattern which is the empty set.

18.1.7 Property Path Patterns

A property path does not span multiple graphs in a dataset.

A Property Path Pattern is a generalization of aTriple Pattern to include a property path expression in the property position.

18.1.8 Solution Mapping

A solution mapping is a mapping from a set of variables to a set of RDF terms. We use the term 'solution' where it is clear.

Write expr(μ) for the value of the expression expr, using the terms for variables given by μ. Evaluation may result in an error.

18.1.9 Solution Sequence Modifiers

18.1.10 SPARQL Query

A query is a tree of "query levels", where eachsubquery forms one query level in the tree.

18.2.1 Variable Scope

We define a variable to bein-scope if there is a way for a variable to be in the domain of a solution mapping at that point in the execution of the SPARQL algebra for the query. The definition below provides a way of determing this from the abstract syntax of a query.

Note that a subquery with a projection can hide variables; use of a variable inFILTER, or inMINUS does not cause a variable to be in-scope outside of those forms.

LetP,P1,P2 be graph patterns andE,E1,...En be expressions. A variablev is in-scope if:

The variablev must not be in-scope at the point of the(expr AS v) form. The scoping for(expr AS v) applies immediately inSELECT expressions.

InBIND (expr AS v) requires that the variablev is not in-scope from the preceeding elements in the group graph pattern in which it is used.

InSELECT, the variablev must not be in-scope in the graph pattern of theSELECT clause, nor used in another select expression earlier in the clause.

18.2.2 Converting Graph Patterns

This section describes the process for translating a SPARQL graph pattern into a SPARQL algebra expression. This process is applied to the group graph pattern (the unit between{...} delimiters) forming theWHERE clause of a query, and recursively to each syntactic element within the group graph pattern. The result of the translation is a SPARQL algebra expression.

In summary, the steps are applied as follows:

• Expand syntax forms for IRIs, literals and triple patterns.
• Translate property path expressions
• Convert some property path patterns to triples
• Collect theFILTERs in the group
• Translate Basic Graph Patterns
• Translate the remaining graph patterns in the group
• Add in Filters
• Simplify the algebra expression

We write

translate(graph pattern)

for the algorthm described here to translate graph patterns.

OPTIONAL { { ... FILTER ( ... ?x ... ) } }..

Applying the simpification step after all the translation of graph patterns is the preferred reading.

Let FS := empty setFor each form FILTER(expr) in the group graph pattern:    In expr, replace NOT EXISTS{P} with fn:not(exists(translate(P)))     In expr, replace EXISTS{P} withexists(translate(P))    FS := FS ∪ {expr}    End

Let A := undefined          For each element G in the GroupOrUnionGraphPattern    If A is undefined        A := Translate(G)    Else        A := Union(A, Translate(G))    EndThe result is A

If the form is GRAPH IRI GroupGraphPattern    The result is Graph(IRI, Translate(GroupGraphPattern))

If the form is GRAPH Var GroupGraphPattern    The result is Graph(Var, Translate(GroupGraphPattern))

Let FS := the empty setLet G := the empty pattern, a basic graph pattern which is the empty set.For each element E in the GroupGraphPattern    If E is of the form OPTIONAL{P}         Let A := Translate(P)        If A is of the form Filter(F, A2)            G := LeftJoin(G, A2, F)        Else             G := LeftJoin(G, A, true)            End        End    If E is of the form MINUS{P}        G := Minus(G, Translate(P))        End    If E is of the form BIND(expr AS var)        G := Extend(G, var, expr)        End    If E is any other form         Let A := Translate(E)        G := Join(G, A)        End   End   The result is G.

The result is a multiset of solution mappings 'data'.

The result is ToMultiset(Translate(SubSelect))

If FS is not empty    Let G := output of preceding step    Let X := Conjunction of expressions in FS    G := Filter(X, G)    End

Replace join(Z, A) by AReplace join(A, Z) by A

18.2.3 Examples of Mapped Graph Patterns

The second form of a rewrite example is the first with empty group joins removed by the simplification step.

Example: group with a basic graph pattern consisting of a single triple pattern:

Example: group with a basic graph pattern consisting of two triple patterns:

Example: group consisting of a union of two basic graph patterns:

Example: group consisting of a union of a union and a basic graph pattern:

Example: group consisting of a basic graph pattern and an optional graph pattern:

Example: group consisting of a basic graph pattern and two optional graph patterns:

Example: group consisting of a basic graph pattern and an optional graph pattern with a filter:

Example: group consisting of a union graph pattern and an optional graph pattern:

Example: group consisting of a basic graph pattern, a filter and an optional graph pattern:

Example: Pattern involving BIND:

Example: Pattern involving BIND:

Example: Pattern involving MINUS:

Example: Pattern involving a subquery:

18.2.4 Converting Groups, Aggregates, HAVING, final VALUES clause and SELECT Expressions

In this step, we process clauses on the query level in the following order:

• Grouping
• Aggregates
• HAVING
• VALUES
• Select expressions

Let A := the empty sequenceLet Q := the query level being evaluatedLet P := the algebra translation of the GroupGraphPattern of the query levelLet E := [], a list of pairs of the form (variable, expression)If Q contains GROUP BY exprlist   Let G := Group(exprlist, P)Else If Q contains an aggregate in SELECT, HAVING, ORDER BY   Let G := Group((1), P)Else   skip the rest of the aggregate step   EndGlobal i := 1   # Initially 1 for each query processedFor each (X AS Var) in SELECT, each HAVING(X), and each ORDER BY X in Q  For each unaggregated variable V in X      Replace V with Sample(V)      End  For each aggregate R(args ; scalarvals) now in X      # note scalarvals may be omitted, then it's equivalent to the empty set      Ai := Aggregation(args, R, scalarvals, G)      Replace R(...) with aggi in Q      i := i + 1      End  EndFor each variable V appearing outside of an aggregate   Ai := Aggregation(V, Sample, {}, G)   E := E append (V, aggi)   i := i + 1   EndA := Ai, ..., Ai-1P := AggregateJoin(A)

PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>SELECT (SUM(?val) AS ?sum) (COUNT(?a) AS ?count)WHERE {  ?a rdf:value ?val .} GROUP BY ?a

Let G := Group((?a), BGP(?a rdf:value ?val))A1 = Aggregation((?val), Sum, {}, G)A2 = Aggregation((?a), Count, {}, G)A := (A1, A2)Let P := AggregateJoin(A)

Let Q := the query level being evaluatedLet P := the algebra translation of the query level so farFor each HAVING(E) in Q    P := Filter(E, P)    End

Let P := the algebra translation of the query level so farP := Join(P, ToMultiSet(data))  wheredata is a solution sequence formed from the VALUES clause

SELECT selItem ... { pattern }SELECT * { pattern }

Let X := algebra from earlier stepsLet VS := list of all variables visible in the pattern,           so restricted by sub-SELECT projected variables and GROUP BY variables.           Not visible: only in filter, exists/not exists, masked by a subselect,                         non-projected GROUP variables, only in the right hand side of MINUSLet PV := {}, a set of variable namesNote, E is a list of pairs of the form (variable, expression), defined insection 18.2.4  If "SELECT *"    PV := VSIf  "SELECTselItem ...:"      For each selItem:        If selItem is a variable            PV := PV ∪ { variable }        End        If selItem is (expr AS variable)            variable must not appear in VS nor in PV; if it does then generate a syntax error and stop            PV := PV ∪ { variable }            E := E append (variable, expr)         End    EndFor each pair (var, expr) in E    X := Extend(X, var, expr)    End  Result is X  The set PV is used later for projection.

18.2.5 Converting Solution Modifiers

Solutions modifiers apply to the processing of a SPARQL query after pattern matching. The solution modifiers are applied to a query in the following order:

• Order by
• Projection
• Distinct
• Reduced
• Offset
• Limit

Step: ToList

ToList turns a multiset into a sequence with the same elements and cardinality. There is no implied ordering to the sequence; duplicates need not be adjacent.

Let M := ToList(Pattern)

Two solution mappings μ₁ and μ₂ are compatible if, for every variable v in dom(μ₁) and in dom(μ₂), μ₁(v) = μ₂(v).

18.3.1 SPARQL Basic Graph Pattern Matching

A basic graph pattern is matched against the active graph for that part of the query. Basic graph patterns can be instantiated by replacing both variables and blank nodes by terms, giving two notions of instance. Blank nodes are replaced using anRDF instance mapping,  σ, from blank nodes to RDF terms; variables are replaced by a solution mapping from query variables to RDF terms.

For a BGP 'x', P(x) denotes the result of replacing blank nodes b in x for which σ is defined with σ(b) and all variables v in x for which μ is defined with μ(v).

Any pattern instance mapping defines a unique solution mapping and a unique RDF instance mapping obtained by restricting it to query variables and blank nodes respectively.

If a basic graph pattern is the empty set, then the solution is Ω₀.

18.3.2 Treatment of Blank Nodes

This definition allows the solution mapping to bind a variable in a basic graph pattern, BGP, to a blank node in G. Since SPARQL treats blank node identifiers in a results format document (SPARQL Query Results XML Format,SPARQL 1.1 Query Results JSON Format andSPARQL 1.1 Query Results CSV and TSV Formats) as scoped to the document, they cannot be understood as identifying nodes in the active graph of the dataset. If DS is the dataset of a query, pattern solutions are therefore understood to be not from the active graph of DS itself, but from an RDF graph, called thescoping graph, which is graph-equivalent to the active graph of DS but shares no blank nodes with DS or with BGP. The same scoping graph is used for all solutions to a single query. The scoping graph is purely a theoretical construct; in practice, the effect is obtained simply by the document scope conventions for blank node identifiers.

Since RDF blank nodes allow infinitely many redundant solutions for many patterns, there can be infinitely many pattern solutions (obtained by replacing blank nodes by different blank nodes). It is necessary, therefore, to somehow delimit the solutions for a basic graph pattern. SPARQL uses the subgraph match criterion to determine the solutions of a basic graph pattern. There is one solution for each distinct pattern instance mapping from the basic graph pattern to a subset of the active graph.

This is optimized for ease of computation rather than redundancy elimination. It allows query results to contain redundancies even when the active graph of the dataset islean, and it allows logically equivalent datasets to yield different query results.

Notation

Write

eval(Path(X, PP, Y))

for the evaluation of the property path patterns. This produces a multiset of solution mappings μ, each solution mapping having a binding for variables used (each of X and Y can be a variable). Some operators only produce a set of solution mappings.

Write

for the variables inx1, x2, ..., xn.

Write

Definition:Evaluation of Predicate Property Path

Let Path(X, link(iri), Y) be an predicate inverse property path pattern,using some IRI iri.

eval(Path(X, link(iri), Y)) =evaluation of basic graph pattern {X iri Y}

Definition:Evaluation of Inverse Property Path

Let P be a property path expression, then:

eval(Path(X, inv(P), Y)) = eval(Path(Y, P, X))

Definition:Evaluation of Sequence Property Path

Let P and Q be property path expressions. Let V be a fresh variable.

A = Join( eval(Path(X, P, V)), eval(Path(V, Q, Y)) )

eval(Path(X, seq(P,Q), Y)) = Project(A, Var(X,Y))

Definition:Evaluation of Alternative Property Path

Let P and Q be property path expressions.

eval(Path(X, alt(P,Q), Y)) = Union(eval(Path(X, P, Y)), eval(Path(X, Q, Y)))

Definition:Node set of a graph

The node set of a graph G, nodes(G), is:

nodes(G) = { n | n is an RDF term that is used as a subject or object of a triple of G}

Definition:Evaluation of ZeroOrOnePath

eval(Path(X:term, ZeroOrOnePath(P), Y:var)) = { (Y, yn) | yn = X or {(Y, yn)} in eval(Path(X,P,Y)) }

eval(Path(X:var, ZeroOrOnePath(P), Y:term)) = { (X, xn) | xn = Y or {(X, xn)} in eval(Path(X,P,Y)) }

eval(Path(X:term, ZeroOrOnePath(P), Y:term)) =     { {} } if X = Y or eval(Path(X,P,Y)) is not empty    { } othewise

eval(Path(X:var, ZeroOrOnePath(P), Y:var)) =     { (X, xn) (Y, yn) | either (yn in nodes(G) and xn = yn) or {(X,xn), (Y,yn)} in eval(Path(X,P,Y)) }

Definition:Function ALP

Let eval(x:term, path) be the evaluation of 'path', starting at RDF term x,                        and returning a multiset of RDF terms reached                        by repeated matches of path.ALP(x:term, path) =     Let V = empty multiset    ALP(x:term, path, V)    return is V# V is the set of nodes visitedALP(x:term, path, V:set of RDF terms) =    if ( x in V ) return     add x to V    X = eval(x,path)     For n:term in X        ALP(n, path, V)        End

Definition: Evaluation ofZeroOrMorePath

eval(Path(X:term, ZeroOrMorePath(path), vy:var)) =    { { (vy, n) } | n in ALP(X, path) }eval(Path(vx:var, ZeroOrMorePath(path), vy:var)) =    { { (vx, t), (vy, n) } |  t in nodes(G), (vy, n) in eval(Path(t, ZeroOrMorePath(path), vy)) }eval(Path(vx:var, ZeroOrMorePath(path), y:term)) =     eval(Path(y:term, ZeroOrMorePath(inv(path)), vx:var))eval(Path(x:term, ZeroOrMorePath(path), y:term)) =     { { } } if { (vy:var,y) } in eval(Path(x, ZeroOrMorePath(path) vy)    { } otherwise

Definition: Evaluation ofOneOrMorePath

eval(Path(X, OneOrMorePath(path), Y))

# For OneOrMorePath, we take one step of the path then start# recording nodes for results.eval(Path(x:term, OneOrMorePath(path), vy:var)) =    Let X = eval(x, path)    Let V = the empty multiset    For n in X        ALP(n, path, V)        End    result is Veval(Path(vx:var, OneOrMorePath(path), vy:var)) =   { { (vx, t), (vy, n) } |  t in nodes(G), (vy, n) in eval(Path(t, OneOrMorePath(path), vy)) }eval(Path(vx:var, OneOrMorePath(path), y:term)) =   eval(Path(y:term, OneOrMorePath(inv(path)), vx))eval(Path(x:term, OneOrMorePath(path), y:term)) =    { { } } if { (vy:var, y) } in eval(Path(x, OneOrMorePath(path), vy))    { } otherwise

Definition:Evaluation of NegatedPropertySet

Write μ' as the extension of a solution mapping:μ'(μ,x) = μ(x)   if x is a variableμ'(μ,t) = t   if t is a RDF term

Let x and y be variables or RDF terms, and S a set of IRIs:eval(Path(x, NPS(S), y)) = { μ | ∃ triple(μ'(μ,x), p, μ'(μ,y)) in G, such that the IRI of p ∉ S }

Definition:Filter

Let Ω be a multiset of solution mappings and expr be an expression. We define:

Filter(expr, Ω, D(G)) = { μ | μ in Ω and expr(μ) is an expression that has an effective boolean value of true }

card[Filter(expr, Ω, D(G))](μ) = card[Ω](μ)

Note that evaluating anexists(pattern) expression uses the dataset and active graph, D(G). See theevaluation of filter.

Definition:Join

Let Ω₁ and Ω₂ be multisets of solution mappings. We define:

Join(Ω₁, Ω₂) = { merge(μ₁, μ₂) | μ₁ in Ω₁and μ₂ in Ω₂, and μ₁ and μ₂ are compatible }

card[Join(Ω₁, Ω₂)](μ) =
    for each merge(μ₁, μ₂), μ₁ in Ω₁and μ₂ in Ω₂ such that μ = merge(μ₁, μ₂),
        sum over (μ₁, μ₂), card[Ω₁](μ₁)*card[Ω₂](μ₂)

Definition:Diff

Let Ω₁ and Ω₂ be multisets of solution mappings and expr be an expression. We define:

Diff(Ω₁, Ω₂, expr) = { μ | μ in Ω₁ such that ∀ μ′ in Ω₂, either μ and μ′ are not compatible or μ and μ' are compatible and expr(merge(μ, μ')) has an effective boolean value of false }

card[Diff(Ω₁, Ω₂, expr)](μ) = card[Ω₁](μ)

Definition:LeftJoin

Let Ω₁ and Ω₂ be multisets of solution mappings and expr be an expression. We define:

LeftJoin(Ω₁, Ω₂, expr) = Filter(expr, Join(Ω₁, Ω₂)) ∪ Diff(Ω₁, Ω₂, expr)

card[LeftJoin(Ω₁, Ω₂, expr)](μ) = card[Filter(expr, Join(Ω₁, Ω₂))](μ) + card[Diff(Ω₁, Ω₂, expr)](μ)

Definition:Union

Let Ω₁ and Ω₂ be multisets of solution mappings. We define:

Union(Ω₁, Ω₂) = { μ | μ in Ω₁ or μ in Ω₂ }

card[Union(Ω₁, Ω₂)](μ) = card[Ω₁](μ) + card[Ω₂](μ)

Definition:Minus

Let Ω₁ and Ω₂ be multisets of solution mappings. We define:

Minus(Ω₁, Ω₂) = { μ | μ in Ω₁ . ∀ μ' in Ω₂, either μ and μ' are not compatible or dom(μ) and dom(μ') are disjoint }

card[Minus(Ω₁, Ω₂)](μ) = card[Ω₁](μ)

Let μ be a solution mapping, Ω a multiset of solution mappings,var a variable andexpr be anexpression, then we define:

Extend(μ, var, expr) = μ ∪ { (var,value) | var not in dom(μ) and value = expr(μ) }

Extend(μ, var, expr) = μ if var not in dom(μ) and expr(μ) is an error

Extend is undefined when var in dom(μ).

Extend(Ω, var, expr) = { Extend(μ, var, expr) | μ in Ω }

Let Ω be a multiset of solution mappings. We define:

ToList(Ω) = a sequence of mappings μ in Ω in any order, with card[Ω](μ) occurrences of μ

card[ToList(Ω)](μ) = card[Ω](μ)

Let Ψ be a sequence of solution mappings. We define:

OrderBy(Ψ, condition) = [ μ | μ in Ψ and the sequence satisfies the ordering condition]

card[OrderBy(Ψ, condition)](μ) = card[Ψ](μ)

Let Ψ be a sequence of solution mappings and PV a set of variables.

For mapping μ, write Proj(μ, PV) to be the restriction of μ to variables in PV.

Project(Ψ, PV) = [ Proj(Ψ[μ], PV) | μ in Ψ ]

card[Project(Ψ, PV)](μ) = card[Ψ](μ)

The order of Project(Ψ, PV) must preserve any ordering given by OrderBy.

Let Ψ be a sequence of solution mappings. We define:

Distinct(Ψ) = [ μ | μ in Ψ ]

card[Distinct(Ψ)](μ) = 1

The order of Distinct(Ψ) must preserve any ordering given by OrderBy.

Let Ψ be a sequence of solution mappings. We define:

Reduced(Ψ) = [ μ | μ in Ψ ]

card[Reduced(Ψ)](μ) is between 1 and card[Ψ](μ)

The order of Reduced(Ψ) must preserve any ordering given by OrderBy.

Let Ψ be a sequence of solution mappings. We define:

Slice(Ψ, start, length)[i] = Ψ[start+i] for i = 0 to (length-1)

Let Ψ be a solution sequence. We define:

ToMultiSet(Ψ) = { μ | μ in Ψ }

card[ToMultiSet(Ψ)](μ) = card[Ψ](μ)

Definition: ToMultiset

ToMultiset turns a sequence into a multiset with the same elements and cardinality as the sequence. The order of the sequence has no effect on the resulting multiset, and duplicates are preserved.

Definition:Exists

exists(pattern) is a function that returns true if the patternevaluates to a non-empty solution sequence, given the current solution mapping and active graph at the time of evaluation; otherwise it returns false.

18.5.1 Aggregate Algebra

Group is a function which groups a solution sequence into multiple solutions, based on some attribute of the solutions.

Note that, although the result of a ListEval can be an error, and errors may be used to group, solutions containing error values are removed at projection time.

ListEval((unbound), μ) = (error), as the evaluation of an unbound expression is an error.

Aggregation, a function which calculates a scalar value as an output of the aggregate expression. It is used in the SELECT clause, the HAVING evaluation process, and in ORDER BY (where required). Aggregation calculates aggregated values over groups of solutions, using set functions.

scalarvals are used to pass values to the underlying set function,bypassing the mechanics of the grouping. For example, the aggregateexpressionGROUP_CONCAT(?x ; separator="|") has a scalarvals argumentof { "separator" → "|" }.

All aggregates may have theDISTINCTkeyword as the first token in their argument list. If this keyword ispresent then first argument to func is Distinct(M).

Example

Given a solution multiset (Ω) with the following values:

And the query expression SELECT (ex:agg(?y, ?z) AS ?agg) WHERE { ?x ?y ?z } GROUP BY ?x.

We produce G = Group((?x), Ω) = { ( (1), { μ₁, μ₂ } ), ( (2), { μ₃ } ) }

And so Aggregation((?y, ?z), ex:agg, {}, G) =
{ ((1), eg:agg({(2, 3), (3, 4)}, {})), ((2), eg:agg({(5, 6)}, {})) }.

Flatten is a function which is used to collapse multisets of lists into a multiset, so for example { (1, 2), (3, 4) } becomes { 1, 2, 3, 4 }.

eval(D(G), BGP) = multiset of solution mappings

See sectionBasic Graph Patterns

eval(D(G), Path(X, path, Y)) = multiset of solution mappings

See sectionProperty Path Expresions

eval(D(G), Filter(F, P)) = Filter(F, eval(D(G),P), D(G))

Definition:Substitute

Let μ be a solution mapping.

substitute(pattern, μ) = the pattern formed by replacing every occurrence of a variable v inpattern by μ(v) for each v in dom(μ)

Definition:Evaluation of Exists

Let μ be the current solution mapping for a filter and P a graph pattern:

The value exists(P), given D(G) is true if and only if eval(D(G), substitute(P, μ)) is a non-empty sequence.

eval(D(G), Join(P1, P2)) = Join(eval(D(G), P1), eval(D(G), P2))

eval(D(G), LeftJoin(P1, P2, F)) = LeftJoin(eval(D(G), P1), eval(D(G), P2), F)

eval(D(G), Union(P1,P2)) = Union(eval(D(G), P1), eval(D(G), P2))

if IRI is a graph name in Deval(D(G), Graph(IRI,P)) = eval(D(D[IRI]), P)

if IRI is not a graph name in Deval(D(G), Graph(IRI,P)) = the empty multiset

eval(D(G), Graph(var,P)) =     Let R be the empty multiset     foreach IRI i in D        R := Union(R, Join( eval(D(D[i]), P) , Ω(?var->i) )     the result is R

Definition: Evaluation of Group

eval(D(G), Group(exprlist, P)) = Group(exprlist, eval(D(G), P))

Definition: Evaluation of Aggregation

eval(D(G), Aggregation(exprlist, func, scalarvals, P)) = Aggregation(exprlist, func, scalarvals, eval(D(G), P))

Definition: Evaluation of AggregateJoin

eval(D(G), AggregateJoin(A₁, ..., A_n)) = AggregateJoin(eval(D(G), A₁), ..., eval(D(G), A_n))

eval(D(G), Extend(P, var, expr)) = Extend(eval(D(G), P), var, expr)

eval(D(G), ToList(P)) = ToList(eval(D(G), P))

eval(D(G), Distinct(L)) = Distinct(eval(D(G), L))

eval(D(G), Reduced(L)) = Reduced(eval(D(G), L))

eval(D(G), Project(L, vars)) = Project(eval(D(G), L), vars)

eval(D(G), OrderBy(L, condition)) = OrderBy(eval(D(G), L), condition)

eval(D(G), ToMultiSet(L)) = ToMultiSet(eval(D), M))

eval(D(G), Slice(L, start, length)) = Slice(eval(D(G), L), start, length)

18.7.1 Notes

(a) SG will often be graph equivalent to AG, but restricting this to E-equivalence allows some forms of normalization, for example elimination of semantic redundancies, to be applied to the source documents before querying.

(b) The construction in condition 3 ensures that any blank nodes introduced by the solution mapping are used in a way which is internally consistent with the way that blank nodes occur in SG. This ensures that blank node identifiers occur in more than one answer in an answer set only when the blank nodes so identified are indeed identical in SG. If the extension does not allow bindings to blank nodes, then this condition can be simplified to the condition:

SG E-entails μ(BGP) for each solution mapping μ.

(c) These conditions do not impose the SPARQL requirement that SG shares no blank nodes with AG or BGP. In particular, it allows SG to actually be AG. This allows query protocols in which blank node identifiers retain their meaning between the query and the source document, or across multiple queries. Such protocols are not supported by the current SPARQL protocol specification, however.

(d) Since conditions 1 to 3 are only necessary conditions on answers, condition 4 allows cases where the set of legal answers can be restricted in various ways.

(e) None of these conditions refer explicitly to instance mappings on blank nodes in BGP. For some entailment regimes, the existential interpretation of blank nodes cannot be fully captured by the existence of a single instance mapping. These conditions allow such regimes to give blank nodes in query patterns a 'fully existential' reading.

It is straightforward to show that SPARQL satisfies these conditions for the case where E is simple entailment, given that the SPARQL condition on SG is that it is graph-equivalent to AG but shares no blank nodes with AG or BGP (which satisfies the first condition). The only condition which is nontrivial is (3).

For every solution mapping μ_i, there is, by definition of basic graph pattern matching, an RDF instance mapping σ_i such that P_i(BGP_i) is a subgraph of SG where P_i is the pattern instance mapping composed of μ_i and σ_i. Since BGP_i and SG have no blank nodes in common, the ranges of σ_i and μ_i contain no blank nodes from BGP_i; therefore, the solution mapping μ_i and the RDF instance mapping σ_i of P_i commute, so P_i(BGP_i) = σ_i(μ_i(BGP_i)). So

P₁(BGP₁) union ... union P_n(BGP_n)
= σ₁(μ₁(BGP₁)) union ... union σ_n(μ_n(BGP_n))
= [ σ₁ + ... + σ_n]( μ₁(BGP₁) union ... union μ_n(BGP_n) )