SPARQL 1.2 查询语言

除非节标题中另有说明，本文档中的所有章节和附录均为规范性内容。

本文档的本节，即 第 1 节，介绍 SPARQL 查询语言规范。它说明本规范文档的组织结构，以及整个规范中使用的约定。

本规范的 第 2 节 通过一系列示例查询和查询结果介绍 SPARQL 查询语言本身。 第 3 节 通过更多示例继续介绍 SPARQL 查询语言， 这些示例展示 SPARQL 表达对出现在查询结果中的 RDF 项进行约束的能力。

第 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 节 定义四种 SPARQL 查询类型， 它们以不同形式生成结果。

第 17 节 定义 SPARQL 的可扩展值测试 和表达式框架。它展示可用于约束出现在查询结果中的值，以及计算 查询要返回的新值的函数和运算符。

第 18 节 是对 SPARQL 图模式和解修饰符求值的 形式化定义。

第 19 节 包含 SPARQL 查询和 SPARQL 1.1 更新 语言语法的 规范性定义，该定义以 EBNF 记法表示的文法给出。

下面的示例展示一个 SPARQL 查询，用于从给定数据图中查找一本书的标题。 该查询由两部分组成：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 .
}

查询的结果是一个解序列， 对应于查询的图模式匹配数据的各种方式。一个查询可以有 零个、一个或多个解。

数据：

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 项， 从而使查询模式与数据匹配。结果集给出所有可能的解。在 上述示例中，数据的以下两个子集提供了两个匹配项。

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

这是一个基本图模式匹配；查询模式中使用的所有变量 都必须在每个解中被绑定。

下面的数据包含三个 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 格式（第二 版）”和 “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 }

这两个结果包含相同信息：用于 匹配查询的空白节点在两个解中是不同的。结果集中的空白节点标识符 _: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>

SPARQL FILTER 函数，如 regex，可以 测试 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 函数与运算符定义，并基于 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 协议还提供了一个 版本声明，该声明使用 媒体类型的 version 参数。 如果没有 VERSION 指令，则会考虑这一点。

基本图模式是三元组模式的集合。SPARQL 图模式匹配是根据 组合基本图模式匹配结果来定义的。

一组三元组模式序列，加上可选过滤器，构成一个基本图 模式。任何其他图模式都会终止一个基本图模式。

在 SPARQL 查询字符串中，组图模式用花括号分隔：{}。 例如，此查询的查询模式是由一个基本图 模式组成的组图模式。

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”的解。

图模式是递归定义的。一个图模式可以有零个或多个可选 图模式，查询模式的任何部分也都可以有可选部分。在此示例中， 有两个可选图模式。

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 提供的另一种否定方式是 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 表示对 否定的两种理解方式：一种基于在已由查询模式确定的绑定 给定时测试某个模式是否存在于数据中，另一种基于两个模式的 求值来移除匹配项。在某些情况下，它们可能产生不同答案。

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 
}

反向属性路径：这两个是同一个查询；第二个只是反转 属性方向，从而交换主语和宾语的角色。

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

任意长度匹配：查找所有可从 Alice 通过 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 连接的节点（任一方向）：

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

可以使用“零次或多次”属性路径运算符 * 和“一次或多次” 属性路径运算符 +，找到主语和宾语之间通过任意长度属性路径形成的 连通性。还有一个“零次或一次”连通性属性 路径运算符 ?。

这些运算符都会使用属性路径表达式，按该运算符所限制的次数 尝试使用路径步骤在主语和宾语之间找到连接。

例如，可以用以下方式找到资源的所有可能类型，包括资源的超类型：

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
}

类似地，查找所有通过 foaf:knows 关系与 :x 相连的人，

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)

此示例展示聚合的两个特性：GROUP BY，它按照 一个或多个表达式（在此例中为 ?org）对查询解进行分组；以及 HAVING，它类似于 FILTER 表达式，但作用于 分组，而不是单个解。

该示例通过按照 GROUP BY 表达式对解分组而产生（即所有 ?org 取某一特定值的解都位于 同一分组内），并在该分组上求值集函数 SUM。随后 用 HAVING 表达式过滤分组，该表达式移除所有 SUM(?lprice) 不大于 10 的分组。

在聚合查询和子查询中，出现在查询模式中但不在 GROUP BY 子句中的变量，只有在被聚合时，才可以被投影或用于 select 表达式。 SAMPLE 聚合可用于此目的。详情见关于 投影限制的章节。

应注意，按照函数的规则，聚合 表达式必须具有别名（同样类似于 BIND 子句，使用 关键字 AS），才能从查询或子查询中投影出来。在 上面的示例中，这是使用变量 ?totalPrice 完成的。如果 聚合投影变量使用的名称已在其他聚合投影中或 WHERE 子句中使用，则是错误。

为了计算某个解的聚合值，首先将解划分为 一个或多个分组，然后为每个分组计算聚合值。

如果在查询层级中的 SELECT、HAVING 或 ORDER BY 中使用了聚合，但未使用 GROUP BY 项， 则这会被视为一个包含所有解的单一隐式分组。

在 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

HAVING 作用于已分组的解集，其方式与 FILTER 作用于未分组的解集相同。

HAVING 表达式具有与分组查询投影相同的求值规则， 如下一节所述。

下面给出一个使用 HAVING 的示例。

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

这将返回按主语分组的平均 size，但只返回平均 size 大于 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] 并不限制命名图和默认 图之间的关系。信息可以在不同图中重复；图之间的关系也可以被 暴露出来。两种有用的安排是：

• 在默认图中包含关于命名图的来源信息
• 也把命名图中的信息包含在默认图中。

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：

RDF 数据可以通过 图的 RDF 合并 [RDF12-SEMANTICS] 来组合。RDF 数据集中一种可能的图安排 是让默认图成为命名图中部分或全部信息的 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 查询可以通过使用 FROM 子句和 FROM NAMED 子句来描述 RDF 数据集，从而指定用于匹配的数据集。 如果查询提供了这样的数据集描述，则会用它替代查询服务在未提供数据集描述时 会使用的任何数据集。RDF 数据集也可以在 SPARQL 协议 请求中指定，在 这种情况下，协议描述会覆盖查询本身中的任何描述。如果数据集描述 对服务不可接受，查询服务可以拒绝查询请求。

FROM 和 FROM NAMED 关键字允许查询通过引用指定 RDF 数据集；它们表示该数据集应包含从给定 IRI（即给定 IRI 引用的绝对形式） 所标识资源的表示中获得的图。由若干 FROM 和 FROM NAMED 子句产生的数据集是：

• 一个默认图，由 FROM 子句所引用图的 RDF 合并组成；以及
• 一组（IRI，图）对，每个 FROM NAMED 子句提供一个。

如果没有 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 }
}

查询一组图时，使用 GRAPH 关键字将 模式与命名图匹配。GRAPH 可以提供一个 IRI 来选择一个图， 也可以使用一个变量，该变量会遍历查询的 RDF 数据集中所有命名图的 IRI。

使用 GRAPH 会改变查询中该部分内 图模式匹配所用的活动图。在 GRAPH 使用范围之外， 使用默认图进行匹配。

以下两个图将用于示例：

# 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，因为涉及变量 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（两个带语言标签的字面量）
• "a" 和 "1"^^xsd:integer（一个数据类型为 xsd:string 的字面量和一个带 受支持 数据类型的字面量）
• "1"^^my:integer 和 "2"^^my:integer（两个不受支持的数据类型）
• "1"^^xsd:integer 和 "2"^^my:integer（一个受支持的数据类型和一个不受支持的 数据类型）
• << :person1 foaf:name "Bob" >> 和 << :person2 foaf:name "Alice" >>（两个 三元组项）

以下变量绑定列表按升序排列：

两个解相对于某个排序比较器的升序，是通过将解绑定代入表达式， 并使用 “<”运算符比较它们来确定的。降序 是升序的反向。

两个解的相对顺序，是两个解相对于序列中第一个排序比较器的 相对顺序。对于那些解绑定的代入产生相同 RDF 项的解， 顺序是两个解相对于下一个排序比较器的相对 顺序。如果没有任何排序表达式在两个解上的求值产生 不同的 RDF 项，则两个解的相对顺序未定义。

对解序列排序总会得到一个包含相同数量 解的序列。

在 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 为零没有影响。

使用 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 后，实际解的数量大于该 限制，则最多返回该限制数量的解。

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 和 XQuery 函数与运算符 3.1 [XPATH-FUNCTIONS-31]，并具有 XML Schema 类型化 值参数和返回类型。作为参数传给这些函数和运算符的 RDF literals 会映射为 XML Schema 类型化值，其 字符串值为 lexical form，并具有与 datatype IRI 对应的 原子数据类型。返回的类型化值会以相同方式映射回 RDF literals。

SPARQL 还有一些作用于 RDF 项特定子集的附加运算符。引用 类型时，以下术语表示具有相应 W3C XML Schema 定义语言（XSD）1.1 第 2 部分： 数据类型 [XMLSCHEMA11-2] datatype IRI 的 literal：

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

以下术语标识 SPARQL 值测试中使用的附加类型：

• numeric 表示 literals， 其数据类型为 xsd:integer、xsd:decimal、xsd:float 或 xsd:double。
• RDF term 表示以下类型： IRI、 literal、 blank node，或 triple term。
• 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 和 XQuery 函数与 运算符定义的函数和运算符的一个子集。 以下规则适配 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 和 XQuery 函数与运算符 3.1 [XPATH-FUNCTIONS-31] 或 第 17.4 节中指定的 SPARQL 运算符所定义的运算符函数相关联。在为给定参数集选择运算符定义时， 具有最具体参数的定义适用。例如，在求值 xsd:integer = xsd:signedInt 时，适用的是带有两个 numeric 参数的 = 定义，而不是带有两个 RDF terms 的定义。该表经过排列，使最上方可行的 候选项最具体。没有适当操作数而调用的运算符 会导致一个错误。

SPARQL 遵循 XPath 对数值运算符参数进行数值类型提升和子类型替换的方案。 XPath 运算符映射 中用于 numeric 操作数（xsd:integer、 xsd:decimal、xsd:float、xsd:double 以及派生自 numeric 类型的类型）的规则同样适用于 SPARQL 运算符（见 XML 路径语言 （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 term 等价性来测试。

标有“(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 和 XQuery 函数与运算符 3.1 [XPATH-FUNCTIONS-31] 第 19.1 从 原始类型到原始类型的转换中定义的一部分 XPath 构造器函数。 SPARQL 构造器包括适用于 SPARQL 操作数数据类型的所有 XPath 构造器，以及 RDF 数据模型所施加的 附加数据类型。 SPARQL 中的转换通过在源类型操作数上调用目标类型的构造器函数来执行。

XPath 只定义了从一种 XML Schema 数据类型到另一种数据类型的转换。其余转换 定义如下：

• 将 IRI 转换为 xsd:string 会产生一个 字面量，其词汇值为组成该 IRI 的码位， 且数据类型为 xsd:string。

下表概述始终允许（Y）、 从不允许（N）以及依赖于词汇 值（M）的转换操作。例如，从 xsd:string（第一行）到 xsd:float（第二列）的转换操作 依赖于词汇值（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))
}

再举第二个例子，考虑一个计算两点之间距离的函数 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 代数的语法。 本节定义可以在该代数语法中形成的表达式， 然后在第 18.3 转换到代数语法中定义 SPARQL 查询字符串到该代数语法的转换。

代数查询表达式 按如下方式递归定义：

• 基本图模式 是代数查询表达式。
• 解映射的多重集 是代数查询表达式。
• 解映射的序列 是代数查询表达式。
  Issue 231：是否将解映射的序列和多重集都保留为 代数表达式？ spec:enhancement

  我们真的需要前两个点吗？
• ContextSolution 是代数查询表达式。
• 如果 ppe 是一个代数属性路径 表达式， x 是一个 RDF 项或变量，并且 y 是一个 RDF 项或变量， 则 Path(x, ppe, y) 是代数查询表达式。
• 如果 A₁ 和 A₂ 是代数查询表达式， 则 Union(A₁, A₂) 是代数查询表达式。
• 如果 A₁ 和 A₂ 是代数查询表达式， 则 Join(A₁, A₂) 是代数查询表达式。
• 如果 A₁ 和 A₂ 是代数查询表达式， 则 Minus(A₁, A₂) 是代数查询表达式。
• 如果 A₁ 和 A₂ 是代数查询表达式且 expr 是一个表达式， 则 LeftJoin(A₁, A₂, expr) 是代数查询表达式。
• 如果 expr 是一个表达式且 A 是代数查询表达式， 则 Filter(expr, A) 是代数查询表达式。
• 如果 A 是代数查询表达式， var 是变量，并且 expr 是表达式， 则 Extend(A, var, expr) 是代数查询表达式。
• 如果 x 是一个 IRI或变量，并且 A 是代数查询表达式， 则 Graph(x, A) 是代数查询表达式。
• 如果 A 是代数查询表达式， 则 ToMultiset(A) 是代数查询表达式。
• 如果 A 是代数查询表达式， 则 ToList(A) 是代数查询表达式。
• 如果 exprlist 是表达式的非空序列且 A 是代数查询表达式， 则 Group(exprlist, A) 是代数查询表达式。
• 如果 exprlist 是表达式的非空序列或星号 字符 (*)， func 是集合函数， scalarvals 是偏函数（可以是空函数，即定义域为空），并且 grp 是形式为 Group(exprlist', A) 的代数查询表达式，其中 exprlist' 是表达式的序列，并且 A 是代数查询表达式， 则 Aggregation(exprlist, func, scalarvals, grp) 是代数查询表达式。
  Issue 230：“Group” 和 “Aggregation” 不应是 代数语法的运算符 spec:bug

  Group 和 Aggregation 不应是独立运算符，而应集成到 AggregateJoin 的定义中。
• 如果 A₁, ..., A_n 是 代数查询表达式的非空序列（即 n ≥ 1）， 并且该序列中的每个表达式 A_i 都具有形式 Aggregation(exprlist_i, func_i, scalarvals_i, grp_i)， 且由前一点捕获， 则 AggregateJoin(A₁, ..., A_n) 是代数查询表达式。
• 如果 A 是代数查询表达式且 condition 是排序条件， 则 OrderBy(A, condition) 是代数查询表达式。
  Issue 229：“排序条件”的概念未定义 spec:bug

  术语“排序条件”应链接到该概念的某个定义。
• 如果 A 是代数查询表达式且 PV 是一组变量， 则 Project(A, PV) 是代数查询表达式。
• 如果 A 是代数查询表达式， 则 Distinct(A) 是代数查询表达式。
• 如果 A 是代数查询表达式， 则 Reduced(A) 是代数查询表达式。
• 如果 A 是代数查询表达式，并且 offset 和 limit 是非负整数， 则 Slice(A, offset) 和 Slice(A, offset, limit) 是代数查询表达式。

如前一定义所使用的 代数属性路径表达式概念， 按如下方式递归定义：

• 如果 iri 是一个 IRI， 则 Link(iri) 是代数属性路径表达式。
• 如果 I 是 IRI 的非空集合， 则 NPS(I) 是代数属性路径表达式。 NPS 是 negated property set 的缩写。
• 如果 ppe₁ 和 ppe₂ 是代数属性路径表达式， 则 Seq(ppe₁, ppe₂) 是代数属性路径表达式。
• 如果 ppe₁ 和 ppe₂ 是代数属性路径表达式， 则 Alt(ppe₁, ppe₂) 是代数属性路径表达式。
• 如果 ppe 是代数属性路径表达式， 则 Inv(ppe) 是代数属性路径表达式。
• 如果 ppe 是代数属性路径表达式， 则 ZeroOrOnePath(ppe) 是代数属性路径表达式。
• 如果 ppe 是代数属性路径表达式， 则 ZeroOrMorePath(ppe) 是代数属性路径表达式。
• 如果 ppe 是代数属性路径表达式， 则 OneOrMorePath(ppe) 是代数属性路径表达式。

本节定义将 SPARQL 查询字符串中的图模式和解修饰符转换为 代数 查询表达式的过程。所描述的过程转换一个 查询嵌套层级，该层级由使用嵌套 SELECT 语法的子查询形成， 并递归应用于子查询。每个层级由图模式匹配和 过滤组成，随后应用解修饰符。

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