SPARQL 1.2 クエリ言語

節見出しに特に明記されていない限り、この文書のすべての節および附録は 規範的です。

この文書のこの節、第1節では、SPARQL クエリ言語仕様を紹介します。この仕様文書の構成および 仕様全体で用いられる規約を示します。

仕様の第2節では、一連のクエリ例および クエリ結果を通じて、SPARQLクエリ言語そのものを紹介します。 第3節では、クエリ結果に現れるRDF用語に対して 制約を表現できるSPARQLの能力を示す追加例によって、 SPARQLクエリ言語の紹介を続けます。

第4節では、SPARQLクエリ言語の 構文の詳細を示します。これは言語の完全な文法に対応するものであり、 文法構造がIRI、空白ノード、リテラル、および変数をどのように表すかを定義します。 第4節はまた、より冗長な式に対する構文糖として機能する いくつかの文法構造の意味も定義します。

第5節では、より複雑なSPARQLクエリ・パターンを構築する 構成要素である、基本グラフ・パターンおよびグループ・グラフ・ パターンを紹介します。第6節、第7節、および第8節では、SPARQLグラフ・パターンを より大きなグラフ・パターンへ結合する構造を示します。特に、 第6節は、クエリの一部を任意にする能力を紹介し、 第7節は、代替グラフ・パターンの選言を 表現する能力を紹介し、第8節は、 情報の欠如をテストするパターンを紹介します。

第9節では、プロパティ・パスをグラフ・パターン照合に追加し、 クエリのコンパクトな表現と、グラフ内の任意長パスを照合する能力も 提供します。

第10節では、SPARQLで可能な割り当て形式について 説明します。

第11節では、結果をグループ化して 集約する仕組みを紹介します。これは第12節で説明されるように サブクエリとして組み込むことができます。

第13節では、クエリの一部を特定のソースグラフへ 制約する能力を紹介します。第13節はまた、クエリのためのソースグラフを 定義するSPARQLの仕組みを示します。

第14節は、別文書 SPARQL 1.1フェデレーテッドクエリを参照します。

第15節では、解の列に対して 並べ替え、スライス、投影、制限、および重複の除去によって 影響を与える構造を定義します。

第16節では、異なる形式で結果を生成する 4種類のSPARQLクエリを定義します。

第17節では、SPARQLの拡張可能な値テスト および式フレームワークを定義します。クエリ結果に現れる値を制約し、 またクエリによって返される新しい値を計算するために用いることができる 関数および演算子を示します。

第18節は、SPARQLグラフ・パターンおよび 解修飾子の評価の形式的定義です。

第19節には、SPARQLクエリおよび SPARQL 1.1更新言語の構文に関する 規範的定義が含まれ、EBNF 記法で表現された文法として与えられます。

次の例は、与えられたデータグラフから本のタイトルを見つけるSPARQLクエリを 示しています。クエリは2つの部分で構成されます。SELECT節は クエリ結果に現れる変数を特定し、WHERE節は データグラフと照合する基本グラフ・パターンを提供します。この例の基本グラフ・パターンは、 目的語位置に単一の変数（?title）を持つ単一のトリプル・パターンで 構成されています。

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

クエリの結果は、クエリのグラフ・パターンがデータと一致する方法に対応する 解列です。 クエリに対する解は、0個、1個、または複数個存在し得ます。

データ:

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 }

各解は、クエリ・パターンがデータと一致するように、選択された変数を RDF用語へ束縛できる1つの方法を与えます。結果セットは、可能なすべての解を示します。 上の例では、提供されたデータの次の2つの部分集合が、2つの一致を提供しました。

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

これは基本グラフ・パターン照合です。クエリ・パターンで 用いられるすべての変数は、すべての解で束縛されていなければなりません。

下のデータには3つのRDFリテラルが含まれます。

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 .

このRDFデータは、第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> }

クエリ結果には空白ノードが含まれる場合があります。この文書の例の 結果セット内の空白ノードは、"_:"の後に 空白ノード識別子が続く形式で 書かれます。

空白ノード識別子は、結果セット（「SPARQLクエリ結果XML形式（第2 版）」および 「SPARQL 1.1クエリ結果JSON 形式」を参照）、またはCONSTRUCTクエリ形式では結果 グラフにスコープを持ちます。結果セット内で同じ識別子を使用することは、同じ空白ノードを示します。

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 }

これら2つの結果は同じ情報を持ちます。クエリに一致するために使用された 空白ノードは、2つの解で異なります。結果セット内の空白ノード識別子 _:aと、データの構文で用いられる空白ノード識別子との間に 何らかの関係がある必要はありません。

アプリケーション作成者は、クエリ内の空白ノード識別子が データ内の特定の空白ノードを参照することを期待すべきではありません。

SPARQL 1.2では、複雑な式から値を作成できます。下のクエリは、 CONCAT関数を使用してFOAFデータから名と 姓を連結し、その値を SELECT節内の式を使用して割り当てる方法、および BIND形式を使用してその値を割り当てる方法を示しています。

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にはいくつかのクエリ形式があります。 SELECTクエリ形式は変数束縛を返します。CONSTRUCTクエリ 形式はRDFグラフを返します。グラフは、クエリのグラフ・パターン照合の 結果に基づいてRDFトリプルを生成するために使用されるテンプレートに基づいて 構築されます。

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>

regexのようなSPARQLのFILTER関数は、 RDFリテラルをテストできます。regexは文字列 リテラルにのみ一致します。regexは、 str関数を使用することで、他のリテラルの字句形式と 照合するために使用できます。

クエリ:

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

正規表現照合は、「i」フラグを用いて大文字小文字を区別しないように できます。

クエリ:

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

正規表現言語は、XQuery およびXPath Functions and Operatorsによって定義され、 XML Schema正規表現に基づいています。

SPARQLのFILTERは、算術式に基づいて制限できます。

クエリ:

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

数値型に加えて、SPARQLは xsd:string、xsd:boolean、およびxsd:dateTime型を サポートします（オペランドのデータ型を参照）。 演算子マッピング節は演算子を説明し、 関数定義節は RDF用語に適用できる関数を説明します。

トリプル・パターンは、主語、述語、目的語として書かれます。 いくつかの一般的なトリプル・パターン構造には、省略して書く方法があります。

次の例は同じクエリを表します。

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

SPARQLの言語進化に対応するために、 VERSION指令を使用できます。 トリプル用語 やトリプル用語に対する関数などの新機能を用いて SPARQLクエリを書く場合、著者は、この指令と、 含まれる機能を処理するために必要なバージョンを示すバージョン・ラベルを続けることにより、 新しい構文形式の使用を宣言してもよいです。

バージョン・ラベルは次の節で定義されます。 処理系は、認識できないラベルをエラーまたは警告として扱うことができます。

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

SPARQL 1.2 Protocol は、 バージョン通知も提供し、これは メディア型の version パラメーターを用いる。 これは VERSION 指令がない場合に考慮される。

基本グラフ・パターンは、トリプル・パターンの集合です。SPARQLのグラフ・パターン照合は、 基本グラフ・パターンの照合結果を組み合わせるという観点から定義されます。

任意のフィルターを伴うトリプル・パターンの列は、単一の基本グラフ・ パターンを構成します。その他のグラフ・パターンは、基本グラフ・パターンを終了させます。

SPARQLクエリ文字列では、グループ・グラフ・パターンは波括弧{}で区切られます。 たとえば、このクエリのクエリ・パターンは、1つの基本グラフ・ パターンからなるグループ・グラフ・パターンです。

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 キーワードを用いて構文的に指定できます。

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

名前が"Bob"である解には、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 ?price
WHERE   { 
    ?x dc:title ?title .
    OPTIONAL { ?x ns:price ?price . FILTER (?price < 30) }
}

タイトルが"SPARQL Tutorial"である本には価格が表示されません。これは、任意グラフ・ パターンが変数「price」を含む解を導かなかったためです。

グラフ・パターンは再帰的に定義されます。グラフ・パターンは0個以上の任意 グラフ・パターンを持つことができ、クエリ・パターンのどの部分にも任意部分を持たせることが できます。この例には2つの任意グラフ・パターンがあります。

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

クエリ解のフィルタリングは、FILTER式内で NOT EXISTSおよびEXISTSを用いて行われます。 フィルター・スコープ規則は、 フィルターが現れるグループ全体に適用されることに注意してください。

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

SPARQLで提供されるもう1つの否定形式はMINUSです。これは両方の 引数を評価し、その後、左辺の解のうち右辺の解と互換でないものを計算します。

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とMINUSは、否定について考える2つの方法を表します。 1つは、クエリ・パターンによってすでに決定された束縛が与えられたとき、 データ内にパターンが存在するかどうかをテストするものです。もう1つは、2つの パターンの評価に基づいて一致を除去するものです。場合によっては異なる答えを 生成することがあります。

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

以下の説明では、iriは完全に書かれたIRIまたは 接頭辞付き名前で省略されたIRI、あるいはキーワードaです。 elt はパス要素であり、それ自体がパス構造から構成されていてもかまいません。

否定プロパティ集合内のIRIおよび逆IRIの順序には意味がなく、混在した順序で 出現できます。

構文形式の優先順位は、高いものから低いものへ次のとおりです。

• IRI、接頭辞付き名前
• 否定プロパティ集合
• グループ
• 単項演算子*、?、および+
• 単項^逆リンク
• 二項演算子/
• 二項演算子|

グループ内では、優先順位は左から右です。

代替: 一方または両方の可能性に一致する

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

これは次のようにも書けます。

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

連続: Aliceが知っている任意の人物の名前を見つける。

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

連続: 2つの「foaf:knows」リンク先にいる人物の名前を見つける。

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

これは次のSPARQLクエリと同じです。

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

または、明示的な変数を用いると次のようになります。

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

重複のフィルタリング: Aliceが知っている人物がAlice自身を知っている可能性も十分あるため、 上の例にはAlice自身が含まれる場合があります。これは次のようにして避けられます。

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

逆プロパティ・パス: これら2つは同じクエリです。2番目はプロパティの方向を逆にして、 主語と目的語の役割を入れ替えているだけです。

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

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

逆パス連続: ある?xが知っている人を知っている、すべての人物を見つける。

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

これは（?gen1がシステム生成変数であるとして）次と等価です。

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

任意長照合: foaf:knowsによってAliceから到達できる すべての人物の名前を見つける。

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

任意長パス内の代替:

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

任意長パス照合: 限定的な推論のいくつかの形式も可能です。 たとえばRDFSについて、あるリソースのすべての型および上位型を取得できます。

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

すべてのリソースと、それらの推論されたすべての型:

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

サブプロパティ:

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

否定プロパティ・パス: rdf:typeによってではなく、どちらの向きでも接続されている ノードを見つける。

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

RDFコレクション内の要素:

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

注: このパス式は結果の順序を保証しません。

SPARQLプロパティ・パスは、RDFトリプルを名前付き辺を持つ有向で循環し得る グラフとして扱います。プロパティ・パス式の評価は重複を導くことがあります。これは、 等価なパターンで導入される変数が結果の一部ではなく、また他の場所ですでに 使用されていないためです。それらは、クエリで与えられた変数だけに結果を暗黙的に 投影することによって隠されます。

たとえば、次のデータに対して:

PREFIX :       <http://example/>

:order  :item :z1 .
:order  :item :z2 .

:z1 :name "Small" .
:z1 :price 5 .

:z2 :name "Large" .
:z2 :price 5 .

クエリ:

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

結果:

一方、クエリを中間変数（?_a）を含めて書き出した場合、 結果内のどの行も重複しません。

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

結果:

グラフ・パターンとの等価性は、クエリが集約操作も含む場合に特に重要です。 注文の総額は次で求められます。

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

任意長のプロパティ・パスによる主語と目的語の接続性は、「0回以上」の プロパティ・パス演算子*、および「1回以上」の プロパティ・パス演算子+を用いて見つけられます。 「0回または1回」の接続性プロパティ・パス演算子?もあります。

これらの各演算子は、演算子によって制限される回数だけパス・ステップを用いて、 主語と目的語の間の接続を見つけようとするためにプロパティ・パス式を使用します。

たとえば、リソースの上位型を含め、リソースの可能なすべての型を見つけることは、 次のように実現できます。

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
}

同様に、:xがfoaf:knows関係を介して接続する すべての人物を見つけるには、

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

このような接続性照合は、繰り返されるパス自体がそうでなければ重複を生じる場合でも、 重複を導入しません（接続を行う方法の数を取り込みません）。

照合されるグラフには循環が含まれる場合があります。接続性照合は、循環の照合が 未定義または無限の結果を導かないように定義されています。

BIND形式により、基本グラフ・パターンまたはプロパティ・パス式から 変数へ値を割り当てることができます。BINDを使用すると、その前の基本グラフ・ パターンは終了します。BIND節によって導入される変数は、BINDでの 使用時点までに、グループ・グラフ・パターン内で使用されていてはなりません。

例:

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

データは、グラフ・パターン内に直接書くことも、VALUESを用いて クエリに追加することもできます。VALUESは、 解列としてインラインデータを提供し、これは 結合操作によってクエリ評価の結果と組み合わされます。 アプリケーションがクエリ結果に対する特定の要件を提供するためにも、 SERVICEキーワードを通じてフェデレーテッドクエリを 提供するSPARQLクエリエンジン実装が、より制約されたクエリをリモート・クエリサービスへ 送信するためにも使用できます。

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)

この例は、集約の2つの機能を示しています。GROUP BYは、 1つ以上の式（この場合は?org）に従ってクエリ解をグループ化し、 HAVINGはFILTER式に類似していますが、個々の解ではなく グループに対して作用します。

この例は、GROUP BY式に従って解をグループ化し （すなわち、?orgが特定の値を取るすべての解が同じグループ内に現れます）、 そのグループに対して集合関数SUMを評価することによって生成されます。 その後、グループはHAVING式によってフィルタリングされ、 SUM(?lprice)が10より大きくないすべてのグループが除去されます。

集約クエリおよびサブクエリでは、クエリ・パターンに現れるが GROUP BY節には含まれない変数は、集約されている場合にのみ、 投影またはSELECT式内で使用できます。この目的にはSAMPLE集約を 使用できます。詳細については、投影制約の節を参照してください。

関数の場合と同様に、集約式をクエリまたはサブクエリから 投影するには、（BIND節と同様に、キーワードASを用いて） 別名を付ける必要があることに注意してください。上の例では、変数 ?totalPriceを用いてこれを行っています。他の集約投影または WHERE節で既に使用されている名前を持つ変数へ集約を投影することはエラーです。

解に対する集約値を計算するには、まず解を1つ以上のグループに分割し、 各グループについて集約値を計算します。

SELECT、HAVING、または ORDER BYのクエリレベルで集約が使用されているが、 GROUP BY項が使用されていない場合、これはすべての解が属する 単一の暗黙的グループとして扱われます。

GROUP BY節内では、GROUP BY (?x + ?y AS ?z)のように、 束縛キーワードASを使用できます。これは { ... BIND (?x + ?y AS ?z) } GROUP BY ?zと等価です。

たとえば、解列S、 ( {?x→2, ?y→3}, {?x→2, ?y→5}, {?x→6, ?y→7} )が与えられたとき、 解を?xの値に従ってグループ化し、各グループについて ?yの値の平均を計算したい場合があります。

これは次のように書けます。

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

HAVINGは、FILTERがグループ化されていない解集合に対して 作用するのと同じように、グループ化された解集合に対して作用します。

HAVING式は、次の節で説明されるように、グループ化された クエリからの投影と同じ評価規則を持ちます。

HAVINGの使用例を以下に示します。

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

これは、主語でグループ化された平均サイズを返しますが、平均サイズが 10より大きい場合に限ります。

グループ化を使用するクエリレベル（明示的なGROUP BY節の使用によるもの、 または投影、HAVING、もしくはORDER BY節内での集約の使用によるもの）では、 そのクエリレベルの投影またはSELECT式に現れる変数のすべての出現は、 次の条件のいずれかを満たさなければなりません。

• その変数Vが、名前付きGROUP BY変数として現れること （対応するGROUP BY式が単に変数Vだけで構成されるか、 (expr AS V)の形式を持つこと）
• その変数がSELECT式内の部分式の一部として現れ、その 部分式が集約への引数として使用されること（例: MIN(?v)または AVG(?v+2)）
• その変数が同じSELECT節内の先行するSELECT式によって導入されること

そのような変数の出現がこれらの条件のいずれも満たさない場合、そのクエリは 構文的に無効です。

たとえば、次のクエリは、?xがGROUP BY項として与えられているため 正当です。

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

STR(?z)を投影することは正当ではないことに注意してください。この式は単純な 変数でも、名前付きGROUP BY式でもないためです。しかし、 GROUP BY ?x (STR(?z) AS ?strZ)を用いれば、 ?strZを投影することが可能です。

上記の条件を満たさない変数を使用するその他の式は、SAMPLE集約を用いて そのグループから投影できます。

この節では、集約を使用するクエリ例を示し、集約が存在する場合に 結果内でエラーがどのように扱われるかを示します。

データ:

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 .

クエリ:

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

結果:

:yグループの束縛は、Avg({1, _:b2, 3, 4})および (_:b2 + 4) / 2の評価がエラーとなり、その束縛が解から除去されるため、 結果に含まれないことに注意してください。

データ:

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

結果:

この結果は、まず内側のクエリを評価することによって達成されます。

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

これは次の解列を生成します。

これは外側のクエリの結果と結合されます。

RDFデータセットの定義 [RDF12-CONCEPTS]は、名前付きグラフと デフォルトグラフの関係を制限しません。情報は異なるグラフで繰り返されることがあり、 グラフ間の関係が公開されることもあります。有用な2つの構成は次のとおりです。

• 名前付きグラフに関する来歴情報を含む情報をデフォルトグラフに持たせること
• 名前付きグラフ内の情報をデフォルトグラフにも含めること。

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

この例では、デフォルトグラフには2つの名前付きグラフの公開者の名前が含まれます。 この例では、名前付きグラフ内のトリプルはデフォルトグラフでは可視ではありません。

例2:

RDFデータは、グラフの RDFマージ [RDF12-SEMANTICS]によって 結合できます。RDFデータセット内のグラフの1つの可能な構成は、 デフォルトグラフを、名前付きグラフ内の一部または全部の情報のRDFマージにすることです。

次の例では、名前付きグラフには以前と同じトリプルが含まれます。RDFデータセットは、 空白ノードを区別したまま、名前付きグラフの RDFマージを デフォルトグラフに含みます。

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

SPARQLクエリは、RDFデータセットを記述するためにFROM節および FROM NAMED節を用いることで、照合に使用するデータセットを指定できます。 クエリがそのようなデータセット記述を提供する場合、クエリ内にデータセット記述が 提供されないときにクエリサービスが使用する任意のデータセットの代わりに、それが使用されます。 RDFデータセットは SPARQLプロトコル要求で 指定されることもあり、 その場合、プロトコル記述はクエリ自体の任意の記述を上書きします。クエリサービスは、 データセット記述がそのサービスにとって受け入れられない場合、クエリ要求を拒否できます。

FROMおよびFROM NAMEDキーワードにより、クエリは 参照によってRDFデータセットを指定できます。これらは、与えられたIRI（すなわち、 与えられたIRI参照の絶対形式）によって識別されるリソースの表現から取得される グラフをデータセットが含むべきであることを示します。複数のFROM節および FROM NAMED節から得られるデータセットは次のとおりです。

• FROM節で参照されるグラフのRDFマージからなるデフォルトグラフ、および
• 各FROM NAMED節から1つずつ得られる（IRI, グラフ）対の集合。

FROM節がなく、1つ以上のFROM NAMED節がある場合、 データセットはデフォルトグラフとして空グラフを含みます。

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

グラフの集合をクエリする場合、名前付きグラフに対してパターンを照合するために GRAPHキーワードが用いられます。GRAPHは、1つのグラフを選択するための IRIを提供することも、クエリのRDFデータセット内のすべての名前付きグラフのIRIを範囲とする 変数を使用することもできます。

GRAPHを使用すると、クエリのその部分内でグラフ・パターンを照合するための アクティブグラフが変わります。GRAPHの使用外では、デフォルトグラフを用いて 照合が行われます。

次の2つのグラフを例で使用します。

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

AliceのFOAFファイル内でBobのnickを与える任意のトリプルは、 Bobのニックネームを提供するためには使用されません。これは、変数nickを含む パターンが、ppdによって特定の個人プロフィール文書に制限されているためです。

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

ORDER BY節は、解列の順序を確立します。

ORDER BY節の後には、式と任意の順序修飾子（ASC()または DESC()のいずれか）から構成される順序比較子の列が続きます。 各順序比較子は、昇順（ASC()修飾子または修飾子なしで示される）または 降順（DESC()修飾子で示される）のいずれかです。

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)

「<」演算子（演算子 マッピングおよび演算子の拡張性を参照）は、 numerics、 xsd:strings、xsd:booleansおよびxsd:dateTimesの対の 相対順序を定義します。IRIの対は、データ型xsd:stringのリテラルとして 比較することで順序付けられます。

SPARQLはまた、そうでなければ順序付けられないいくつかの種類のRDF用語の間に 順序を定めます。

1. （最小）この解で変数または式に値が割り当てられていない。
2. 空白ノード
3. IRI
4. RDFリテラル
5. トリプル用語

SPARQLは、すべての可能なRDF用語の全順序を定義しません。実装は 演算子の拡張性を通じて全順序を定義できます。以下は、 相対順序が未定義である用語の対のいくつかの例です。

• "a"および"a"@en_gb（データ型xsd:stringを持つリテラルと、言語 タグを持つリテラル）
• "a"@en_gbおよび"b"@en_gb（言語タグを持つ2つのリテラル）
• "a"および"1"^^xsd:integer（データ型xsd:stringを持つリテラルと、 サポートされる データ型を持つリテラル）
• "1"^^my:integerおよび"2"^^my:integer（サポートされない2つのデータ型）
• "1"^^xsd:integerおよび"2"^^my:integer（サポートされるデータ型とサポートされない データ型）
• << :person1 foaf:name "Bob" >>および<< :person2 foaf:name "Alice" >>（2つの トリプル用語）

この変数束縛のリストは昇順です。

順序比較子に関する2つの解の昇順は、解の束縛を式に代入し、 それらを「<」演算子で比較することによって確立されます。 降順は昇順の逆です。

2つの解の相対順序は、列内の最初の順序比較子に関する2つの解の相対順序です。 解束縛の代入が同じRDF用語を生成する解については、順序は 次の順序比較子に関する2つの解の相対順序です。2つの解について評価された順序式が 区別できるRDF用語を生成しない場合、2つの解の相対順序は未定義です。

解の列を順序付けると、常に同じ数の解を含む列になります。

CONSTRUCTまたはDESCRIBEクエリの解列に ORDER BYを使用しても、直接的な効果はありません。これは、 SELECTだけが結果の列を返すためです。LIMITおよび OFFSETと組み合わせて使用すると、ORDER BYは、解列の別の スライスから生成された結果を返すために使用できます。ASKクエリには ORDER BY、 LIMITまたはOFFSETは含まれません。

解列は、変数の部分集合だけを含むものへ変換できます。列内の各解について、 SELECTクエリ形式を用いて、指定された変数の選択を使用する新しい解が形成されます。

次の例は、FOAFプロパティを用いてRDFグラフ内に記述された人々の名前だけを 抽出するクエリを示しています。

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 }

DISTINCTまたはREDUCEDクエリ修飾子を持たない解列は、 重複する解を保持します。

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は、生成される解が指定された数の解の後から開始するようにします。 OFFSETが0の場合、効果はありません。

LIMITおよびOFFSETを使用してクエリ解の異なる部分集合を選択することは、 ORDER BYを用いて順序を予測可能にしない限り、有用ではありません。

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>

SELECT  ?name
WHERE   { ?x foaf:name ?name }
ORDER BY ?name
LIMIT   5
OFFSET  10

LIMIT節は、返される解の数に上限を設定します。 OFFSETが適用された後の実際の解の数がlimitより大きい場合、 高々limit個の解が返されます。

PREFIX foaf:    <http://xmlns.com/foaf/0.1/>

SELECT ?name
WHERE { ?x foaf:name ?name }
LIMIT 20

LIMITが0の場合、結果は返されません。limitは 負であってはなりません。

SELECT形式の結果は、変数とその束縛を直接返します。これは、 必要な変数を投影する操作と、新しい変数束縛をクエリ解へ導入する操作を組み合わせます。

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 
}

CONSTRUCTクエリ形式は、グラフ・テンプレートによって指定された単一のRDFグラフを 返します。結果は、解列内の各クエリ解を取り、グラフ・テンプレート内の変数を代入し、 集合和によってトリプルを単一のRDFグラフに結合することで形成されたRDFグラフです。

そのようなインスタンス化によって、未束縛変数、または主語もしくは述語位置のリテラルなど 不正なRDF構造を含むトリプルが生成される場合、そのトリプルは出力RDFグラフに 含まれません。グラフ・テンプレートは、変数を持たないトリプル（グラウンド・トリプルまたは 明示的トリプルとして知られる）を含むことができ、これらもCONSTRUCTクエリ形式によって 返される出力RDFグラフに現れます。

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 }

アプリケーションは、クエリ・パターンに解があるかどうかをテストするために ASK形式を使用できます。可能なクエリ解に関する情報は返されず、 解が存在するかどうかだけが返されます。

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

DESCRIBE形式は、リソースに関するRDFデータを含む単一の結果RDFグラフを 返します。このデータはSPARQLクエリによって規定されるものではありません。そこでは クエリ・クライアントがデータソース内のRDF構造を知っている必要がありますが、 代わりにSPARQLクエリ処理系によって決定されます。クエリ・パターンは結果セットを 作成するために使用されます。DESCRIBE形式は、解で識別された各リソースを、 IRIで直接名付けられた任意のリソースとともに取り、対象RDFデータセットを含む 利用可能な任意の情報から来る「記述」を取ることで、単一のRDFグラフを組み立てます。 その記述はクエリサービスによって決定されます。構文DESCRIBE *は、 クエリ内のすべての変数を記述する省略形です。

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関数および演算子は、RDF用語およびSPARQL変数に対して作用します。 これらの関数および演算子の部分集合は、XPath and XQuery Functions and Operators 3.1 [XPATH-FUNCTIONS-31]から取られ、 XML Schemaの 型付き 値の引数および返り値型を持ちます。これらの関数および演算子に引数として渡される RDF literalsは、lexical formの 文字列値と、 データ型IRIに対応する 原子データ型を持つ XML Schema型付き値へ対応付けられます。返される型付き値は、同じ方法で RDF literalsへ対応付けられます。

SPARQLには、RDF用語の特定の部分集合に作用する追加の演算子があります。 型を参照する場合、次の用語は、対応するW3C XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes [XMLSCHEMA11-2]の データ型 IRIを持つliteralを示します。

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

次の用語は、SPARQL値テストで使用される追加の型を識別します。

• numericは、 データ型xsd:integer、xsd:decimal、xsd:float、または xsd:doubleを持つ リテラルを示します。
• RDF termは、 IRI、 リテラル、 空白ノード、または トリプル用語の型を示します。
• variableはSPARQL変数を示します。

次の型はnumeric型から派生し、 numeric引数を取る関数および演算子への有効な引数です。

• 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言語拡張は、追加の型をXML Schemaデータ型から派生するものとして 扱ってもよいです。

SPARQL式は、 解マッピングに関して、 かつアクティブグラフを持つ RDFデータセットの文脈で評価されます。 そのような評価の結果は、 RDF 用語または エラーのいずれかです。

SPARQLは、 XPath and XQuery Functions and Operatorsによって定義される関数および演算子の部分集合を提供します。 次の規則は、XPath/XQueryとSPARQLのデータモデルおよび実行モデルの違いに対応します。

• XPath/XQueryの関数とは異なり、SPARQLの関数は ノード列を処理しません。
• 誤った型の引数で呼び出された関数はエラーを生成します。
• 実効ブール値引数（下の演算子マッピング表で "xsd:boolean (EBV)"とラベル付けされたもの）は、 SPARQL EBV規則を用いてxsd:booleanへ強制変換されます。
• 関数形式 BOUND、COALESCE、 IF、IN、NOT IN、 logical-or（||）、 logical-and（&&）、 logical-not（!）、 NOT EXISTS、 EXISTS、および EBVを除き、 すべての関数はRDF用語に対して作用します。 関数は、いずれかの引数が未束縛である場合にエラーを生成します。
• logical-or（||）または logical-and（&&）以外の任意の式が エラーに遭遇した場合、そのエラーを生成します。
• 一方の分岐だけでエラーに遭遇するlogical-orは、 もう一方の分岐がTRUEであればTRUEを返し、もう一方の分岐がFALSEであればエラーを返します。
• 一方の分岐だけでエラーに遭遇するlogical-andは、 もう一方の分岐がTRUEであればエラーを返し、もう一方の分岐がFALSEであればFALSEを返します。
• 両方の分岐でエラーに遭遇するlogical-orまたは logical-andは、 いずれかのエラーを生成します。

true（T）、false （F）、およびerror（E）に対する logical-andおよびlogical-orの真理値表は次のとおりです。

xsd:boolean  EBV (RDF term term)

SPARQL文法は、制約を構築するために使用される演算子の集合 （たとえば、&&、 *、isIRI）を 識別します。次の表は、これらの各文法生成規則を、適切なオペランドおよび XPath and XQuery Functions and Operators 3.1 [XPATH-FUNCTIONS-31]または 第17.4節で指定されるSPARQL演算子のいずれかによって定義される 演算子関数と関連付けます。与えられたパラメータ集合に対する演算子定義を選択するときは、 最も具体的なパラメータを持つ定義が適用されます。たとえば、 xsd:integer = xsd:signedIntを評価する場合、 2つのRDF用語を持つ定義ではなく、 2つのnumericパラメータを持つ=の定義が適用されます。 表は、最上位の実行可能な候補が最も具体的になるよう配置されています。 適切なオペランドなしで呼び出された演算子は、 エラーになります。

SPARQLは、数値演算子への引数について、XPathの数値型昇格およびサブタイプ代入の仕組みに 従います。numericオペランド （xsd:integer、 xsd:decimal、xsd:float、xsd:double、および numeric型から派生した型）のための XPath演算子マッピング規則は、 SPARQL演算子にも適用されます（数値型 昇格およびサブタイプ代入の定義については、 XML Path Language (XPath) 3.1 [XPATH-31]を参照）。 一部の演算子は、入れ子になった関数式、たとえば fn:not(op:numeric-equal(A, B))と関連付けられます。XPath定義に従い、 fn:notおよびop:numeric-equalは、その引数がエラーである場合に エラーを生成することに注意してください。

fn:compareの照合順序は、 XPathによって定義され、 http://www.w3.org/2005/xpath-functions/collation/codepointによって識別されます。 この照合順序は、コードポイント値に基づく文字列比較を可能にします。コードポイント文字列の 等価性は、RDF用語の等価性でテストできます。

"(EBV)"で示されたxsd:boolean関数引数は、 その引数の実効ブール値を評価することによって xsd:booleanへ強制変換されます。

トリプル用語に適用される 演算子=および!=は、 各構成要素に演算子を適用します。

この節では、SPARQLクエリ言語によって導入される演算子および関数を定義します。 例は、適切な文法構成によって呼び出された演算子の挙動を示します。

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は、 XPath and XQuery Functions and Operators 3.1 [XPATH-FUNCTIONS-31]の 19.1 Casting from primitive types to primitive types節で定義されるXPathコンストラクター関数の部分集合を インポートします。 SPARQLコンストラクターには、SPARQLオペランド・データ型のための すべてのXPathコンストラクターに加え、RDFデータモデルによって課される 追加のデータ型が含まれます。 SPARQLにおけるキャストは、ソース型のオペランドに対してターゲット型の コンストラクター関数を呼び出すことによって行われます。

XPathは、あるXML Schemaデータ型から別のXML Schemaデータ型へのキャストだけを定義します。 残りのキャストは次のように定義されます。

• IRIをxsd:stringへキャストすると、 IRIを構成するコードポイントの字句値と、xsd:stringのデータ型を持つ リテラルが生成されます。

下の表は、常に許可される（Y）、決して許可されない （N）、および字句値に依存する （M）キャスト操作を要約しています。 たとえば、xsd:string（最初の行）からxsd:float （2番目の列）へのキャスト操作は、字句値に依存します（M）。

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

一部の条件下でエラーを返すよう指定されている任意の関数または演算子は、 有効な拡張ポイントであることに注意してください。すなわち、実装はこれらのエラーの場合に 非エラー値を返すことができ、それでもこの勧告に適合します。

PrimaryExpression文法規則は、IRIで名前付けされた 拡張関数の呼び出しであり得ます。拡張関数は、いくつかのRDF用語を引数として取り、 RDF用語を返します。これらの関数の意味論は、その関数を識別するIRIによって識別されます。

拡張関数を使用するSPARQLクエリは、相互運用性が制限される可能性があります。

例として、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))
}

2番目の例として、2点間の距離を計算する関数aGeo:distanceを考えます。 ここでは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 ) .
}

拡張関数は、コアSPARQL仕様でサポートされていない何らかのアプリケーション・データ型を テストするために使用されることがあります。また、たとえば別の日付形式から XSD dateTime RDF用語へ変換するような、データ型形式間の変換である場合もあります。

SPARQLクエリの評価意味論を定義するために、 SPARQLクエリ文字列の抽象構文木 （SPARQL文法によって定義されるもの）は、 まずSPARQL代数に似た構文へ変換されます。 この節では、この代数構文で形成できる式を定義し、 SPARQLクエリ文字列をこの代数構文へ変換する方法は 第 18.3 代数構文への変換で定義されます。

代数クエリ式は、 次のように再帰的に定義されます。

• 基本グラフ・パターンは 代数クエリ式です。
• 解マッピングのマルチセットは 代数クエリ式です。
• 解マッピングの列は 代数クエリ式です。
  Issue 231: 解マッピングの列とマルチセットの両方を 代数式として保持するか? spec:enhancement

  前の2項目は本当に両方必要でしょうか?
• ContextSolution は代数クエリ式です。
• Path(x, ppe, y) は、ppeが代数プロパティ・パス 式であり、 xがRDF用語または変数であり、かつ yがRDF用語または変数である場合、代数クエリ式です。
• Union(A₁, A₂) は、A₁とA₂が代数クエリ式である場合、 代数クエリ式です。
• Join(A₁, A₂) は、A₁とA₂が代数クエリ式である場合、 代数クエリ式です。
• Minus(A₁, A₂) は、A₁とA₂が代数クエリ式である場合、 代数クエリ式です。
• LeftJoin(A₁, A₂, expr) は、A₁とA₂が代数クエリ式であり、かつ exprが式である場合、代数クエリ式です。
• Filter(expr, A) は、exprが式であり、かつ Aが代数クエリ式である場合、代数クエリ式です。
• Extend(A, var, expr) は、Aが代数クエリ式であり、 varが変数であり、かつ exprが式である場合、代数クエリ式です。
• Graph(x, A) は、xがIRIまたは変数であり、かつ Aが代数クエリ式である場合、代数クエリ式です。
• ToMultiset(A) は、Aが代数クエリ式である場合、代数クエリ式です。
• ToList(A) は、Aが代数クエリ式である場合、代数クエリ式です。
• Group(exprlist, A) は、exprlistが式の空でない列であり、かつ Aが代数クエリ式である場合、代数クエリ式です。
• Aggregation(exprlist, func, scalarvals, grp) は、exprlistが式の空でない列またはアスタリスク 文字(*)であり、 funcが集合関数であり、 scalarvalsが部分関数（空関数、すなわち空の 定義域を持つ関数でもよい）であり、かつ grpがGroup(exprlist', A)の形式の代数クエリ式であり、 exprlist'が式の列であり、 Aが代数クエリ式である場合、代数クエリ式です。
  Issue 230: 'Group'および'Aggregation'は 代数構文の演算子であるべきではない spec:bug

  GroupおよびAggregationは 独立した演算子であるべきではなく、代わりに AggregateJoinの定義へ統合されるべきです。
• AggregateJoin(A₁, ..., A_n) は、A₁, ..., A_nが 代数クエリ式の空でない列（すなわちn ≥ 1）であり、 この列に含まれるすべての式A_iが、 Aggregation(exprlist_i, func_i, scalarvals_i, grp_i)の形式であり、 前の項目により捉えられる場合、代数クエリ式です。
• OrderBy(A, condition) は、Aが代数クエリ式であり、かつ conditionが順序条件である場合、代数クエリ式です。
  Issue 229: 「順序条件」の概念が未定義 spec:bug

  「順序条件」という用語は、この概念の何らかの定義へリンクするべきです。
• Project(A, PV) は、Aが代数クエリ式であり、かつ PVが変数の集合である場合、代数クエリ式です。
• Distinct(A) は、Aが代数クエリ式である場合、代数クエリ式です。
• Reduced(A) は、Aが代数クエリ式である場合、代数クエリ式です。
• Slice(A, offset) および Slice(A, offset, limit) は、Aが代数クエリ式であり、かつ offsetとlimitが非負整数である場合、代数クエリ式です。

前の定義で使用される 代数プロパティ・パス式の概念は、 次のように再帰的に定義されます。

• Link(iri) は、iriがIRIである場合、代数プロパティ・パス式です。
• NPS(I) は、IがIRIの空でない集合である場合、 代数プロパティ・パス式です。 NPSは否定プロパティ集合の頭字語です。
• Seq(ppe₁, ppe₂) は、ppe₁とppe₂が代数プロパティ・パス式である場合、 代数プロパティ・パス式です。
• Alt(ppe₁, ppe₂) は、ppe₁とppe₂が代数プロパティ・パス式である場合、 代数プロパティ・パス式です。
• Inv(ppe) は、ppeが代数プロパティ・パス式である場合、代数プロパティ・パス式です。
• ZeroOrOnePath(ppe) は、ppeが代数プロパティ・パス式である場合、代数プロパティ・パス式です。
• ZeroOrMorePath(ppe) は、ppeが代数プロパティ・パス式である場合、代数プロパティ・パス式です。
• OneOrMorePath(ppe) は、ppeが代数プロパティ・パス式である場合、代数プロパティ・パス式です。

この節では、SPARQLクエリ文字列内のグラフ・パターンおよび解修飾子を 代数 クエリ式へ変換する処理を定義します。記述される処理は、 入れ子になったSELECT構文を用いるサブクエリによって形成されるクエリの入れ子の 1レベルを変換し、サブクエリに再帰的に適用されます。各レベルは、グラフ・パターン照合および フィルタリングからなり、その後に解修飾子が適用されます。

SPARQLクエリ文字列は構文解析され、第 4. SPARQL 構文で与えられるIRIおよびトリプル・パターンの省略形が適用されます。 この時点で、抽象構文木は次の要素で構成されます。

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

Let FS := empty set
For each form FILTER(expr) in the group graph pattern
    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 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.