SPARQL 1.2 Query Language

Unless otherwise noted in the section heading, all sections and appendices in this document are normative.

This section of the document, section 1 , introduces the SPARQL Query Language specification. It presents the organization of this specification document and the conventions used throughout the specification.

Section 2 of the specification introduces the SPARQL query language itself via a series of example queries and query results. Section 3 continues the introduction of the SPARQL query language with more examples that demonstrate SPARQL's ability to express constraints on the RDF terms that appear in a query's results.

Section 4 presents details of the SPARQL query language's syntax. It is a companion to the full grammar of the language and defines how grammatical constructs represent IRIs, blank nodes, literals, and variables. Section 4 also defines the meaning of several grammatical constructs that serve as syntactic sugar for more verbose expressions.

Section 5 introduces basic graph patterns and group graph patterns, the building blocks from which more complex SPARQL query patterns are constructed. Sections 6, 7, and 8 present constructs that combine SPARQL graph patterns into larger graph patterns. In particular, Section 6 introduces the ability to make portions of a query optional; Section 7 introduces the ability to express the disjunction of alternative graph patterns; and Section 8 introduces patterns to test for the absense of information.

Section 9 adds property paths to graph pattern matching, giving a compact representation of queries and also the ability to match arbitrary length paths in the graph.

Section 10 describes the forms of assignment possible in SPARQL.

Sections 11 introduces the mechanism to group and aggregate results, which can be incorporated as subqueries as described in Section 12 .

Section 13 introduces the ability to constrain portions of a query to particular source graphs. Section 13 also presents SPARQL's mechanism for defining the source graphs for a query.

Section 14 refers to the separate document SPARQL 1.1 Federated Query .

Section 15 defines the constructs that affect the solutions of a query by ordering, slicing, projecting, limiting, and removing duplicates from a sequence of solutions.

Section 16 defines the four types of SPARQL queries that produce results in different forms.

Section 17 defines SPARQL's extensible value testing and expression framework. It presents the functions and operators that can be used to constrain the values that appear in a query's results and also calculate new values to be returned by a query.

Section 18 is a formal definition of the evaluation of SPARQL graph patterns and solution modifiers.

Section 19 contains the normative definition of the syntax for the SPARQL query and SPARQL 1.1 Update languages, as given by a grammar expressed in EBNF notation.

The example below shows a SPARQL query to find the title of a book from the given data graph. The query consists of two parts: the SELECT clause identifies the variables to appear in the query results, and the WHERE clause provides the basic graph pattern to match against the data graph. The basic graph pattern in this example consists of a single triple pattern with a single variable ( ?title ) in the object position.

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

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

The result of a query is a solution sequence , corresponding to the ways in which the query's graph pattern matches the data. There may be zero, one or multiple solutions to a query.

Data:

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>
.

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

Each solution gives one way in which the selected variables can be bound to RDF terms so that the query pattern matches the data. The result set gives all the possible solutions. In the above example, the following two subsets of the data provided the two matches.

_:a foaf:name  "Johnny Lee Outlaw" .
_:a
foaf:box
<mailto:jlow@example.com>
.

_:b foaf:name  "Peter Goodguy" .
_:b
foaf:box
<mailto:peter@example.org>
.

This is a basic graph pattern match ; all the variables used in the query pattern must be bound in every solution.

The data below contains three RDF literals:

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
.

This RDF data is the data graph for the query examples in sections 2.3.1–2.3.3.

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

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

SELECT
?v
WHERE
{
?v
?p
42
}

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

Query results can contain blank nodes. Blank nodes in the example result sets in this document are written in the form "_:" followed by a blank node identifier .

Blank node identifiers are scoped to a result set (see " SPARQL Query Results XML Format (Second Edition) " and " SPARQL 1.1 Query Results JSON Format ") or, for the CONSTRUCT query form, the result graph. Use of the same identifier within a result set indicates the same blank node.

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 ?name
WHERE
{
?x
foaf:name
?name
}

These two results have the same information: the blank nodes used to match the query are different in the two solutions. There need not be any relation between a blank node identifier _:a in the result set and a blank node identifier used in the syntax for the data.

An application writer should not expect blank node identifiers in a query to refer to a particular blank node in the data.

SPARQL 1.2 allows values to be created from complex expressions. The queries below show how the CONCAT function can be used to concatenate first names and last names from FOAF data, then assign the value using an expression in the SELECT clause and also assign the value by using the BIND form.

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 ?name
WHERE  { 
    ?P foaf:givenName ?G ; 
       foaf:surname ?S 
    BIND(CONCAT(?G, " ", ?S) AS ?name)
}

SPARQL has several query forms . The SELECT query form returns variable bindings. The CONSTRUCT query form returns an RDF graph. The graph is built based on a template which is used to generate RDF triples based on the results of matching the graph pattern of the query.

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"
.

<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>

SPARQL FILTER functions like regex can test RDF literals. regex matches only string literals . regex can be used to match the lexical forms of other literals by using the str function.

Query:

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

Regular expression matches may be made case-insensitive with the " i " flag.

Query:

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

The regular expression language is defined by XQuery and XPath Functions and Operators and is based on XML Schema Regular Expressions .

SPARQL FILTER s can restrict on arithmetic expressions.

Query:

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

In addition to numeric types, SPARQL supports types xsd:string , xsd:boolean and xsd:dateTime (see Operand Data Types ). Section Operator Mapping describes the operators and section Function Definitions the functions that can be that can be applied to RDF terms.

Triple Patterns are written as subject, predicate and object; there are abbreviated ways of writing some common triple pattern constructs.

The following examples express the same query:

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

PREFIX  dc: <http://purl.org/dc/elements/1.1/>
PREFIX  : <http://example.org/book/>
SELECT  $title
WHERE
{
:book1
dc:title
$title
}

BASE    <http://example.org/book/>
PREFIX  dc: <http://purl.org/dc/elements/1.1/>
SELECT  $title
WHERE
{
<book1>
dc:title
?title
}

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

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

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

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

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

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

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

_: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"
.

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

_: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
.

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

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

To cope with the language evolution of SPARQL, the VERSION directive can be used. When writing SPARQL queries with new features such as triple terms or functions on triple terms , authors MAY announce the use of the new syntax forms by including this directive.

VERSION "1.2"
PREFIX : <http://example/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?s ?date {
    ?s ?p ?o .
    BIND( <<( ?s ?p ?o )>> AS ?tt )
    :myreifier rdf:reifies ?tt .
    :myreifier :tripleAdded ?date .
}

Basic graph patterns are sets of triple patterns. SPARQL graph pattern matching is defined in terms of combining the results from matching basic graph patterns.

A sequence of triple patterns, with optional filters, comprises a single basic graph pattern. Any other graph pattern terminates a basic graph pattern.

In a SPARQL query string, a group graph pattern is delimited with braces: {} . For example, this query's query pattern is a group graph pattern of one basic graph pattern.

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

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

{
}

SELECT ?x
WHERE
{}

{  ?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 .
}

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

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

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

Optional parts of the graph pattern may be specified syntactically with the OPTIONAL keyword applied to a graph pattern:

pattern

OPTIONAL
{

pattern

}

{
OPTIONAL
{

pattern

}
}

{
{
}
OPTIONAL
{

pattern

}
}

pattern

OPTIONAL
{

pattern

}
OPTIONAL
{
pattern
}

{

pattern

OPTIONAL
{

pattern

}
}
OPTIONAL
{
pattern
}

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 ?mbox
WHERE  {
    ?x foaf:name  ?name .
    OPTIONAL { ?x  foaf:mbox  ?mbox }
}

There is no value of mbox in the solution where the name is "Bob" .

This query finds the names of people in the data. If there is a triple with predicate mbox and the same subject, a solution will contain the object of that triple as well. In this example, only a single triple pattern is given in the optional match part of the query but, in general, the optional part may be any graph pattern. The entire optional graph pattern must match for the optional graph pattern to affect the query solution.

Constraints can be given in an optional graph pattern. For 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 .
: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 ?price
WHERE   { 
    ?x dc:title ?title .
    OPTIONAL { ?x ns:price ?price . FILTER (?price < 30) }
}

No price appears for the book with title "SPARQL Tutorial" because the optional graph pattern did not lead to a solution involving the variable " price ".

Graph patterns are defined recursively. A graph pattern may have zero or more optional graph patterns, and any part of a query pattern may have an optional part. In this example, there are two optional graph patterns.

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 ?hpage
WHERE  {
    ?x foaf:name  ?name .
    OPTIONAL { ?x foaf:mbox ?mbox } .
    OPTIONAL { ?x foaf:homepage ?hpage }
}

Filtering of query solutions is done within a FILTER expression using NOT EXISTS and EXISTS . Note that the filter scope rules apply to the whole group in which the filter appears .

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 ?person
WHERE 
{
    ?person rdf:type  foaf:Person .
    FILTER NOT EXISTS { ?person foaf:name ?name }
}

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

The other style of negation provided in SPARQL is MINUS which evaluates both its arguments, then calculates solutions in the left-hand side that are not compatible with the solutions on the right-hand side.

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 ?s
WHERE {
    ?s ?p ?o .
    MINUS {
        ?s foaf:givenName "Bob" .
    }
}

NOT EXISTS and MINUS represent two ways of thinking about negation, one based on testing whether a pattern exists in the data, given the bindings already determined by the query pattern, and one based on removing matches based on the evaluation of two patterns. In some cases they can produce different answers.

PREFIX : <http://example/>
:a
:b
:c
.

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

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

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

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

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
.

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

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

In the description below, iri is either an IRI written in full or abbreviated by a prefixed name , or the keyword a . elt is a path element, which may itself be composed of path constructs.

The order of IRIs, and reverse IRIs, in a negated property set is not significant and they can occur in a mixed order.

The precedence of the syntax forms is, from highest to lowest:

• IRI, prefixed names
• Negated property sets
• Groups
• Unary operators * , ? and +
• Unary ^ inverse links
• Binary operator /
• Binary operator |

Precedence is left-to-right within groups.

Alternatives : Match one or both possibilities

{
:book1
dc:title|rdfs:label
?displayString
}

which could have written:

{ 
   :book1 <http://purl.org/dc/elements/1.1/title> | <http://www.w3.org/2000/01/rdf-schema#label> ?displayString
}

Sequence : Find the name of any people that Alice knows.

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

Sequence : Find the names of people 2 " foaf:knows " links away.

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

This is the same as the SPARQL query:

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

or, with explicit variables:

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

Filtering duplicates : Because someone Alice knows may well know Alice, the example above may include Alice herself. This could be avoided with:

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

Inverse Property Paths : These two are the same query: the second is just reversing the property direction which swaps the roles of subject and object.

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

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

Inverse Path Sequence : Find all the people who know someone ?x knows.

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

which is equivalent to ( ?gen1 is a system generated variable):

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

Arbitrary length match : Find the names of all the people that can be reached from Alice by foaf:knows :

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

Alternatives in an arbitrary length path :

{
?ancestor
(ex:motherOf|ex:fatherOf)+
<#me>
}

Arbitrary length path match : Some forms of limited inference are possible as well. For example, for RDFS, all types and supertypes of a resource:

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

All resources and all their inferred types:

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

Subproperty :

{
?x
?p
?v
.
?p
rdfs:subPropertyOf*
:property
}

Negated Property Paths : Find nodes connected but not by rdf:type (either way round):

{
?x
!(rdf:type|^rdf:type)
?y
}

Elements in an RDF collection :

{
:list
rdf:rest*/rdf:first
?element
}

Note: This path expression does not guarantee the order of the results.

SPARQL property paths treat the RDF triples as a directed, possibly cyclic, graph with named edges. Evaluation of a property path expression can lead to duplicates because any variables introduced in the equivalent pattern are not part of the results and are not already used elsewhere. They are hidden by implicit projection of the results to just the variables given in the query.

For example, on the data:

PREFIX :       <http://example/>
:order  :item :z1 .
:order  :item :z2 .
:z1 :name "Small" .
:z1 :price 5 .
:z2 :name "Large" .
:z2
:price
5
.

Query:

PREFIX :   <http://example/>
SELECT * 
{
?s
:item/:price
?x
.
}

Results:

whereas if the query were written out to include the intermediate variable ( ?_a ), no rows in the results are duplicates:

PREFIX :   <http://example/>
SELECT * 
{  ?s :item ?_a .
   ?_a :price ?x .
}

Results:

The equivalence to graphs patterns is particularly significant when query also involves an aggregation operation. The total cost of the order can be found with

PREFIX :   <http://example/>
SELECT (sum(?x) AS ?total) { 
    :order :item/:price ?x
}

Connectivity between the subject and object by a property path of arbitrary length can be found using the "zero or more" property path operator, * , and the "one or more" property path operator, + . There is also a "zero or one" connectivity property path operator, ? .

Each of these operators uses the property path expression to try to find a connection between subject and object, using the path step a number of times, as restricted by the operator.

For example, finding all the the possible types of a resource, including supertypes of resources, can be achieved with:

PREFIX  rdfs:   <http://www.w3.org/2000/01/rdf-schema#> . 
PREFIX  rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?x ?type
{ 
    ?x rdf:type/rdfs:subClassOf* ?type
}

Similarly, finding all the people :x connects to via the foaf:knows relationship,

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX :     <http://example/>
SELECT ?person
{ 
    :x foaf:knows+ ?person
}

Such connectivity matching does not introduce duplicates (it does not incorporate any count of the number of ways the connection can be made) even if the repeated path itself would otherwise result in duplicates.

The graph matched may include cycles. Connectivity matching is defined so that matching cycles does not lead to undefined or infinite results.

The BIND form allows a value to be assigned to a variable from a basic graph pattern or property path expression. Use of BIND ends the preceding basic graph pattern. The variable introduced by the BIND clause must not have been used in the group graph pattern up to the point of use in BIND .

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 ?price
{   
    ?x ns:price ?p .
    ?x ns:discount ?discount
    BIND (?p*(1-?discount) AS ?price)
    FILTER(?price < 20)
    ?x dc:title ?title . 
}

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)
}

Data can be directly written in a graph pattern or added to a query using VALUES . VALUES provides inline data as a solution sequence which are combined with the results of query evaluation by a join operation. It can be used by an application to provide specific requirements on query results and also by SPARQL query engine implementations that provide federated query through the SERVICE keyword to send a more constrained query to a remote query service.

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

VALUES
?z
{
"abc"
"def"
}

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

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 .
}

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)
    }
}

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)
}

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
.

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

This example demonstrates two features of aggregates: GROUP BY , which groups query solutions according to one or more expressions (in this case ?org ), and HAVING , which is analogous to a FILTER expression, but operates over groups, rather than individual solutions.

The example is produced by grouping solutions according to the GROUP BY expression (i.e. all solutions where ?org takes a particular value appear within the same group), and evaluating the Set Function SUM over that group. The groups are then filtered by the HAVING expression, which removes all groups where SUM(?lprice) is not greater than 10.

In aggregate queries and sub-queries, variables that appear in the query pattern, but are not in the GROUP BY clause, can only be projected or used in select expressions if they are aggregated. The SAMPLE aggregate may be used for this purpose. For details see the section on Projection Restrictions .

It should be noted that as per functions , aggregate expressions are required to be aliased (again, similar to the BIND clause, using the keyword AS ) in order to project them from queries or subqueries. In the example above this is done using the variable ?totalPrice . It is an error for aggregates to project variables with a name already used in other aggregate projections, or in the WHERE clause.

In order to calculate aggregate values for a solution, the solution is first divided into one or more groups, and the aggregate value is calculated for each group.

If aggregates are used in the query level in SELECT , HAVING or ORDER BY but the GROUP BY term is not used, then this is taken to be a single implicit group, to which all solutions belong.

Within GROUP BY clauses the binding keyword, AS , may be used, such as GROUP BY (?x + ?y AS ?z) . This is equivalent to { ... BIND (?x + ?y AS ?z) } GROUP BY ?z .

For example, given a solution sequence S , ( {?x→2, ?y→3}, {?x→2, ?y→5}, {?x→6, ?y→7} ) , we might wish to group the solutions according to the value of ?x , and calculate the average of the values of ?y for each group.

This could be written as:

SELECT (AVG(?y) AS ?avg)
WHERE {
    ?a :x ?x ;
    :y ?y .
}
GROUP
BY
?x

HAVING operates over grouped solution sets, in the same way that FILTER operates over un-grouped ones.

HAVING expressions have the same evaluation rules as projections from grouped queries, as described in the following section.

An example of the use of HAVING is given below.

PREFIX : <http://data.example/>
SELECT (AVG(?size) AS ?asize)
WHERE {
    ?x :size ?size
}
GROUP BY ?x
HAVING(AVG(?size)
>
10)

This will return average sizes, grouped by the subject, but only where the mean size is greater than 10.

In a query level which uses aggregates, only expressions consisting of aggregates and constants may be projected, with one exception. When GROUP BY is given with one or more simple expressions consisting of just a variable, those variables may be projected from the level.

For example, the following query is legal as ?x is given as a GROUP BY term.

PREFIX : <http://example.com/data/#>
SELECT ?x (MIN(?y) * 2 AS ?min)
WHERE {
    ?x :p ?y .
    ?x :q ?z .
}
GROUP
BY
?x
(STR(?z))

Note that it would not be legal to project STR(?z) as this is not a simple variable expression. However, with GROUP BY (STR(?z) AS ?strZ) it would be possible to project ?strZ .

Other expressions, not using GROUP BY variables, or aggregates may have non-deterministic values projected from their groups using the SAMPLE aggregate.

This section shows an example query using aggregation, which demonstrates how errors are handled in results, in the presence of aggregates.

Data:

PREFIX : <http://example.com/data/#>
:x :p 1, 2, 3, 4 .
:y :p 1, _:b2, 3, 4 .
:z
:p
1.0,
2.0,
3.0,
4
.

Query:

PREFIX : <http://example.com/data/#>
SELECT ?g (AVG(?p) AS ?avg) ((MIN(?p) + MAX(?p)) / 2 AS ?c)
WHERE {
    ?g :p ?p .
}
GROUP
BY
?g

Result:

Note that the bindings for the :y group is not included in the results as the evaluation of Avg({1, _:b2, 3, 4}), and (_:b2 + 4) / 2 is an error, removing the bindings from the solution.

Data:

PREFIX : <http://people.example/>
:alice :name "Alice", "Alice Foo", "A. Foo" .
:alice :knows :bob, :carol .
:bob :name "Bob", "Bob Bar", "B. Bar" .
:carol
:name
"Carol",
"Carol
Baz",
"C.
Baz"
.

PREFIX : <http://people.example/>
PREFIX : <http://people.example/>
SELECT ?y ?minName
WHERE {
    :alice :knows ?y .
    {
      SELECT ?y (MIN(?name) AS ?minName)
      WHERE {
          ?y :name ?name .
      } GROUP BY ?y
    }
}

Results:

This result is achieved by first evaluating the inner query:

SELECT ?y (MIN(?name) AS ?minName)
WHERE {
    ?y :name ?name .
}
GROUP
BY
?y

This produces the following solution sequence:

Which is joined with the results of the outer query:

The definition of RDF Dataset [ RDF12-CONCEPTS ] does not restrict the relationships of named and default graphs. Information can be repeated in different graphs; relationships between graphs can be exposed. Two useful arrangements are:

• to have information in the default graph that includes provenance information about the named graphs
• to include the information in the named graphs in the default graph as well.

PREFIX dc: <http://purl.org/dc/elements/1.1/>
<http://example.org/bob>    dc:publisher  "Bob" .
<http://example.org/alice>  dc:publisher  "Alice" .
GRAPH <http://example.org/bob> {
    _:a foaf:name "Bob" .
    _:a foaf:mbox <mailto:bob@oldcorp.example.org> .
}
GRAPH <http://example.org/alice> {
    _:a foaf:name "Alice" .
    _:a foaf:mbox <mailto:alice@work.example.org> .
}

In this example, the default graph contains the names of the publishers of two named graphs. The triples in the named graphs are not visible in the default graph in this example.

Example 2:

RDF data can be combined by the RDF merge [ RDF12-SEMANTICS ] of graphs. One possible arrangement of graphs in an RDF Dataset is to have the default graph be the RDF merge of some or all of the information in the named graphs.

In this next example, the named graphs contain the same triples as before. The RDF dataset includes an RDF merge of the named graphs in the default graph, which keeps blank nodes distinct.

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> .
GRAPH <http://example.org/bob> {
    _:a foaf:name "Bob" .
    _:a foaf:mbox <mailto:bob@oldcorp.example.org> .
}
GRAPH <http://example.org/alice> {
    _:a foaf:name "Alice" .
    _:a foaf:mbox <mailto:alice@work.example> .
}

A SPARQL query may specify the dataset to be used for matching by using the FROM clause and the FROM NAMED clause to describe the RDF dataset. If a query provides such a dataset description, then it is used in place of any dataset that the query service would use if no dataset description is provided in a query. The RDF dataset may also be specified in a SPARQL protocol request , in which case the protocol description overrides any description in the query itself. A query service may refuse a query request if the dataset description is not acceptable to the service.

The FROM and FROM NAMED keywords allow a query to specify an RDF dataset by reference; they indicate that the dataset should include graphs that are obtained from representations of the resources identified by the given IRIs (i.e. the absolute form of the given IRI references). The dataset resulting from a number of FROM and FROM NAMED clauses is:

• a default graph consisting of the RDF merge of the graphs referred to in the FROM clauses, and
• a set of (IRI, graph) pairs, one from each FROM NAMED clause.

If there is no FROM clause, but there is one or more FROM NAMED clauses, then the dataset includes an empty graph for the default graph.

# 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  ?name
FROM    <http://example.org/foaf/aliceFoaf>
WHERE
{
?x
foaf:name
?name
}

# 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>
...

# 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 ?mbox
FROM <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 }
}

When querying a collection of graphs, the GRAPH keyword is used to match patterns against named graphs. GRAPH can provide an IRI to select one graph or use a variable which will range over the IRI of all the named graphs in the query's RDF dataset.

The use of GRAPH changes the active graph for matching graph patterns within that part of the query. Outside the use of GRAPH , matching is done using the default graph.

The following two graphs will be used in examples:

# 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
.

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?src ?bobNick
FROM 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
    }
}

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX data: <http://example.org/foaf/>
SELECT ?nick
FROM 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 
    }
}

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 ?ppd
FROM 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
    }
}

Any triple in Alice's FOAF file giving Bob's nick is not used to provide a nick for Bob because the pattern involving variable nick is restricted by ppd to a particular Personal Profile Document.

# 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 ?date
WHERE {
   ?g dc:publisher ?name ;
      dc:date ?date .
   GRAPH ?g { 
       ?person foaf:name ?name ; foaf:mbox ?mbox
   }
}

The ORDER BY clause establishes the order of a solution sequence.

Following the ORDER BY clause is a sequence of order comparators, composed of an expression and an optional order modifier (either ASC() or DESC() ). Each ordering comparator is either ascending (indicated by the ASC() modifier or by no modifier) or descending (indicated by the DESC() modifier).

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

PREFIX     :    <http://example.org/ns#>
PREFIX foaf:    <http://xmlns.com/foaf/0.1/>
SELECT ?name
WHERE { ?x foaf:name ?name ; :empId ?emp }
ORDER
BY
DESC(?emp)

PREFIX     :    <http://example.org/ns#>
PREFIX foaf:    <http://xmlns.com/foaf/0.1/>
SELECT ?name
WHERE { ?x foaf:name ?name ; :empId ?emp }
ORDER
BY
?name
DESC(?emp)

The "<" operator (see the operator mapping and operator extensibility ) defines the relative order of pairs of numerics , xsd:strings , xsd:booleans and xsd:dateTimes . Pairs of IRIs are ordered by comparing them as literals with datatype xsd:string .

SPARQL also fixes an order between some kinds of RDF terms that would not otherwise be ordered:

1. (Lowest) no value assigned to the variable or expression in this solution.
2. Blank nodes
3. IRIs
4. RDF literals
5. Triple terms

SPARQL does not define a total ordering of all possible RDF terms. Implementations may define total ordering through operator extensibility . Here are a few examples of pairs of terms for which the relative order is undefined:

• "a" and "a"@en_gb (a literal with datatype xsd:string and a literal with a language tag)
• "a"@en_gb and "b"@en_gb (two literals with language tags)
• "a" and "1"^^xsd:integer (a literal with datatype xsd:string and a literal with a supported datatype)
• "1"^^my:integer and "2"^^my:integer (two unsupported datatypes)
• "1"^^xsd:integer and "2"^^my:integer (a supported datatype and an unsupported datatype)
• << :person1 foaf:name "Bob" >> and << :person2 foaf:name "Alice" >> (two triple terms)

This list of variable bindings is in ascending order:

The ascending order of two solutions with respect to an ordering comparator is established by substituting the solution bindings into the expressions and comparing them with the "<" operator . The descending order is the reverse of the ascending order.

The relative order of two solutions is the relative order of the two solutions with respect to the first ordering comparator in the sequence. For solutions where the substitutions of the solution bindings produce the same RDF term, the order is the relative order of the two solutions with respect to the next ordering comparator. The relative order of two solutions is undefined if no order expression evaluated for the two solutions produces distinct RDF terms.

Ordering a sequence of solutions always results in a sequence with the same number of solutions in it.

Using ORDER BY on a solution sequence for a CONSTRUCT or DESCRIBE query has no direct effect because only SELECT returns a sequence of results. Used in combination with LIMIT and OFFSET , ORDER BY can be used to return results generated from a different slice of the solution sequence. An ASK query does not include ORDER BY , LIMIT or OFFSET .

The solution sequence can be transformed into one involving only a subset of the variables. For each solution in the sequence, a new solution is formed using a specified selection of the variables using the SELECT query form.

The following example shows a query to extract just the names of people described in an RDF graph using FOAF properties.

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 ?name
WHERE
{
?x
foaf:name
?name
}

A solution sequence with no DISTINCT or REDUCED query modifier will preserve duplicate solutions.

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
}

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
}

OFFSET causes the solutions generated to start after the specified number of solutions. An OFFSET of zero has no effect.

Using LIMIT and OFFSET to select different subsets of the query solutions will not be useful unless the order is made predictable by using ORDER BY .

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>
SELECT  ?name
WHERE   { ?x foaf:name ?name }
ORDER BY ?name
LIMIT   5
OFFSET
10

The LIMIT clause puts an upper bound on the number of solutions returned. If the number of actual solutions, after OFFSET is applied, is greater than the limit, then at most the limit number of solutions will be returned.

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

A LIMIT of 0 would cause no results to be returned. A limit may not be negative.

The SELECT form of results returns variables and their bindings directly. It combines the operations of projecting the required variables with introducing new variable bindings into a query solution.

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 ?nickY
WHERE
{ ?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>

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 
}

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 
}

The CONSTRUCT query form returns a single RDF graph specified by a graph template. The result is an RDF graph formed by taking each query solution in the solution sequence, substituting for the variables in the graph template, and combining the triples into a single RDF graph by set union.

If any such instantiation produces a triple containing an unbound variable or an illegal RDF construct, such as a literal in subject or predicate position, then that triple is not included in the output RDF graph. The graph template can contain triples with no variables (known as ground or explicit triples), and these also appear in the output RDF graph returned by the CONSTRUCT query form.

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"
.

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#>
_:a vcard:N         _:v1 .
_:v1 vcard:givenName  "Alice" .
_:v1 vcard:familyName "Hacker" .
_:b vcard:N         _:v2 .
_:v2 vcard:givenName  "Bob" .
_:v2
vcard:familyName
"Hacker"
.

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

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 ) .
}

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"
.

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
}

Applications can use the ASK form to test whether or not a query pattern has a solution. No information is returned about the possible query solutions, just whether or not a solution exists.

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>

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

false

The DESCRIBE form returns a single result RDF graph containing RDF data about resources. This data is not prescribed by a SPARQL query, where the query client would need to know the structure of the RDF in the data source, but, instead, is determined by the SPARQL query processor. The query pattern is used to create a result set. The DESCRIBE form takes each of the resources identified in a solution, together with any resources directly named by IRI, and assembles a single RDF graph by taking a "description" which can come from any information available including the target RDF Dataset. The description is determined by the query service. The syntax DESCRIBE * is an abbreviation that describes all of the variables in a query.

DESCRIBE
<http://example.org/>

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

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

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

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#>
PREFIX rdf:    <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
.

SPARQL functions and operators operate on RDF terms and SPARQL variables. A subset of these functions and operators are taken from the XPath and XQuery Functions and Operators 3.1 [ XPATH-FUNCTIONS-31 ] and have XML Schema typed value arguments and return types. RDF literals passed as arguments to these functions and operators are mapped to XML Schema typed values with a string value of the lexical form and an atomic datatype corresponding to the datatype IRI . The returned typed values are mapped back to RDF literals the same way.

SPARQL has additional operators which operate on specific subsets of RDF terms. When referring to a type, the following terms denote a literal with the corresponding W3C XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes [ XMLSCHEMA11-2 ] datatype IRI :

• xsd:integer
• xsd:decimal
• xsd:float
• xsd:double
• xsd:string
• xsd:boolean
• xsd:dateTime

The following terms identify additional types used in SPARQL value tests:

• numeric denotes literals with datatypes xsd:integer , xsd:decimal , xsd:float , or xsd:double .
• RDF term denotes the types IRI , literal , blank node , or triple term .
• variable denotes a SPARQL variable.

The following types are derived from numeric types and are valid arguments to functions and operators taking numeric arguments:

• xsd:nonPositiveInteger
• xsd:negativeInteger
• xsd:long
• xsd:int
• xsd:short
• xsd:byte
• xsd:nonNegativeInteger
• xsd:unsignedLong
• xsd:unsignedInt
• xsd:unsignedShort
• xsd:unsignedByte
• xsd:positiveInteger

SPARQL language extensions may treat additional types as being derived from XML schema datatypes.

A SPARQL expression is evaluated with respect to a solution mapping and in the context of an RDF dataset with an active graph . The result of such an evaluation is either an RDF term or an error .

SPARQL provides a subset of the functions and operators defined by XPath and XQuery Functions and Operators . The following rules accommodate the differences in the data and execution models between XPath/XQuery and SPARQL:

• Unlike functions in XPath/XQuery, functions in SPARQL do not process node sequences.
• Functions invoked with an argument of the wrong type will produce an error .
• Effective boolean value arguments (labeled "xsd:boolean (EBV)" in the operator mapping table below), are coerced to xsd:boolean using the SPARQL EBV rules .
• Apart from the functional forms BOUND , COALESCE , IF , IN , NOT IN , logical-or ( || ), logical-and ( && ), logical-not ( ! ), NOT EXISTS , EXISTS , and EBV , all functions operate on RDF Terms. Functions produce an error if any argument is unbound.
• Any expression other than logical-or ( || ) or logical-and ( && ) that encounters an error will produce that error.
• A logical-or that encounters an error on only one branch will return TRUE if the other branch is TRUE and an error if the other branch is FALSE.
• A logical-and that encounters an error on only one branch will return an error if the other branch is TRUE and FALSE if the other branch is FALSE.
• A logical-or or logical-and that encounters errors on both branches will produce either of the errors .

The logical-and and logical-or truth table for true ( T ), false ( F ), and error ( E ) is as follows:

xsd:boolean


EBV

(

RDF
term


term

)

The SPARQL grammar identifies a set of operators (for instance, && , * , isIRI ) used to construct constraints. The following table associates each of these grammatical productions with the appropriate operands and an operator function defined by either XPath and XQuery Functions and Operators 3.1 [ XPATH-FUNCTIONS-31 ] or the SPARQL operators specified in section 17.4 . When selecting the operator definition for a given set of parameters, the definition with the most specific parameters applies. For instance, when evaluating xsd:integer = xsd:signedInt , the definition for = with two numeric parameters applies, rather than the one with two RDF terms . The table is arranged so that the upper-most viable candidate is the most specific. Operators invoked without appropriate operands result in an error .

SPARQL follows XPath's scheme for numeric type promotions and subtype substitution for arguments to numeric operators. The XPath Operator Mapping rules for numeric operands ( xsd:integer , xsd:decimal , xsd:float , xsd:double , and types derived from a numeric type) apply to SPARQL operators as well (see XML Path Language (XPath) 3.1 [ XPATH-31 ] for definitions of numeric type promotions and subtype substitution ). Some of the operators are associated with nested function expressions, e.g. fn:not(op:numeric-equal(A, B)) . Note that per the XPath definitions, fn:not and op:numeric-equal produce an error if their argument is an error.

The collation for fn:compare is defined by XPath and identified by http://www.w3.org/2005/xpath-functions/collation/codepoint . This collation allows for string comparison based on code point values. Codepoint string equivalence can be tested with RDF term equivalence.

xsd:boolean function arguments marked with "(EBV)" are coerced to xsd:boolean by evaluating the effective boolean value of that argument.

Operators = and != applied to triple terms apply the operator to each of the components.

This section defines the operators and functions introduced by the SPARQL query language. The examples show the behavior of the operators as invoked by the appropriate grammatical constructs.

xsd:boolean


BOUND

(

variable


var

)

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))
}

rdfTerm


IF

(

expression1
,

expression2
,

expression3

)

rdfTerm


COALESCE

(

expression,
....

)

xsd:boolean


NOT
EXISTS

{

pattern

}

xsd:boolean

EXISTS
{

pattern

}

xsd:boolean


logical-or

(

xsd:boolean


left
,

xsd:boolean


right

)

xsd:boolean


logical-and

(

xsd:boolean


left
,

xsd:boolean


right

)

xsd:boolean


logical-not

(

xsd:boolean


arg

)

boolean

rdfTerm

IN

(

expression
,
...

)

(rdfTerm
=
value
of
expression1)
||
(rdfTerm
=
value
of
expression2)
||
...

boolean

rdfTerm

NOT
IN

(

expression
,
...

)

(rdfTerm

!=


value


of


expression1)


&&


(rdfTerm

!=


value


of


expression2)


&&

...

xsd:boolean


sameTerm

(


RDF
term



term1
,


RDF
term



term2

)

xsd:boolean


sameValue

(


RDF
term



term1
,


RDF
term



term2

)

xsd:boolean  isIRI (RDF term term)

xsd:boolean


isURI

(

RDF
term


term

)

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:boolean


isBLANK

(


RDF
term



term

)

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 ?family
WHERE { 
    ?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:boolean


isLITERAL

(


RDF
term



term

)

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 isLiteral(?mbox)
}

xsd:boolean


isNUMERIC

(


RDF
term



term

)

xsd:string  STR (literal literal)

xsd:string


STR

(


IRI



rsrc

)

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$")
}

xsd:string


LANG

(


literal



ltrl

)

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" )
}

xsd:string


LANGDIR

(


literal



ltrl

)

xsd:string


hasLANG

(

RDF
term


term

)

xsd:string


hasLANGDIR

(

RDF
term


term

)

iri



DATATYPE

(


literal



literal

)

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 )
}

iri  IRI(xsd:string)
iri  IRI(iri)
iri  URI(xsd:string)

iri


URI

(

iri

)

blank
node


BNODE

()

blank
node


BNODE

(

xsd:string

)

literal


STRDT

(

xsd:string

lexicalForm,

IRI

datatypeIRI)

literal


STRLANG

(

xsd:string

lexicalForm,

xsd:string

langTag)

literal


STRLANGDIR

(

xsd:string

lexicalForm,

xsd:string

langTag,

xsd:string

baseDirection)

iri


UUID

()

xsd:string


STRUUID

()

xsd:integer


STRLEN

(

string
literal

str)

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

string
literal


SUBSTR

(

string
literal

source,

xsd:integer

startingLoc,

xsd:integer

length)

string
literal


UCASE

(

string
literal

str)

string
literal


LCASE

(

string
literal

str)

xsd:boolean


STRSTARTS

(

string
literal

arg1,

string
literal

arg2)

xsd:boolean


STRENDS

(

string
literal

arg1,

string
literal

arg2)

xsd:boolean


CONTAINS

(

string
literal

arg1,

string
literal

arg2)

literal


STRBEFORE

(

string
literal

arg1,

string
literal

arg2)

literal


STRAFTER

(

string
literal

arg1,

string
literal

arg2)

string
literal


CONCAT

(

string
literal
,
...,

string
literal

)

xsd:boolean


langMatches

(


xsd:string



language-tag
,


xsd:string



language-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:boolean  REGEX (string literal text, xsd:string pattern)

xsd:boolean


REGEX

(


string
literal



text
,


xsd:string



pattern
,


xsd:string



flags

)

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 literal  REPLACE (string literal arg, xsd:string pattern, xsd:string replacement )


string
literal



REPLACE

(


string
literal


arg,


xsd:string


pattern,


xsd:string


replacement,


xsd:string


flags)

xsd:string


ENCODE_FOR_URI

(

string
literal

ltrl)

numeric


ABS

(


numeric



term

)

numeric


ROUND

(


numeric



term

)

numeric


CEIL

(


numeric



term

)

numeric


FLOOR

(


numeric



term

)

xsd:double


RAND

(
)

xsd:dateTime


NOW

()

xsd:integer


YEAR

(


xsd:dateTime



arg

)

xsd:integer


MONTH

(


xsd:dateTime



arg

)

xsd:integer


DAY

(


xsd:dateTime



arg

)

xsd:integer


HOURS

(


xsd:dateTime



arg

)

xsd:integer


MINUTES

(


xsd:dateTime



arg

)

xsd:decimal


SECONDS

(


xsd:dateTime



arg

)

xsd:dayTimeDuration


TIMEZONE

(


xsd:dateTime



arg

)

xsd:string


TZ

(


xsd:dateTime



arg

)

triple
term


TRIPLE

(

RDF
term


subj
,

RDF
term


pred
,

RDF
term


obj

)

<<(

subj
pred
obj

)>>

VERSION "1.2"
PREFIX : <http://example/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?s ?date {
    ?s ?p ?o .
    BIND( <<( ?s ?p ?o )>> AS ?tt )
    :myreifier rdf:reifies ?tt .
    :myreifier :tripleAdded ?date .
}

VERSION "1.2"
PREFIX : <http://example/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?s ?date {
    ?s ?p ?o .
    BIND( TRIPLE(?s, ?p, ?o) AS ?tt )
    :myreifier rdf:reifies ?tt .
    :myreifier :tripleAdded ?date .
}

RDF
term


SUBJECT

(

triple
term


triple-term

)

RDF
term


PREDICATE

(

triple
term


triple-term

)

RDF
term


OBJECT

(

triple
term


triple-term

)

xsd:boolean


isTRIPLE

(

RDF
term


term

)

xsd:string


MD5

(


xsd:string



arg

)

xsd:string


SHA1

(


xsd:string



arg

)

xsd:string


SHA256

(


xsd:string



arg

)

xsd:string


SHA384

(


xsd:string



arg

)

xsd:string


SHA512

(


xsd:string



arg

)

SPARQL imports a subset of the XPath constructor functions defined in XPath and XQuery Functions and Operators 3.1 [ XPATH-FUNCTIONS-31 ] in section 19.1 Casting from primitive types to primitive types . SPARQL constructors include all of the XPath constructors for the SPARQL operand datatypes plus the additional datatypes imposed by the RDF data model. Casting in SPARQL is performed by calling a constructor function for the target type on an operand of the source type.

XPath defines only the casts from one XML Schema datatype to another. The remaining cast is defined as follows:

• Casting an IRI to an xsd:string produces a literal with a lexical value of the codepoints comprising the IRI, and a datatype of xsd:string .

The table below summarizes the casting operations that are always allowed ( Y ), never allowed ( N ) and dependent on the lexical value ( M ). For example, a casting operation from an xsd:string (the first row) to an xsd:float (the second column) is dependent on the lexical value ( M ).

bool = xsd:boolean
dbl = xsd:double
flt = xsd:float
dec = xsd:decimal
int = xsd:integer
dT = xsd:dateTime
str = xsd:string
IRI = IRI

It should be noted that any function or operator that is specified to return an error under some conditions is a valid extension point. That is, an implementation may return a non-error value in these error cases, and still be conformant with this recommendation.

A PrimaryExpression grammar rule can be a call to an extension function named by an IRI. An extension function takes some number of RDF terms as arguments and returns an RDF term. The semantics of these functions are identified by the IRI that identifies the function.

SPARQL queries using extension functions are likely to have limited interoperability.

As an example, consider a function called func:even :

xsd:boolean


func:even

(


numeric



value

)

PREFIX foaf: <http://xmlns.com/foaf/0.1/>
PREFIX func: <http://example.org/functions#>
SELECT ?name ?id
WHERE { 
    ?x foaf:name  ?name ;
       func:empId   ?id .
    FILTER (func:even(?id))
}

For a second example, consider a function aGeo:distance that calculates the distance between two points, which is used here to find the places near Grenoble:

xsd:double


aGeo:distance

(


numeric



x1
,


numeric



y1
,


numeric



x2
,


numeric



y2

)

PREFIX aGeo: <http://example.org/geo#>
SELECT ?neighbor
WHERE {
    ?a aGeo:placeName "Grenoble" .
    ?a aGeo:locationX ?axLoc .
    ?a aGeo:locationY ?ayLoc .
    ?b aGeo:placeName ?neighbor .
    ?b aGeo:locationX ?bxLoc .
    ?b aGeo:locationY ?byLoc .
    FILTER ( aGeo:distance(?axLoc, ?ayLoc, ?bxLoc, ?byLoc) < 10 ) .
}

An extension function might be used to test some application datatype not supported by the core SPARQL specification, it might be a transformation between datatype formats, for example into an XSD dateTime RDF term from another date format.

To define the evaluation semantics of a SPARQL query, the abstract syntax tree of the SPARQL query string (as defined by the SPARQL grammar ) is first translated into a syntax that resembles the SPARQL algebra . This section defines the expressions that can be formed in this algebraic syntax, and the translation of SPARQL query strings into this algebraic syntax is then defined in Section  18.3 Translation to the Algebraic Syntax .

An algebraic query expression is defined recursively as follows:

• A basic graph pattern is an algebraic query expression.
• A multiset of solution mappings is an algebraic query expression.
• A sequence of solution mappings is an algebraic query expression.
  Issue 231 : Keep both sequences and multisets of solution mappings as algebraic expressions? spec:enhancement

  Do we really need both of the previous two points?
• ContextSolution is an algebraic query expression.
• Path ( x , ppe , y ) is an algebraic query expression if ppe is an algebraic property path expression , x is an RDF term or a variable , and y is an RDF term or a variable .
• Union ( A ₁ , A ₂ ) is an algebraic query expression if A ₁ and A ₂ are algebraic query expressions.
• Join ( A ₁ , A ₂ ) is an algebraic query expression if A ₁ and A ₂ are algebraic query expressions.
• Minus ( A ₁ , A ₂ ) is an algebraic query expression if A ₁ and A ₂ are algebraic query expressions.
• LeftJoin ( A ₁ , A ₂ , expr ) is an algebraic query expression if A ₁ and A ₂ are algebraic query expressions and expr is an expression .
• Filter ( expr , A ) is an algebraic query expression if expr is an expression and A is an algebraic query expression.
• Extend ( A , var , expr ) is an algebraic query expression if A is an algebraic query expression, var is a variable , and expr is an expression .
• Graph ( x , A ) is an algebraic query expression if x is an IRI or a variable and A is an algebraic query expression.
• ToMultiset ( A ) is an algebraic query expression if A is an algebraic query expression.
• ToList ( A ) is an algebraic query expression if A is an algebraic query expression.
• Group ( exprlist , A ) is an algebraic query expression if exprlist is a nonempty sequence of expressions and A is an algebraic query expression.
• Aggregation ( exprlist , func , scalarvals , grp ) is an algebraic query expression if exprlist is a nonempty sequence of expressions or the asterisk character (*), func is a set function , scalarvals is a partial function (which may be the empty function, i.e., with an empty domain), and grp is an algebraic query expression of the form Group ( exprlist' , A ) where exprlist' is a sequence of expressions and A is an algebraic query expression.
  Issue 230 : 'Group' and 'Aggregation' should not be operators of the algebraic syntax spec:bug

  Group and Aggregation should not be independent operators but, instead, should be integrated into the definition of AggregateJoin .
• AggregateJoin ( A ₁ , ..., A _n ) is an algebraic query expression if A ₁ , ..., A _n is a non-empty sequence of algebraic query expressions (i.e., n ≥ 1) such that every expression A _i in this sequence is of the form Aggregation ( exprlist _i , func _i , scalarvals _i , grp _i ) that is captured by the previous point .
• OrderBy ( A , condition ) is an algebraic query expression if A is an algebraic query expression and condition is an ordering condition.
  Issue 229 : Notion of "ordering condition" undefined spec:bug

  The term "ordering condition" should link to some definition of this notion.
• Project ( A , PV ) is an algebraic query expression if A is an algebraic query expression and PV is a set of variables .
• Distinct ( A ) is an algebraic query expression if A is an algebraic query expression.
• Reduced ( A ) is an algebraic query expression if A is an algebraic query expression.
• Slice ( A , offset ) and Slice ( A , offset , limit ) are algebraic query expressions if A is an algebraic query expression and offset and limit are non-negative integers.

The notion of an algebraic property path expression , as used in the previous definition, is defined recursively as follows:

• Link ( iri ) is an algebraic property path expression if iri is an IRI .
• NPS ( I ) is an algebraic property path expression if I is a nonempty set of IRIs . NPS is an acronym for negated property set .
• Seq ( ppe ₁ , ppe ₂ ) is an algebraic property path expression if ppe ₁ and ppe ₂ are algebraic property path expressions.
• Alt ( ppe ₁ , ppe ₂ ) is an algebraic property path expression if ppe ₁ and ppe ₂ are algebraic property path expressions.
• Inv ( ppe ) is an algebraic property path expression if ppe is an algebraic property path expression.
• ZeroOrOnePath ( ppe ) is an algebraic property path expression if ppe is an algebraic property path expression.
• ZeroOrMorePath ( ppe ) is an algebraic property path expression if ppe is an algebraic property path expression.
• OneOrMorePath ( ppe ) is an algebraic property path expression if ppe is an algebraic property path expression.

This section defines the process of converting graph patterns and solution modifiers in a SPARQL query string into an algebraic query expression . The process described converts one level of query nesting as formed by subqueries using the nested SELECT syntax, and is applied recursively on subqueries. Each level consists of graph pattern matching and filtering, followed by the application of solution modifiers.

The SPARQL query string is parsed and the abbreviations for IRIs and triple patterns given in Section  4. SPARQL Syntax are applied. At this point, the abstract syntax tree is composed of the following:

OPTIONAL
{
{
...

FILTER

(
...
?

x

...
)
}
}.
.

Let FS := empty set
For 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} with exists(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))
    End
The
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 set
Let G := ContextSolution
For each element E in the sequence of elements 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

data

of
solution
mappings.

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 A
Replace

Join

(

A
,

Z

)
by

A