SPARQL 1.1クエリ言語

1.1 ドキュメントの概要

項の先頭で特に注記がなければ、このドキュメントのすべての項と付録は規範的です。

ドキュメントのこの項（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項は、EBNF表記法で示されている文法で規定されているような、SPARQLクエリ言語とSPARQL更新言語の構文の規範的な定義を含んでいます。

1.2 キュメントの慣習

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

2.1 シンプルなクエリの記述

次の例は、与えられたデータ・グラフから書名（title）を発見するためのPARQLクエリを示しています。クエリは、次の2つで構成されています。SELECT句はクエリの結果に現れる変数を識別し、WHERE句はデータ・グラフにマッチする基本グラフ・パターンを提供します。この例の基本グラフ・パターンは、目的語の位置に1つの変数（?title）を持つ、1つのトリプル・パターンから成ります。

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

2.2 複数マッチ

クエリの結果は、クエリのグラフ・パターンがデータにマッチする方法に従ったソリューション・シーケンスです。クエリに対し、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> .

これは、基本グラフ・パターン・マッチで、クエリ・パターンで使用されるすべての変数がすべてのソリューションにバインドされていなければなりません。

2.3 RDFリテラルのマッチング

次のデータには、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> }

2.4 クエリ結果の空白ノード・ラベル

クエリの結果には、空白ノードを含むことができます。このドキュメントの例では、結果集合の空白ノードは、"_:"の後に空白ノード・ラベルが続く形で書かれています。

空白ノード・ラベルは結果集合（「SPARQLクエリ結果XMLフォーマット」と「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と、同じラベルを持つデータ・グラフの空白ノードとの間に関係がある必要はありません。

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

2.5 式による値の作成

PARQL 1.1では、複数の式から値を作成できます。下記のクエリは、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)
}

2.6 RDFグラフの構築

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>

3.1 文字列の値の制限

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 1.0とXPath 2.0関数および演算子で定められており、XMLスキーマ正規表現に基づいています。

3.2 数値の制限

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

3.3 その他の用語制約

数値型に加え、SPARQLは、xsd:string、xsd:boolean、xsd:dateTimeという型をサポートしています（オペランド・データ型を参照してください）。演算子マッピングの項では、演算子について述べ、関数の定義の項では、RDF用語に適用できる関数について述べています。

4.1 RDF用語構文

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

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

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

[ :p "v" ] .

[] :p "v" .

_:b57 :p "v" .

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

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

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

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

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

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

4.2 トリプル・パターンの構文

トリプル・パターンは、主語、述語、目的語として書かれます。いくつかの共通するトリプル・パターン構成子を省略して書く方法があります。

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

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

5.1 基本グラフ・パターン

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

オプションのフィルタを有する、トリプル・パターンのシーケンスは、1つの基本グラフ・パターンから成ります。他のグラフ・パターンが、基本グラフ・パターンを終了させます。

5.2 グループ・グラフ・パターン

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

6.1 オプションのパターン・マッチング

グラフ・パターンのオプション部分は、次のグラフ・パターンに当てはまる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と、同じ主語を持つトリプルがある場合、ソリューションにはそのトリプルの目的語も含まれるでしょう。この例では、クエリのオプションのマッチ部分では1つのトリプル・パターンのみが得られますが、一般に、オプションの部分は任意のグラフ・パターンでありえます。オプションのグラフ・パターンの全体は、クエリのソリューションに影響するように、オプションのグラフ・パターンにマッチしなければなりません。

6.2 オプションのパターン・マッチングにおける制約

オプションのグラフ・パターンでは、制約を付与できます。例えば、次のとおりです。

@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」を伴うソリューションをもたらさなかったからです。

6.3 複数のオプションのグラフ・パターン

グラフ・パターンは再帰的に定義されます。グラフ・パターンは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 }
       }

8.1 グラフ・パターンを用いたフィルタリング

クエリ・ソリューションのフィルタリングは、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 }
}

8.2 ソリューションの除外

SPARQLが提供する別の形式の否定は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" .
   }
}

8.3 NOT EXISTSとMINUSの関係と違い

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

9.1 プロパティー・パス構文

下記の記述では、iriは、完全形か接頭辞付き名前で省略したIRI、または、キーワードaのいずれかです。eltはパス要素で、それ自体をパス構成子で構成することができます。

否定のプロパティー集合のIRIや逆のIRIの順序は重要ではなく、それらは混在した順序で出現する場合があります。

構文形式の優先順位は、次の上から下への順です。

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

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

9.2 例

選択肢: 片方または両方とマッチします。

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

シーケンス: アリスが知っているあらゆる人々の名前を見つけます。

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

シーケンス: 「foaf:knows」が2リンク離れた人々の名前を見つけます。

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

重複のフィルタリング: アリスが知っている人はおそらくアリスを知っているため、上記の例にはアリス自身が含まれている可能性があります。これは、次の方法で回避できます。

  { ?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によってアリスから到達可能なすべての人々の名前を見つけます。

  {
    ?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（または、逆のrdf:type）によってではありません。

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

RDFコレクションの要素:

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

注意: このパス式では、結果の順序を保証されません。

9.3 プロパティー・パスと同等パターン

SPARQLプロパティー・パスは、RDFトリプルを、有向性の、巡回的である可能性のある、名前付きの辺を有するグラフとして扱います。一部のプロパティー・パスは、トリプル・パターンおよびSPARQL UNIONグラフ・パターンへの置換と同等です。同等のパターンに導入された変数は結果の一部でなく、他では未使用であるため、プロパティー・パス式の評価は重複につながる場合があります。それらは、クエリで得られた変数のみへの結果の暗黙的な射影によって非表示になります。

例えば、次のデータでは:

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

9.4 任意の長さのパス・マッチング

任意の長さのプロパティー・パスによる主語と目的語の結合性は、「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
  }

パスの繰り返し自体により重複が発生することはあっても、この結合性のマッチングにより重複が発生することはありません（これには、結合を生成できる方法の数は含まれてはいません）。

マッチしたグラフには、循環が含まれる可能性があります。結合性マッチングは、マッチングの循環によって、未定義や無限の結果が生じないように定義されています。

10.1 BIND: 変数への割り当て

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

10.2 VALUES: インライン・データの提供

データは、VALUESを用いて、グラフ・パターンに直接記述するか、クエリに追加することができます。VALUESは、インライン・データを、joinオペレーションによるクエリ評価の結果と結合したソリューション・シーケンスとして提供します。これは、アプリケーションに用いてクエリ結果に特定の要件を提供することができ、また、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)
}

11.1 集約の例

@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句内には存在しない変数は、集約される場合には、単に射影することも、選択式で使用することもできます。SAMPLE集約は、この目的に使用できます。詳細については、射影制限の項を参照してください。

関数に従って、クエリまたはサブクエリから射影するためには、集約式を別名にする必要がある（ここでも、BIND句と同様に、キーワードASを用いる）ということに注意すべきです。上例では、これは変数?totalPriceを用いて行われます。他の集約の射影やWHERE句で既に使用されている名前を有する変数を集約が射影するとエラーとなります。

11.2 GROUP BY

ソリューションに対する集約の値を計算するため、最初にソリューションを1つ以上のグループに分割し、各グループに対して集約の値を算出します。

集約がSELECT、HAVINGやORDER BYのクエリ・レベルで用いられていても、GROUP BY用語が用いられていなければ、すべてのソリューションが属する1つの暗黙的なグループと見なされます。

GROUP BY句内では、バインディングのキーワードASは、GROUP BY (?x + ?y AS ?z)のように使用できます。これは{ ... 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

11.3 HAVING

FILTERがグループ化されていないソリューション集合で機能するのと同じように、HAVINGはグループ化されたソリューション集合で機能します。

次の項で述べているように、HAVING式にはグループ化されたクエリからの射影と同じ評価規則があります。

HAVINGの使用の一例を、以下で示しています。

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

これは、主語でグループ化されて、平均サイズを返すでしょうが、それは、平均サイズが10より大きい場合のみです。

11.4 集約射影制限

集約を用いたクエリ・レベルでは、1つの例外を除き、集約と定数で構成される式のみを射影できます。GROUP BYが、1つの変数のみで構成される1つ以上の単純式とともに与えられれば、それらの変数はレベルから射影できます。

例えば、?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 (STR(?z) AS ?strZ)の場合、?strZに射影できるでしょう。

GROUP BY変数を用いていない他の式や集約は、SAMPLE集約を用いて、それらのグループから非確定的な値を射影できます。

11.5 集約の例（エラーがある場合）

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

データ:

@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はエラーで、ソリューションからバインディングが削除されることに注意してください。

13.1 RDFデータセットの例

RDFデータセットの定義は、名前付きグラフとデフォルト・グラフの関係を制限しません。異なるグラフで情報を繰り返すことができ、グラフ間の関係を公開できます。次の2つの有益な処理があります。

• 名前付きグラフに関する来歴情報を含む情報をデフォルト・グラフに持つこと
• 名前付きグラフの情報をデフォルト・グラフに含むこと

# Default graph
@prefix dc: <http://purl.org/dc/elements/1.1/> .

<http://example.org/bob>    dc:publisher  "Bob" .
<http://example.org/alice>  dc:publisher  "Alice" .

# Named graph: http://example.org/bob
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

_:a foaf:name "Bob" .
_:a foaf:mbox <mailto:bob@oldcorp.example.org> .

# Named graph: http://example.org/alice
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

_:a foaf:name "Alice" .
_:a foaf:mbox <mailto:alice@work.example.org> .

この例では、デフォルト・グラフには、2つの名前付きグラフの公開者名が含まれています。名前付きグラフのトリプルは、この例のデフォルト・グラフでは表示されません。

例2:

RDFデータは、グラフのRDFマージ[RDF-MT]によって組み合わすことができます。RDFデータセットにおける、グラフの1つの可能な処理は、デフォルト・グラフを名前付きグラフの情報の一部またはすべてのRDFマージにすることです。

次の例では、名前付きグラフには、以前と同じトリプルが含まれています。RDFデータセットは、デフォルト・グラフに名前付きグラフのRDFマージを含んでおり、再ラベル付けを行って空白ノードを異なったものにしておきます。

# Default graph
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

_:x foaf:name "Bob" .
_:x foaf:mbox <mailto:bob@oldcorp.example.org> .

_:y foaf:name "Alice" .
_:y foaf:mbox <mailto:alice@work.example.org> .

# Named graph: http://example.org/bob
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

_:a foaf:name "Bob" .
_:a foaf:mbox <mailto:bob@oldcorp.example.org> .

# Named graph: http://example.org/alice
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

_:a foaf:name "Alice" .
_:a foaf:mbox <mailto:alice@work.example> .

13.2 RDFデータセットの指定

SPARQLクエリは、RDFデータセットを記述するために、FROM句とFROM NAMED句を用いて、マッチングに用いるデータセットを指定できます。クエリがそのようなデータセットの記述を提供していれば、それは、データセットの記述がクエリで提供されない場合にクエリ・サービスが使用する任意のデータセットの代わりに使用しています。また、RDFデータセットは、SPARQLプロトコル要求で指定することもできます。その場合、プロトコルの記述により、クエリ自体のあらゆる記述は無効になります。クエリ・サービスがデータセットの記述を許容できない場合には、サービスはクエリ要求を拒否するかもしれません。

FROMとFROM NAMEDキーワードによって、クエリは参照によってRDFデータセットを指定できます。これは、データセットが、与えられたIRI（すなわち、与えられたIRI参照の絶対形式）によって識別された資源の表現から得られるグラフを含むべきであるということを示しています。いくつかのFROMとFROM NAMED句から生じるデータセットは次の通りです。

• FROM句で参照されたグラフのRDFマージから成るデフォルト・グラフ、および
• 1組（IRI、グラフ）の対で、各FROM NAMED句から1つずつ。

FROM句はないけれども複数の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 }
}

13.3 データセットのクエリ実行

グラフのコレクションにクエリを実行する際には、GRAPHキーワードを用いて、名前付きグラフに対してパターンをマッチングさせます。GRAPHは、IRIを提供して1つのグラフを選択するか、クエリの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
  }
}

変数nickを含むパターンがppdによって特定のパーソナル・プロフィール・ドキュメントに制限されているため、Bobのnickを示しているAliceのFOAFファイルのトリプルは、Bobにnickを提供するために用いられていません。

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

15.1 ORDER BY

ORDER BY句は、ソリューション・シーケンスの順序を定めます。

ORDER BY句の後には、式と、オプションの順序修飾子（ASC()かDESC()のどちらか）で構成された順序コンパレータ（order comparator）のシーケンスが続きます。各順序付けコンパレータは、昇順（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)

「<」という演算子（演算子マッピングおよび17.3.1 演算子の拡張性を参照）は、数値（numerics）、シンプルなリテラル（simple literals）、xsd:strings、xsd:booleans、xsd:dateTimesの対の相対順序を定めます。IRIの対は、simple literalsとして比較し、順序付けられます。

SPARQLは、次の、別の方法では順序付けられない数種のRDF用語間の順序も定めます。

1. （最も順序が低い） このソリューションの変数または式に割り当てられていない値
2. 空白ノード
3. IRI
4. RDFリテラル

プレーン・リテラルは、同じ字句形式の型xsd:stringを持つRDFリテラルよりも順序が低いです。

SPARQLは、可能な限りのあらゆるRDF用語の全体的な順序付けを定めるわけではありません。以下は、相対順序が定められていない対の用語のいくつかの例です。

• "a" と "a"@en_gb（シンプルなリテラルと言語タグ付きリテラル）
• "a"@en_gb と "b"@en_gb（言語タグを持つ2つのリテラル）
• "a" と "1"^^xsd:integer（シンプルなリテラルとサポートされているデータ型を持つリテラル）
• "1"^^my:integer と "2"^^my:integer（2つのサポートされていないデータ型）
• "1"^^xsd:integer と "2"^^my:integer（サポートしているデータ型とサポートされていないデータ型）

この変数バインディングのリストは、昇順です。

順序付けコンパレータに対する2つのソリューションの昇順は、ソリューションのバインディングを式に代入し、それを「<」演算子で比較することで定めることができます。降順は昇順の逆です。

2つのソリューションの相対順序は、シーケンス内の最初の順序付けコンパレータに対する2つのソリューションの相対順序です。ソリューション・バインディングの置換が同じRDF用語を作成するソリューションの場合は、順序は次の順序付けコンパレータに対する2つのソリューションの相対順序です。2つのソリューションに対して評価が行われた順序の式が別々のRDF用語を作成しない場合、2つのソリューションの相対順序は未定義です。

ソリューションのシーケンスの順序付けは、常に、その内部に同数のソリューションを持つシーケンスになります。

ソリューション・シーケンスでCONSTRUCTまたはDESCRIBEクエリに対しORDER BYを使用すると、SELECTのみが結果のシーケンスを返すため、直接的な効果はありません。LIMITやOFFSETと組み合わせて用いれば、ORDER BYは、ソリューション・シーケンスの異なる部分から生じる結果を返すために使用できます。ASKクエリは、ORDER BY、LIMIT、または、OFFSETを含みません。

15.2 射影

ソリューション・シーケンスは変数のサブセットのみを含むものに変換できます。シーケンスの各ソリューションに対し、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 }

15.3 ソリューションの複製

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 }

15.4 OFFSET

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

15.5 LIMIT

LIMIT句は、返されるソリューションの数に上限を設けます。OFFSETが適用された後で、実際のソリューションの数がlimitより大きい場合は、最大で、limitの数のソリューションが返されるでしょう。

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

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

LIMITを0にすれば、結果を返さないでしょう。limitは負の数であってはなりません。

16.1 SELECT

結果の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 
}

16.2 CONSTRUCT

CONSTRUCTクエリ形式は、グラフ・テンプレートで指定された1つのRDFグラフを返します。結果は、各クエリのソリューションをソリューション・シーケンスに取り込み、グラフ・テンプレートに変数を代入し、和集合によってトリプルを1つの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#> .

_:v1 vcard:N         _:x .
_:x vcard:givenName  "Alice" .
_:x vcard:familyName "Hacker" .

_:v2 vcard:N         _:z .
_:z vcard:givenName  "Bob" .
_:z 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 }

16.3 ASK

アプリケーションは、クエリ・パターンにソリューションがあるか否かをテストするために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

16.4 DESCRIBE（参考情報）

DESCRIBE形式は、資源に関するRDFデータを含んだ1つの結果RDFグラフを返します。SPARQLのクエリではこのデータは規定されておらず、この場合には、クエリのクライアントがデータ情報源内のRDFの構造を知っている必要があるでしょうが、その代わりにSPARQLクエリ・プロセッサがこのデータを決定します。クエリ・パターンを用いて結果集合を作成します。DESCRIBE形式は、IRIで直接指定された任意の資源と一緒に、識別された各資源をソリューションに取り込み、ターゲットのRDFデータセットを含んでいる利用可能な任意の情報から得られる「記述」を持ってくることによって、1つの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 .

17.1 オペランド・データ型

SPARQLの関数と演算子は、RDF用語とSPARQL変数を演算します。これらの関数および演算子のサブセットは、XQuery 1.0とXPath 2.0関数および演算子[FUNCOP]から持って来たもので、XMLスキーマ型付き値の引数を持っており、型を返します。これらの関数と演算子に引数として渡されたRDF型付きリテラル（typed literals）は、字句形式（lexical form）の文字列の値を持つXMLスキーマの型付き値と、データ型IRIに対応するアトミックなデータ型にマッピングされます。返された型付き値は、同様にRDFの型付きリテラル（typed literals）にマッピングし返されます。

SPARQLには、RDF用語の特定のサブセットに基づいて演算する付加的な演算子があります。型について述べるときには、次の用語は、XMLスキーマ[XSDT]のデータ型IRIに対応する型付きリテラル（typed literal）を表します。

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

次の用語は、SPARQL値テストに用いられる付加的な型を識別します。

• 数値は、データ型xsd:integer、xsd:decimal、xsd:float、および、xsd:doubleを持つ型付きリテラル（typed literals）を表します。
• シンプルなリテラルは、言語タグ（language tag）を持たないプレーン・リテラル（plain literal）を表します。
• RDF用語は、IRI、リテラル（literal）、および、空白ノード（blank node）の型を表します。
• 変数は、SPARQL変数を表します。

次の型は、数値の型から得られ、数値引数を取る関数と演算子に対する有効な引数です。

• 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スキーマ・データ型から得られるものとして扱うことができます。

17.2 フィルタ評価

SPARQLは、XQuery演算子マッピングで定義された関数と演算子のサブセットを提供します。XQuery 1.0の2.2.3 式の処理の項では、XPath関数の呼び出しについて説明しています。次の規則は、XQueryとSPARQLのデータと実行モデルの違いを調整します。

• XPath/XQueryとは異なり、SPARQL関数はノード・シーケンスを処理しません。XPath関数のセマンティクスを解釈するときには、それぞれの引数が1つのノードのシーケンスであると想定します。
• 間違った型の引数で呼び出された関数は型エラーを起こすでしょう。有効なブール値引数（下記の演算子マッピング・テーブルで「xsd:boolean (EBV)」とラベル付けされている）は、17.2.2項のEBV規則を用いてxsd:booleanに強制変換されます。
• BOUND、COALESCE、NOT EXISTS、EXISTSは別として、任意の引数がバインドされていなければ、すべての関数と演算子はRDF用語に基づいて演算し、型エラーを起こすでしょう。
• エラーに遭遇した論理OR（||）または論理AND（&&）を除く任意の式は、エラーを起こすでしょう。
• 1つの辺のみでエラーに遭遇した論理ORは、もう一方の辺がTRUEであるならTRUEを、FALSEであるならエラーを返します。
• 1つの辺のみでエラーに遭遇した論理ANDは、もう一方の辺がTRUEであるならエラーを、FALSEであるならFALSEを返します。
• 両方の辺でエラーに遭遇した論理ORまたは論理ANDは、どちらかのエラーを起こします。

真（T）、偽（F）、エラー（E）に対する論理ANDと論理ORの真理値表は次の通りです。

17.3 演算子マッピング

SPARQLの文法は、一連の演算子を識別し（例えば、&&、*、isIRI）、制約を構築するために用いられます。以下のテーブルは、これらのそれぞれの文法上の生成規則と、XQuery 1.0とXPath 2.0関数および演算子[FUNCOP]、または17.4項のSPARQL演算子のいずれかによって定義されている適切なオペランドおよび演算子関数とを関連付けます。一連のパラメータに対する演算子定義を選択する際には、最も明確なパラメータを持つ定義が適用されます。例えば、xsd:integer = xsd:signedIntを評価する際には、2つのRDF用語を持つ=に対する定義ではなく、2つの数値（numeric）パラメータを持つ=に対する定義が適用されます。表は、最も実行可能性のある候補が最も明確になるように配列されています。適切なオペランドなしに呼び出された演算子は、型エラーになります。

SPARQLは、XPathの数値型昇格（numeric type promotion）に対するスキームと、数値演算子への引数に対する部分型置換（subtype substitution）に従います。数値オペランド（xsd:integer、xsd:decimal、xsd:float、xsd:double、および数値型から得られた型）のXPath演算子マッピング規則は、SPARQL演算子にも適用されます（数値型昇格および部分型置換の定義に関しては、XMLパス言語（XPath）2.0[XPATH20]を参照してください)。演算子の一部は、入れ子にされた関数式、例えば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に強制されます:。

17.4 関数の定義

この項では、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  xsd:boolean left || xsd:boolean right

 xsd:boolean  xsd:boolean left && xsd:boolean right

 xsd:boolean  RDF term term1 = RDF用語 term2

@prefix foaf:       <http://xmlns.com/foaf/0.1/> .

_:a  foaf:name       "Alice".
_:a  foaf:mbox       <mailto:alice@work.example> .

_:b  foaf:name       "Ms A.".
_:b  foaf:mbox       <mailto:alice@work.example> .
              

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

@prefix a:          <http://www.w3.org/2000/10/annotation-ns#> .
@prefix dc:         <http://purl.org/dc/elements/1.1/> .

_:b   a:annotates   <http://www.w3.org/TR/rdf-sparql-query/> .
_:b   dc:date       "2004-12-31T19:00:00-05:00"^^<http://www.w3.org/2001/XMLSchema#dateTime> .

PREFIX a:      <http://www.w3.org/2000/10/annotation-ns#>
PREFIX dc:     <http://purl.org/dc/elements/1.1/>
PREFIX xsd:    <http://www.w3.org/2001/XMLSchema#>

SELECT ?annotates
WHERE { ?annot  a:annotates  ?annotates .
        ?annot  dc:date      ?date .
        FILTER ( ?date = xsd:dateTime("2005-01-01T00:00:00Z") ) 
      }

 xsd:boolean  sameTerm (RDF用語 term1, RDF term term2)

@prefix foaf:       <http://xmlns.com/foaf/0.1/> .

_:a  foaf:name       "Alice".
_:a  foaf:mbox       <mailto:alice@work.example> .

_:b  foaf:name       "Ms A.".
_:b  foaf:mbox       <mailto:alice@work.example> .

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

@prefix :          <http://example.org/WMterms#> .
@prefix t:         <http://example.org/types#> .

_:c1  :label        "Container 1" .
_:c1  :weight       "100"^^t:kilos .
_:c1  :displacement  "100"^^t:liters .

_:c2  :label        "Container 2" .
_:c2  :weight       "100"^^t:kilos .
_:c2  :displacement  "85"^^t:liters .

_:c3  :label        "Container 3" .
_:c3  :weight       "85"^^t:kilos .
_:c3  :displacement  "85"^^t:liters .

PREFIX  :      <http://example.org/WMterms#>
PREFIX  t:     <http://example.org/types#>

SELECT ?aLabel1 ?bLabel
WHERE { ?a  :label        ?aLabel .
        ?a  :weight       ?aWeight .
        ?a  :displacement ?aDisp .

        ?b  :label        ?bLabel .
        ?b  :weight       ?bWeight .
        ?b  :displacement ?bDisp .

        FILTER ( sameTerm(?aWeight, ?bWeight) && !sameTerm(?aDisp, ?bDisp)) }

boolean  rdfTerm IN (expression, ...)

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

boolean  rdfTerm NOT IN (expression, ...)

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

 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)

 simple literal  STR (literal ltrl)
 simple literal  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$") }

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

 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(simple literal)
 iri  IRI(xsd:string)
 iri  IRI(iri)
 iri  URI(simple literal)
 iri  URI(xsd:string)
 iri  URI(iri)

blank node  BNODE()

blank node  BNODE(simple literal)

blank node  BNODE(xsd:string)

literal  STRDT(simple literal lexicalForm, IRI datatypeIRI)

literal  STRLANG(simple literal lexicalForm, simple literal langTag)

iri  UUID()

simple literal  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)

simple literal  ENCODE_FOR_URI(string literal ltrl)

string literal  CONCAT(string literal ltrl1 ... string literal ltrln)

 xsd:boolean  langMatches (simple literal language-tag, simple literal language-range)

@prefix dc:       <http://purl.org/dc/elements/1.1/> .

_:a  dc:title         "That Seventies Show"@en .
_:a  dc:title         "Cette Serie des Annees Soixante-dix"@fr .
_:a  dc:title         "Cette Serie des Annees 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, simple literal pattern)
 xsd:boolean  REGEX (string literal text, simple literal pattern, simple literal 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, simple literal pattern, simple literal replacement )
 string literal  REPLACE (string literal arg, simple literal pattern, simple literal replacement,  simple literal flags)

 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)

 simple literal  TZ (xsd:dateTime arg)

 simple literal  MD5 (simple literal arg)

 simple literal  MD5 (xsd:string arg)

 simple literal  SHA1 (simple literal arg)

 simple literal  SHA1 (xsd:string arg)

 simple literal  SHA256 (simple literal arg)

 simple literal  SHA256 (xsd:string arg)

 simple literal  SHA384 (simple literal arg)

 simple literal  SHA384 (xsd:string arg)

 simple literal  SHA512 (simple literal arg)

 simple literal  SHA512 (xsd:string arg)

17.5 XPathコンストラクタ関数

SPARQLは、XQuery 1.0とXPath 2.0関数および演算子[FUNCOP]の17.1 プリミティブ型からプリミティブ型へのキャスティングで定義されているXPathコンストラクタ関数のサブセットをインポートします。SPARQLコンストラクタは、RDFデータ・モデルが規定しているSPARQLオペランド・データ型と付加的なデータ型のXPathコンストラクタのすべてを含んでいます。SPARQLのキャスティングは、情報源の型のオペランドにターゲット型に対するコンストラクタ関数を呼び出すことによって実行されます。

XPathは、1つのXMLスキーマ・データ型から別のデータ型へのキャストのみを定義しています。残りのキャストは、次の通り定義されています。

• IRIをxsd:stringにキャストすると、そのIRIを構成するコードポイントの字句値を持つ型付きリテラル、およびxsd:stringのデータ型が作成されます。
• シンプルなリテラルのXMLスキーマ・データ型へのキャスティングは、ターゲットのデータ型にリテラルの字句値と等しい文字列値を持つ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
ltrl = simple literal

17.6 拡張可能な値テスト

ある条件でエラーを返すように定められている関数や演算子も、有効な拡張ポイントであることに注意すべきです。つまり、実装では、これらのエラーが発生した場合には非エラー値が返され、この勧告との適合性も保たれます。

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用語へのデータ型フォーマット間の変換であるかもしれません。

18.1 初期定義

「[RDFコア・ワーキンググループは]リテラルが主語であってはならない理由がないことを
承知していると述べました。そして、より制限のない憲章を持つ将来のWGは、ステートメン
トの主語としてのリテラルを許容するように構文を拡張するかもしれません。」

18.2 SPARQL代数への置換

この項は、SPARQLクエリ文字列内のグラフ・パターンとソリューション修飾子をSPARQL代数式に変換するプロセスを定義します。 記述したプロセスは、1つのクエリの入れ子のレベルを変換し、入れ子のSELECT構文を用いてサブクエリによって生成される際に、サブクエリ上で再帰的に適用されます。個々のレベルは、グラフ・パターン・マッチングとフィルタリングで構成され、その後に、ソリューション修飾子のアプリケーションが続きます。

SPARQLクエリ文字列が分析され、4項で示したIRIとトリプル・パターンの省略形が適用されます。現時点では、抽象構文木は、以下で構成されています。

このような抽象構文木を変換した結果は、次の表の符号をSPARQL代数で用いるSPARQLクエリです。

Sliceは、OFFSETとLIMITを組み合わせたものです。

ToListはグラフ・パターン・マッチングの結果からシーケンスへの変換が起こる場合に用いられます。

ソリューション・シーケンスから多重集合への変換が生じる場合には、ToMultiSetが用いられます。

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

A := 未定義とします。
          
For each element G in the GroupOrUnionGraphPattern
    If A is undefined
        A := Translate(G)
    Else
        A := Union(A, Translate(G))
    End

結果はA

形式がGRAPH IRI GroupGraphPatternであれば、
    結果はGraph(IRI, Translate(GroupGraphPattern))

形式がGRAPH Var GroupGraphPatternであれば、
    結果はGraph(Var, Translate(GroupGraphPattern))

S := 空の集合とします。
G := 空のパターン、空の集合である基本グラフ・パターンとします。

For each element E in the GroupGraphPattern

    If E is of the form OPTIONAL{P}
        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
   
結果はGです。

結果はソリューション・マッピング「データ」の多重集合です。

結果は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

Let A := the empty sequence
Let Q := the query level being evaluated
Let P := the algebra translation of the GroupGraphPattern of the query level
Let E := [], a list of pairs of the form (variable, expression)

If Q contains GROUP BY exprlist
   Let G := Group(exprlist, P)
Else If Q contains an aggregate in SELECT, HAVING, ORDER BY
   Let G := Group((1), P)
Else
   skip the rest of the aggregate step
   End

Global i := 1   # Initially 1 for each query processed

For each (X AS Var) in SELECT, each HAVING(X), and each ORDER BY X in Q
  For each unaggregated variable V in X
      Replace V with Sample(V)
      End
  For each aggregate R(args ; scalarvals) now in X
      # note scalarvals may be omitted, then it's equivalent to the empty set
      Ai := Aggregation(args, R, scalarvals, G)
      Replace R(...) with aggi in Q
      i := i + 1
      End
  End

For each variable V appearing outside of an aggregate
   Ai := Aggregation(V, Sample, {}, G)
   E := E append (V, aggi)
   i := i + 1
   End

A := Ai, ..., Ai-1
P := AggregateJoin(A)

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

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

Let Q := the query level being evaluated
Let P := the algebra translation of the query level so far

For each HAVING(E) in Q
    P := Filter(E, P)
    End

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

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

Let X := algebra from earlier steps
Let VS := list of all variables visible in the pattern,
           so restricted by sub-SELECT projected variables and GROUP BY variables.
           Not visible: only in filter, exists/not exists, masked by a subselect, 
                        non-projected GROUP variables, only in the right hand side of MINUS

Let PV := {}, a set of variable names
Note, E is a list of pairs of the form (variable, expression), defined in section 18.2.4
  
If "SELECT *"
    PV := VS

If  "SELECT selItem ...:"  
    For each selItem:
        If selItem is a variable
            PV := PV ∪ { variable }
        End
        If selItem is (expr AS variable)
            variable must not appear in VS nor in PV; if it does then generate a syntax error and stop
            PV := PV ∪ { variable }
            E := E append (variable, expr) 
        End
    End

For each pair (var, expr) in E
    X := Extend(X, var, expr)
    End
  
Result is X  
The set PV is used later for projection.

18.3 基本グラフ・パターン

グラフ・パターンをマッチさせるときには、可能なソリューションは、バッグ（bag）としても知られている多重集合[multiset]を形成します。多重集合は、各要素が1回以上出現しうる要素の順不同のコレクションです。これは、多重集合内の集合の各要素の出現回数を示す、1組の要素とカーディナリティー関数で記述されます。

ソリューション・マッピングを、μと記述する。

dom(μ₀)が空の集合であるようなマッピングを、μ₀と記述します。

カーディナリティー1を持つ、空のマッピングμ_0,からきっかり成る多重集合を、Ω₀と記述します。これは、joinと同値です。

RDF用語t : { (x, t) }に対するソリューション・マッピング変数xを、μ(x)と記述します。

きっかりμ(?x->t)から成る多重集合、つまり、カーディナリティー1を持つ{ { (x, t) } }を、Ω(x)と記述します。

Here, μ₁(v) = μ₂(v) means that μ₁(v) and μ₂(v) are the same RDF term.

μ₁とμ₂に互換性がある場合、μ₁ ∪ μ₂もマッピングです。μ₁ ∪ μ₂を、merge(μ₁, μ₂)と記述します。

マッピングΩの多重集合におけるソリューション・マッピングμのカーディナリティーを、card[Ω](μ)と記述します。

18.4 プロパティー・パス・パターン

この項では、プロパティー・パス・パターンの評価について定義します。プロパティー・パス・パターンは、主語エンドポイント（RDF用語または変数）、プロパティー・パス式および目的語エンドポイントです。プロパティー・パス式の置換は、長さ1のプロパティー・パスをトリプル・パターンに変換するなど、ある形式を他のSPARQL式に変換し、これは次に基本グラフ・パターンにまとめられます。これによって、ZeroOrOnePath、ZeroOrMorePath、OneOrMorePath、NegatedPropertySetsというプロパティー・パス・オペレーターと、さらに、これらのオペレーター内に含まれているパス式が残ります。

すべの残りのプロパティー・パス式は、エンドポイントのXとYに対し、Path(X, path, Y)という形式で代数内にあります。例えば、(:p/:q)*という構文は、ZeroOrMorePath式で、シーケンス・プロパティー・パスを伴い、ZeroOrMorePath(seq(link(:p), link(:q)))という代数式になります。

eval(Path(X, PP, Y))

すべての評価は、全体のクエリ評価において、その時点のアクティブ・グラフとのマッチングにより行なわれます。明確にするために、個々の定義へのアクティブ・グラフの組み込みを明示的に省略しています。

XとYの両方が変数ならば、これは次と同じです。

Xが変数で、YがRDF用語である場合、

XがRDF用語で、Yが変数である場合、

XとYの両方がRDF用語である場合、

非形式的には、述語プロパティ・パスの評価は、クエリ評価において、その時点のサブクエリSELECT * { X P Y }を実行するのと同じことです。

非形式的には、これは次と同じです。

SELECT * { X P _:a . _:a Q Y }

これは、空白ノード_:aは、それがSELECT *の結果に出現しない場合を除いて、変数のように機能する（シンプルな含意において）という事実を用いています。

非形式的には、これは次と同じです。

SELECT * { { X P Y } UNION { X Q Y } }

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

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

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

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

このドキュメントでは、ZeroOrMorePathとOneOrMorePathの定義で用いられる補助関数（ALP）を定義しています。ここで示しているアルゴリズムが機能を指定する役割を果たすをことに注意してください。実装では、全体としてクエリに対して同じ結果を生むあらゆる方法による評価を自由に実行することができます。ZeroOrMorePathとOneOrMorePathの形式は、パスによって結合されている別々のノードに基づいて、マッチを返します。

マッチング・アルゴリズムは、すべてのパスをたどることを基礎としており、パス上でグラフ・ノード（主語または目的語）が訪問済みである場合に検知します。

非形式的には、このアルゴリズムは、パスの1つのアプリケーションによって、ステップごとに結果の多重集合を拡張しようと試み、この特定のパスのどのノードを既に訪問したかを指摘します。検討中のパスをノードが既に訪問していれば、それは、別のステップの候補になりません。

Let eval(x:term, path) be the evaluation of 'path', starting at RDF term x, 
                       and returning a multiset of RDF terms reached 
                       by repeated matches of path.

ALP(x:term, path) = 
    Let V = empty multiset
    ALP(x:term, path, V)
    return is V

# V is the set of nodes visited

ALP(x:term, path, V:set of RDF terms) =
    if ( x in V ) return 
    add x to V
    X = eval(x,path) 
    For n:term in X
        ALP(n, path, V)
        End

eval(Path(X:term, ZeroOrMorePath(path), vy:var)) =
    { { (vy, n) } | n in ALP(X, path) }

eval(Path(vx:var, ZeroOrMorePath(path), vy:var)) =
    { { (vx, t), (vy, n) } |  t in nodes(G), (vy, n) in eval(Path(t, ZeroOrMorePath(path), vy)) }

eval(Path(vx:var, ZeroOrMorePath(path), y:term)) = 
    eval(Path(y:term, ZeroOrMorePath(inv(path)), vx:var))

eval(Path(x:term, ZeroOrMorePath(path), y:term)) = 
    { { } } if { (vy:var,y) } in eval(Path(x, ZeroOrMorePath(path) vy)
    { } otherwise

# For OneOrMorePath, we take one step of the path then start
# recording nodes for results.

eval(Path(x:term, OneOrMorePath(path), vy:var)) =
    Let X = eval(x, path)
    Let V = the empty multiset
    For n in X
        ALP(n, path, V)
        End
    result is V

eval(Path(vx:var, OneOrMorePath(path), vy:var)) =
   { { (vx, t), (vy, n) } |  t in nodes(G), (vy, n) in eval(Path(t, OneOrMorePath(path), vy)) }

eval(Path(vx:var, OneOrMorePath(path), y:term)) =
   eval(Path(y:term, OneOrMorePath(inv(path)), vx))

eval(Path(x:term, OneOrMorePath(path), y:term)) =
    { { } } if { (vy:var, y) } in eval(Path(x, OneOrMorePath(path), vy))
    { } otherwise

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

Let x and y be variables or RDF terms, and S a set of IRIs:

eval(Path(x, NPS(S), y)) = { μ | ∃ triple(μ'(μ,x), p, μ'(μ,y)) in G, such that the IRI of p ? S }

18.5 SPARQL代数

SPARQLの抽象クエリに内の残りの各シンボルに対し、評価のための演算子を定義しています。同じ名前のSPARQL代数演算子は、「評価セマンティクス」の項で記述されているように、SPARQLの抽象クエリ・ノードを評価するために用いられます。基本グラフ・パターントプロパティー・パス・パターンの評価は、上で記述しました。

Joinにおけるソリューション・マッピングμは、異なるソリューション・マッピング、結合された多重集合におけるμ₁とμ₂において出現することは可能です。μのカーディナリティーは、すべての可能性のカーディナリティーの合計です。

Diffは、LeftJoinの定義のために内部的に使用されます。

これは、完全形で記述すれば、次の通りです。

LeftJoin(Ω₁, Ω₂, expr) =
    { merge(μ_1, μ₂) | μ₁ in Ω₁ and μ₂ in Ω₂, μ₁ and μ₂ are compatible and expr(merge(μ₁, μ₂)) is true }
∪
    { μ₁ | μ₁ in Ω₁, ∀ μ₂ in Ω₂, μ₁ and μ₂ are not compatible, or Ω₂ is empty }
∪
    { μ₁ | μ₁ in Ω₁, ∃ μ₂ in Ω₂, μ₁ and μ₂ are compatible and expr(merge(μ₁, μ₂)) is false. }

これらが異なっているため、LeftJoinのカーディナリティーは、定義のこれらの個々の構成要素のカーディナリティーです。

dom(μ)とdom(μ')には制限が追加されています。なぜならば、そうでない場合、Ω₁のソリューション・マッピングと同様に変数を持っていないΩ₂にソリューション・マッピングがあれば、Minus(Ω₁, Ω₂)は、残りのΩ₂にかかわらず、空になるだろうからです。空のソリューション・マッピングは、他のすべてのソリューション・マッピングと互換性があります。したがって、そうでない場合、P MINUS {}は任意のパターンPに対し空でしょう。

Cがxの条件である場合、要素のシーケンスに対し[ x | C ]と書きます。

Lでのxというカーディナリティーになるように、card[L](x)と書きます。

Reducedソリューション・シーケンス修飾子は、定義済みのカーディナリティーを保証しません。

ListEvalは、ソリューションに対する式のリストを評価し、結果の値のリストを返すために用いられる関数です。

18.6 評価セマンティクス

我々は、eval(D(G), algebra expression)を、アクティブ・グラフGを持つデータセットDに関する代数式の評価であると定義しています。アクティブ・グラフは、最初はデフォルト・グラフです。

D : データセット
D(G) : アクティブ・グラフGを持つデータセットD（パターンがマッチするもの）
D[i] : データセットDにIRI iを持つグラフ
P, P1, P2 : グラフ・パターン
L : ソリューション・シーケンス
F : 式

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

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

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

「substitute」は、existsに置換されたEXISTSとNOT EXISTSの形式の評価をサポートするフィルタ関数です。

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

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

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

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

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

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

グラフの評価は、SPARQL代数和集合演算子を使用します。ソリューション・マッピングのカーディナリティーは、それぞれのjoinの操作における、そのソリューション・マッピングのカーディナリティーの合計です。

eval(D(G), A_i)がエラーであれば、無視されることに注意してください。

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

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

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

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

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

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

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

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

18.7 SPARQL基本グラフ・マッチングの拡張

SPARQLの全体的な設計は、基本グラフ・パターンにマッチングした条件を書き直すことによって、シンプルな含意ではなく、より精緻な形式の含意を想定したクエリに使用できます。1つの一般的な形式でそのような条件を記述し、それをすべての形式の含意に適用して不必要または不適切な重複を最適に排除することは、未解決の研究課題であるため、このドキュメントは、そのようなソリューションが満たすべき必要条件を提示するのみです。これらは、それぞれの具体的な事例に対する完全な定義に拡張する必要があるでしょう。

基本グラフ・パターンは、RDFグラフがRDFトリプルに対して行うトリプルのパターンと同じ関係にあり、同じ用語の多くをそれらに適用できます。特に、トリプル（M(s), M(p), M(o)）が2番目のパターンにある場合に限りトリプル（s, p, o）が最初のパターンに存在するような、空白ノードを空白ノードにマッピングし、変数、リテラル、およびIRIをそれら自身にマッピングするトリプル・パターンの用語間に全単射Mがある場合、2つの基本グラフ・パターンはが同等であると述べられます。この定義は、変数名を同等なパターン全体で保持することによって、RDFグラフの同等性に対し、それを基本グラフ・パターンに拡張します。

含意レジーム（entailment regime）は、次の仕様を定めます。

1. レジームに対する整形式と呼ばれるRDFグラフのサブセット
2. 整形式のグラフと整形式のグラフのサブセットの間の含意関係

様々な含意レジームのクエリに関する詳細な定義は、SPARQL 1.1含意レジームにあります。

いくつかの含意レジームは、いくつかのRDFグラフを、矛盾すると分類することができます。例えば、次のRDFグラフは、

_:x rdf:type xsd:string .
_:x rdf:type xsd:decimal .

DがXSDデータ型を含んでいる場合、D矛盾です。矛盾したグラフへのクエリの効果は、この仕様ではカバーしていませんが、特定のSPARQLの拡張で指定しなければなりません。

結果として生じるソリューションの多重集合が、RDFグラフ同等の違は無視して、一意に決定されるような、条件を満たす任意の基本グラフ・パターンBGP、任意のRDFグラフG、および任意の評価に対し、含意レジームEは、基本グラフ・パターン評価の条件を提供しなければなりません。EをEval-E(G, BGP)とともに用いたGに対するBGPの評価に基づくソリューションの多重集合を示します。
含意レジームは、さらに次の条件を満たさなければなりません。

1. 任意のe整合のアクティブ・グラフAGの場合、含意レジームEは、AGとe等価なスコーピング・グラフSGを一意に指定します。
2. Eの整形式のグラフの集合は、Eval-E(SG、BGP)の、任意の基本グラフ・パターンBGP、スコーピング・グラフSG、およびソリューション・マッピングμに対し、グラフμ(BGP)がEの整形式であるように指定されます。
3. 任意の基本グラフ・パターンBGPとスコーピング・グラフSGの場合、Eval-E(SG, BGP)のμ₁, ..., μ_nとBGP₁, ..., BGP_nは、すべてBGPと同等である基本グラフ・パターンであるけれども、互いに、または、SGと空白ノードを共有していなければ、次のとおりです。

   SG E-entails (SG union μ₁(BGP₁) union ... union μ_n(BGP_n))

   RDFがいくらでも重複を許すため、これらの条件は、ありえる答えの集合を完全に決定するわけではありません。さらに、したがって、下記が当てはまらなければなりません。

4. 含意レジームは、レジームに応じて、自明な無限のソリューション多重集合を適切に防止する条件を提供すべきです。