Copyright © 2026 World Wide Web Consortium. W3C® liability, trademark and permissive document license rules apply.
本文档定义了 SHACL 形状约束语言中与 SPARQL 相关的特性。 SHACL 的核心部分定义了形状的基本语法以及 SHACL 支持的最常见约束组件,而与 SPARQL 相关的特性则通过 SPARQL 扩展了核心部分的表达能力。 具体而言,本文档定义了如何使用 SPARQL 定义约束和约束组件。 此外,本文档还引入了基于 SPARQL 的节点表达式,可用于派生 节点列表。 最后,本文档定义了一种声明式机制,用于基于 SHACL 节点 表达式定义新的 SPARQL 函数。
本节描述了本文档在发布时的状态。当前 W3C 出版物以及本技术报告最新修订版的列表可在 W3C 标准和草案 索引中找到。
本文档由 数据形状工作组 作为工作草案发布,并使用 推荐标准 轨道。
作为 工作草案发布并不意味着 W3C 及其成员认可该文档。
这是一个草案文档,可能随时被其他文档更新、替换或废弃。 除作为进行中的工作外,不应将本文档作为其他形式引用。
本文档由一个在 W3C 专利 政策下运行的工作组制作。 W3C 维护着一份 与该工作组交付物相关的任何专利 披露的公开列表; 该页面还包括 披露专利的说明。任何实际知悉某项专利,并认为该专利包含 必要权利要求的个人, 必须根据 W3C 专利政策第 6 节披露相关信息。
本文档受 2025 年 8 月 18 日 W3C 流程文档约束。
本规范是 SHACL 1.2 规范系列的一部分。有关这些规范的更详细 介绍,请参阅 SHACL 1.2 概述。
这些规范如下:
工作草案:
编辑草案:
实现者可以通过运行上述规范各自提供的测试用例,部分检查其实现 自身的符合程度。 这些测试用例的链接可在相应规范的元数据中找到。 但请注意,通过测试套件中的所有测试并不意味着完全符合 规范, 而仅意味着该实现符合测试套件所测试的方面。
本文档规定了形状约束语言(SHACL)中与 SPARQL 相关的功能。
本文档通篇使用以下术语。
本文档中定义的 SHACL SPARQL 相关特性有时称为 SHACL-SPARQL。
链接到 RDF 1.2 Concepts and Abstract Syntax 各部分的术语在 SHACL-SPARQL 中按照其中的定义使用。 链接到 SPARQL 1.2 Query Language 各部分的术语在 SHACL-SPARQL 中按照其中的定义 使用。 链接到 SHACL 1.2 Core 各部分的术语在 SHACL-SPARQL 中按照其中的定义使用。 对于本文档中某个特定术语的所有出现位置,只需一个链接即可为其提供 定义。
本文档中的定义是完备的,也就是说,如果本文档中没有规则使某种情况为真, 则该情况为假。
SHACL 的语法是 RDF。 本文档中的示例使用 Turtle [rdf12-turtle]。 实践中可以使用其他 RDF 序列化,例如 RDF/XML。 读者应熟悉基本 RDF 概念 [rdf12-concepts],例如三元组, 并熟悉 SPARQL [sparql12-query]。
本文档中使用以下命名空间前缀绑定:
| 前缀 | 命名空间 |
|---|---|
owl: |
http://www.w3.org/2002/07/owl# |
rdf: |
http://www.w3.org/1999/02/22-rdf-syntax-ns# |
rdfs: |
http://www.w3.org/2000/01/rdf-schema# |
sh: |
http://www.w3.org/ns/shacl# |
xsd: |
http://www.w3.org/2001/XMLSchema# |
ex: |
http://example.com/ns# |
shnex: |
http://www.w3.org/ns/shacl-node-expr# |
sparql: |
http://www.w3.org/ns/sparql# |
本文档中使用以下 JSON-LD 上下文:
{
"@context": {
"owl": "http://www.w3.org/2002/07/owl#",
"rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
"rdfs": "http://www.w3.org/2000/01/rdf-schema#",
"sh": "http://www.w3.org/ns/shacl#",
"xsd": "http://www.w3.org/2001/XMLSchema#",
"ex": "http://example.com/ns#",
"shnex": "http://www.w3.org/ns/shacl-node-expr#",
"sparql": "http://www.w3.org/ns/sparql#"
}
}
请注意,定义 SHACL 词汇表本身的图的 URI 等同于
上述命名空间,即它包含 #。
对 SHACL 词汇表的引用,例如通过 owl:imports 进行引用时,应包含 #。
在整篇文档中,会出现包含 Turtle 中 RDF 图的彩色编码框。 这些 Turtle 文档片段使用上面给出的前缀绑定。
SHACL 定义显示在蓝色框中:
# 此框包含 SPARQL 或文本定义。
这样的灰色框包括适用于 形状图的语法规则。
使用 $ 标记的 SPARQL 变量表示外部绑定,这些绑定会被预绑定,或者对于 $PATH,会在 SPARQL
查询执行前被替换(如
3.3 使用
基于 SPARQL 的约束进行验证中所述)。
true 表示 RDF 术语 "true"^^xsd:boolean。
false 表示 RDF 术语 "false"^^xsd:boolean。
除标记为非规范性的章节外,本规范中的所有编写指南、图表、示例和注释也均为非规范性内容。 本规范中的其他所有内容均为规范性内容。
本文档中的关键词 可以、必须、不得 、可选和应该 仅当它们如本文所示以全大写形式出现时,才应按照 BCP 14 [RFC2119] [RFC8174] 中的规定 进行解释。
本文档定义了扩展 SHACL Core 的 SHACL-SPARQL 语言。 本规范描述了以下处理器的符合性标准:
SPARQLValidation)。
此类处理器还可以支持5. 注解
属性;
支持该功能的处理器必须遵循该章节的规则。
SPARQLNodeExpr)
SPARQLCustomFunctions)
另请参阅 SHACL Core 的符合性章节中关于良构性的讨论。
SHACL 1.2 推理规则规范 [shacl12-inference-rules] 定义了 SHACL 的其他 基于 SPARQL 的特性。
本节介绍本文档中用于为 SPARQL 查询声明命名空间前缀的机制。
形状图可以 包含命名空间前缀的声明,以便使用这些前缀缩写从同一形状图派生的 SPARQL 查询。 以下示例说明了此类前缀声明的语法。
同时具有 sh:prefix 和 sh:namespace
值的
IRI 或空白节点
称为前缀声明。
SHACL 词汇表包含类 sh:PrefixDeclaration,可用作此类前缀声明的类型,
但这些声明并不要求具有 rdf:type 三元组。
前缀
声明的属性 sh:prefix 恰好有一个值。
sh:prefix 的值是数据类型为
xsd:string 的字面量。
前缀
声明的属性 sh:namespace 恰好有一个值。
sh:namespace 的值是数据类型为
xsd:anyURI 或 xsd:string 的字面量。
这样的一对值指定从一个前缀到一个命名空间的单一映射。
属性
sh:declare 的值是前缀声明。
建议将包含使用这些前缀的形状的具名图 IRI 用作 sh:declare 值的主语。
这些 IRI 通常被声明为 sh:ShapesGraph 或 owl:Ontology 的实例,
但这不是必需的。
除其他用途外,前缀声明还可供基于 SPARQL 的约束、
基于 SPARQL 的约束组件的验证器、
基于 SPARQL 的节点表达式以及
基于 SPARQL 的推理规则使用。
这些节点可以使用属性 sh:prefixes 指定一组前缀映射。
关于 sh:prefixes 属性的用法,可以参阅此
示例。
sh:prefixes 的值必须是 IRI 或空白节点。
SHACL 处理器通过合并所有作为以下 SPARQL 属性路径的值的
各个前缀映射,收集一组前缀映射:
sh:prefixes/(^owl:versionIRI)?/(owl:imports/(^owl:versionIRI)?)*/sh:declare。
该路径从基于 SPARQL 的约束、验证器或基于
SPARQL 的节点表达式出发。
(^owl:versionIRI)? 元素支持通过图的
owl:versionIRI
引用的图,
无论是直接作为 sh:prefixes 的值,还是通过 owl:imports 引用:
在收集前缀声明并进一步沿 owl:imports 遍历之前,
它们会从版本 IRI 导航到形状图 IRI。
如果这样收集的
前缀声明包含对应同一 sh:prefix 值的多个不同命名空间,
则该形状
图是非良构的。
(请注意,SHACL 处理器可以忽略从未遍历到的前缀声明)。
如果基于 SPARQL 的约束、验证器或基于
SPARQL 的节点表达式
没有 sh:prefixes 的值,
则 SHACL 处理器使用形状
图中的前缀声明,
即在 owl:Ontology、sh:DataGraph、sh:ShapesGraph
或 sh:RulesGraph(它是 sh:ShapesGraph 的子类)的
SHACL 实例处,
作为 sh:declare 的值的那些前缀声明。
SHACL 处理器通过在 sh:select(以及
sh:ask 和 sh:construct 等类似属性)的值前添加
所有前缀映射对应的 PREFIX 声明,
将这些值转换为 SPARQL。
每个 sh:prefix 的值都转换为 PNAME_NS,而每个
sh:namespace 的值则转换
为 PREFIX 声明中的 IRIREF。
对于上面的示例形状图,SHACL-SPARQL 处理器会生成如下行:
PREFIX ex: <http://example.com/ns#>。
如果生成的查询字符串无法解析为有效的 SPARQL 1.2 查询,SHACL-SPARQL 处理器必须产生失败。
为简洁起见,本文档其余部分可能省略了 sh:prefixes 语句。
SHACL-SPARQL 支持一种约束组件, 可用于表达基于 SPARQL SELECT 查询的限制。
约束组件 IRI:sh:SPARQLConstraintComponent
| 属性 | 摘要 |
|---|---|
sh:sparql |
声明要进行求值的 SPARQL 查询的基于 SPARQL 的约束。 |
本节的其余部分定义了基于 SPARQL 的约束的语法规则和验证过程。
本节不具有规范性。
以下示例说明了基于 SPARQL 的约束的语法。
{
"@graph": [
{
"@id": "ex:LanguageExampleShape",
"@type": "sh:NodeShape",
"sh:sparql": {
"@type": "sh:SPARQLConstraint",
"sh:message": "Values are literals with German language tag.",
"sh:prefixes": {
"@id": "http://example.com/ns#"
},
"sh:select": "\n\t\t\tSELECT $this (ex:germanLabel AS ?path) ?value\n\t\t\tWHERE {\n\t\t\t\t$this ex:germanLabel ?value .\n\t\t\t\tFILTER (!isLiteral(?value) || !langMatches(lang(?value), \"de\"))\n\t\t\t}\n\t\t\t"
},
"sh:targetClass": {
"@id": "ex:Country"
}
},
{
"@id": "http://example.com/ns#",
"sh:declare": {
"@id": "_:b1"
}
}
]
}
上述形状的目标包含 ex:Country 的所有SHACL 实例。
对于这些节点(由变量 this 表示),SPARQL 查询会遍历
ex:germanLabel 的值,
并验证这些值是否为带有德语语言代码的字面量。
{
"@graph": [
{
"@id": "ex:InvalidCountry",
"@type": "ex:Country",
"ex:germanLabel": {
"@language": "en",
"@value": "Spain"
}
},
{
"@id": "ex:ValidCountry",
"@type": "ex:Country",
"ex:germanLabel": {
"@language": "de",
"@value": "Spanien"
}
}
]
}
{
"@type": "sh:ValidationReport",
"sh:conforms": {
"@type": "xsd:boolean",
"@value": "false"
},
"sh:result": {
"@type": "sh:ValidationResult",
"sh:focusNode": {
"@id": "ex:InvalidCountry"
},
"sh:resultPath": {
"@id": "ex:germanLabel"
},
"sh:resultSeverity": {
"@id": "sh:Violation"
},
"sh:sourceConstraintComponent": {
"@id": "sh:SPARQLConstraintComponent"
},
"sh:sourceShape": {
"@id": "ex:LanguageExampleShape"
},
"sh:value": {
"@language": "en",
"@value": "Spain"
}
}
}
SPARQL 查询为所有违反约束的变量 value 绑定返回结果集解。
该结果集中的每个解都会产生一个验证结果,
并应用稍后说明的映射规则。
在此示例中,每个验证结果都会将变量
this 的绑定作为 sh:focusNode,
将 ex:germanLabel 作为 sh:resultPath,并将违反约束的值作为
sh:value。
以下示例说明了与上述类似的场景,但使用的是属性形状。
{
"@graph": [
{
"@id": "ex:LanguageExamplePropertyShape",
"@type": "sh:PropertyShape",
"sh:path": {
"@id": "ex:germanLabel"
},
"sh:sparql": {
"@type": "sh:SPARQLConstraint",
"sh:message": "Values are literals with German language tag.",
"sh:prefixes": {
"@id": "http://example.com/ns#"
},
"sh:select": "\n\t\t\tSELECT $this ?value\n\t\t\tWHERE {\n\t\t\t\t$this $PATH ?value .\n\t\t\t\tFILTER (!isLiteral(?value) || !langMatches(lang(?value), \"de\"))\n\t\t\t}\n\t\t\t"
},
"sh:targetClass": {
"@id": "ex:Country"
}
},
{
"@id": "http://example.com/ns#",
"sh:declare": {
"@id": "_:b1"
}
}
]
}
形状可以具有属性
sh:sparql 的值,并且这些值是 IRI 或空白节点。
这些值称为基于 SPARQL 的约束。
基于 SPARQL 的约束的属性
sh:select 恰好有一个值。
sh:select 的值是数据类型为
xsd:string 的字面量。
类 sh:SPARQLConstraint 在 SHACL 词汇表中定义,可用作这些约束的类型
(尽管并不要求具有类型)。
按照前缀处理规则,sh:select 的值是有效的
SPARQL 1.2 SELECT 查询。
从
sh:select 值派生的 SPARQL 查询在 SELECT 子句中投影变量
this。
以下两个属性的用法与它们在形状中的用法类似:
基于 SPARQL 的
约束可以具有属性 sh:message 的值,
这些值是字面量,其数据类型为
xsd:string、rdf:dirLangString、rdf:langString 或
rdf:HTML。
sh:message 不应具有多个使用相同语言标签的值,
也不应具有多个数据类型为 xsd:string 的值。
基于 SPARQL 的
约束最多可以具有一个属性 sh:deactivated 的值,
该值是一个节点表达式,其(唯一的)输出节点必须是
true 或 false,
与形状的情况相同。
基于 SPARQL 的约束最多可以具有一个
属性 sh:severity 的值,
且该值必须是一个 IRI。
在属性形状的上下文中使用的
SELECT 查询,
使用名为 PATH 的特殊变量作为该形状所用路径的占位符。
在基于 SPARQL 的约束
和基于 SELECT 的验证器的 SPARQL 查询中,
变量 PATH 唯一合法的用法是出现在谓词
位置,即三元组模式的谓词位置。
在任何其他位置使用变量 PATH 的查询都是非良构的。
本节介绍 sh:SPARQLConstraintComponent 的验证器。
请注意,此验证器仅说明一种可能的实现策略,
SHACL 处理器可以选择其他方法,只要结果等效即可。
$sparql 为 sh:sparql 的一个值。
如果 $sparql 的属性 sh:deactivated 具有一个值 expr,并且
evalExpr(expr, 数据图, 焦点节点, {})
产生 true 作为其唯一的输出节点,
则该约束被停用,且不会产生验证结果。
否则,执行基于 SPARQL 的约束 $sparql 指定的 SPARQL
查询,
并按照3.3.1 SPARQL 约束中
预绑定的变量 $this中所述,对变量 this 进行预绑定。
如果该形状是
属性
形状,则在执行之前,
将出现在谓词
位置的变量 PATH 替换为该三元组模式中
由属性形状通过
sh:path 指定的
SHACL
属性路径的有效 SPARQL 表层语法字符串。
对于变量 failure 的绑定不为
true 的每个解,
都会产生一个验证结果。
这些验证结果必须具有3.3.2 将解的
绑定映射到结果属性中所述的属性值。
如果 $sparql 具有 sh:severity 的值,
则该验证结果必须
将该值作为其唯一的 sh:resultSeverity 值。
当且仅当某个解中
failure 的绑定为 true 时,才必须产生失败。
当处理基于 SPARQL 的约束的 SPARQL 查询
以及基于 SPARQL 的约束组件的验证器时,
SHACL-SPARQL 处理器会将变量 $this 的值预绑定到当前焦点节点。
验证结果节点的属性值 通过以下规则,结合结果解和约束本身的值派生。 这些规则应自上而下执行,以便使用第一个已绑定的值。
| 属性 | 生成规则 |
|---|---|
sh:focusNode |
|
sh:resultPath |
|
sh:value |
|
sh:resultMessage |
这些消息字面量可以通过
{?varName} 或
{$varName} 包含任何 SELECT 结果变量的名称。
如果约束基于基于 SPARQL 的
约束组件,则也可以使用该组件的参数名称。
这些 {?varName} 和 {$varName} 块应当替换为所述变量值的适当字符串表示形式。
|
sh:sourceConstraint |
|
变量 failure 是保留变量,不会映射到结果属性:
如上文所定义,如果一个解将
true
作为 failure 的绑定值,则会产生失败,而不是
验证结果。
基于 SPARQL 的约束提供了很大的灵活性, 但对于某些人来说可能难以理解,或者会导致重复。 本节引入基于 SPARQL 的约束 组件,以此抽象 SPARQL 的复杂性, 并声明类似于核心约束组件的高级可重用组件。 此类约束组件可以使用 SHACL RDF 词汇表声明,因而可以共享和重用。
本节不具有规范性。
以下示例演示了如何使用 SPARQL,通过 SHACL-SPARQL 语言指定新的约束组件。
该示例使用
sh:pattern 和
sh:flags,并通过
SPARQL ASK 查询验证每个值节点是否与给定的正则
表达式匹配。
请注意,这只是一个示例实现,不应被视为规范性内容。
{
"@graph": [
{
"@id": "ex:hasPattern",
"@type": "sh:SPARQLAskValidator",
"sh:ask": "\n\t\tASK {\n\t\t\tFILTER (!isBlank($value) &&\n\t\t\t\tIF(bound($flags), regex(str($value), $pattern, $flags), regex(str($value), $pattern)))\n\t\t}",
"sh:message": "值与模式 {$pattern} 不匹配"
},
{
"@id": "sh:PatternConstraintComponent",
"@type": "sh:ConstraintComponent",
"sh:parameter": [
{
"sh:path": {
"@id": "sh:pattern"
}
},
{
"sh:optional": {
"@type": "xsd:boolean",
"@value": "true"
},
"sh:path": {
"@id": "sh:flags"
}
}
],
"sh:validator": {
"@id": "ex:hasPattern"
}
}
]
}
声明约束组件后,即可在形状中使用其参数,如以下示例所示。
{
"@id": "ex:CaseInsensitiveSearch",
"@type": "sh:NodeShape",
"sh:property": {
"sh:flags": "i",
"sh:path": {
"@id": "ex:code"
},
"sh:pattern": "^[A-Z]{3}[0-9]{2}$"
}
}
约束组件为验证引擎提供有关如何识别和验证约束
的指令,这些约束位于形状中。
通常,如果一个形状
S 具有属性 p 的一个值,并且
存在一个将 p 指定为参数的约束组件
C,而且 S 具有 C 的所有必需
参数的值,
则这些参数值的集合(包括可选参数)声明了一个
约束,并且
验证引擎使用来自 C 的合适验证器
对该约束执行验证。
在上面的示例中,sh:PatternConstraintComponent 声明了必需参数
sh:pattern、
可选参数 sh:flags,
以及一个可用于针对节点形状或属性形状执行验证的验证器。
基于 SPARQL 的约束组件
是一个在形状图中具有
SHACL 类型
sh:ConstraintComponent 的 IRI。
本文档中声明新约束组件的机制 仅限于基于 SPARQL 的约束组件。 但是,声明参数和验证器的通用语法也被设计为可用于 JavaScript 等 其他扩展语言。
约束
组件的参数
通过属性 sh:parameter 声明。
sh:parameter 的值称为参数声明。
类 sh:Parameter 可以用作参数声明的类型,但并不要求具有
此类三元组。
每个
参数声明的属性
sh:path 恰好有一个值。
在参数声明中,
sh:path 的值是一个IRI。
IRI 的局部名称定义为该 IRI 末尾最长的
NCNAME,
并且其前面不能紧邻该 IRI
中的第一个冒号。
参数声明的参数名称定义为
sh:path 值的局部名称。
为确保可以将参数正确映射到 SPARQL 变量,适用以下语法规则:
每个参数名称都是有效的 SPARQL VARNAME。
参数名称不得为以下任何一个:
this、path、PATH、value、
message、failure。
如果一个约束
组件中的两个或多个参数声明使用
相同的参数名称,则该约束组件是非良构的。
sh:optional 的值必须是数据类型为 xsd:boolean 的字面量。
一个参数声明的属性
sh:optional 最多可以有一个值。
如果设置为 true,则该参数声明声明了一个可选参数。
每个约束组件
至少有一个非可选参数。
类 sh:Parameter 被定义为 sh:PropertyShape 的一个SHACL 子类,
所有适用于属性形状的属性也可以用于参数。
这包括 sh:name 和 sh:description 等描述性属性,
也包括 sh:class 等约束参数。
不符合
为参数声明的约束的形状是非良构的。
某些实现可以使用这些约束参数,防止执行参数值无效的约束组件。
属性 sh:labelTemplate 可用于任何约束组件,以
建议如何向用户呈现约束。
sh:labelTemplate 的值是字面量,其数据类型为
xsd:string、rdf:langString 或 rdf:dirLangString,
并且
称为标签模板。
本节的其余部分不具有规范性。
标签模板可以使用
{?varName} 或 {$varName} 语法,
包含为约束组件声明的参数名称,
其中 varName 是参数名称。
显示时,这些 {?varName} 和 {$varName} 块应替换为
实际的参数值。
同一主语可以有多个标签模板,但它们不应具有相同的语言标签,
并且数据类型为 xsd:string 的模板不应超过一个。
对于每种受支持的形状类型(即属性形状或节点形状), 约束组件都会声明一个合适的验证器。 对于给定约束,按照以下规则依次从约束组件中选择一个验证器:
sh:nodeValidator 的其中一个值。sh:propertyValidator 的其中一个值。
sh:validator 的其中一个值。
如果找不到合适的验证器,SHACL-SPARQL 处理器将忽略该约束。
SHACL-SPARQL 包含两种类型的验证器:一种基于 SPARQL
SELECT 查询(用于 sh:nodeValidator 和 sh:propertyValidator),
另一种基于 SPARQL ASK 查询(用于 sh:validator)。
验证器
中,SHACL
类型为 sh:SPARQLSelectValidator 的称为基于 SELECT 的验证器。
sh:nodeValidator 的值必须是基于
SELECT 的验证器。
sh:propertyValidator 的值必须是基于
SELECT 的验证器。
基于
SELECT 的验证器必须恰好具有一个
属性 sh:select 的值。
sh:select 的值
是数据类型为 xsd:string 的字面量。
按照前缀处理规则,sh:select 的值
是有效的 SPARQL 1.2 SELECT 查询。
从
sh:select 的值派生的 SPARQL 查询在其 SELECT 子句中投影变量
this。
本节的其余部分不具有规范性。
以下示例说明了如何声明基于 SPARQL
SELECT 查询的约束组件。
它是 3.1 基于 SPARQL
的约束示例中示例的泛化变体。
该 SPARQL 查询包含两个常量:特定属性
ex:germanLabel 和语言标签 de,
而本示例对约束进行了泛化,使任何属性都可以使用语言标签来定义。
实际上,约束组件通过
向形状添加参数谓词来应用(例如 ex:lang "de"),SHACL-SPARQL
处理器会在执行 SELECT 验证器之前,将其预绑定到相应的 SPARQL
变量(例如 $lang)。
约束组件使这类场景能够被泛化,从而使常量通过预绑定与参数绑定。
这样便可在多个位置复用查询逻辑,而无需编写任何新的
SPARQL。
{
"@id": "ex:LanguageConstraintComponentUsingSELECT",
"@type": "sh:ConstraintComponent",
"rdfs:label": "语言约束组件",
"sh:labelTemplate": "值是语言为 \"{$lang}\" 的字面量",
"sh:parameter": {
"sh:datatype": {
"@id": "xsd:string"
},
"sh:description": "语言标签,例如 \"de\"。",
"sh:minLength": {
"@type": "xsd:integer",
"@value": "2"
},
"sh:name": "语言",
"sh:path": {
"@id": "ex:lang"
}
},
"sh:propertyValidator": {
"@type": "sh:SPARQLSelectValidator",
"sh:message": "值是语言为 \"{?lang}\" 的字面量",
"sh:select": "\n\t\t\tSELECT DISTINCT $this ?value\n\t\t\tWHERE {\n\t\t\t\t$this $PATH ?value .\n\t\t\t\tFILTER (!isLiteral(?value) || !langMatches(lang(?value), $lang))\n\t\t\t}\n\t\t\t"
}
}
声明约束组件后(在形状图中),即可
按以下示例所示使用其参数。任何包含 ex:lang 的属性形状
都会被解释为使用
ex:LanguageConstraintComponentUsingSELECT(将 $lang 绑定到该
值)。
{
"@id": "ex:LanguageExampleShape",
"@type": "sh:NodeShape",
"sh:property": [
{
"ex:lang": "de",
"sh:path": {
"@id": "ex:germanLabel"
}
},
{
"ex:lang": "en",
"sh:path": {
"@id": "ex:englishLabel"
}
}
],
"sh:targetClass": {
"@id": "ex:Country"
}
}
上述示例形状规定,ex:germanLabel 的所有值
都带有语言标签 de,
而 ex:englishLabel 的所有值都以 en 作为其语言。
这些细节通过两个属性形状指定,这两个属性形状具有
约束组件所要求的 ex:lang 参数值。
许多约束组件采用这样一种形式:针对某个布尔条件,逐个测试所有值节点。 为此编写 SELECT 查询会变得很繁琐,尤其是在一个约束组件既可用于属性形状, 又可用于节点 形状的情况下。 SHACL-SPARQL 为基于 ASK 查询的验证器提供了一种更紧凑的替代语法。
具有 SHACL
类型
sh:SPARQLAskValidator 的验证器称为基于 ASK
的验证器。
sh:validator 的值必须是基于 ASK 的验证器。
基于 ASK 的验证器的属性
sh:ask 恰好有一个值。
sh:ask 的值必须是数据类型为 xsd:string 的字面量。
sh:ask 的值必须是使用上述前缀
处理规则的有效 SPARQL ASK 查询。
本节的其余部分不具有规范性。
当且仅当给定值节点
(由预绑定变量 value 表示)符合约束时,ASK 查询才返回 true。
以下示例使用 ASK 查询声明了一个约束组件。
{
"@graph": [
{
"@id": "ex:hasLang",
"@type": "sh:SPARQLAskValidator",
"sh:ask": "\n\t\tASK {\n\t\t\tFILTER (isLiteral($value) && langMatches(lang($value), $lang))\n\t\t}\n\t\t",
"sh:message": "Values are literals with language \"{$lang}\""
},
{
"@id": "ex:LanguageConstraintComponentUsingASK",
"@type": "sh:ConstraintComponent",
"rdfs:label": "Language constraint component",
"sh:labelTemplate": "Values are literals with language \"{$lang}\"",
"sh:parameter": {
"sh:datatype": {
"@id": "xsd:string"
},
"sh:description": "The language tag, e.g. \"de\".",
"sh:minLength": {
"@type": "xsd:integer",
"@value": "2"
},
"sh:name": "language",
"sh:path": {
"@id": "ex:lang"
}
},
"sh:validator": {
"@id": "ex:hasLang"
}
}
]
}
请注意,ASK 查询实现的验证条件与其 SELECT 对应项的方向“相反”:
ASK 查询针对符合约束的值节点返回 true,而
SELECT 查询返回那些不符合约束的值节点。
本节定义基于 SPARQL 的约束组件的验证器。 请注意,此验证器仅说明一种可能的实现策略, SHACL 处理器可以选择其他方法,只要结果等效即可。
第一步,必须按照 4.2.3 验证器中概述的规则选择一个验证器。 然后应用以下规则,生成一组 SPARQL 查询的解:
v,如果将 v 预绑定到变量 value 后,
SPARQL ASK 查询返回 false,
则创建一个由绑定 ($this, 焦点节点) 和
($value, v) 组成的解。
设 QS 为这些解的列表。
PATH 替换为
三元组模式中
由该属性形状通过
sh:path 指定的SHACL 属性路径
的有效 SPARQL 表层语法字符串。
设 QS 为执行 SPARQL 查询产生的解。
上述 SPARQL 查询执行必须按照预绑定规则处理变量
this,如3.3.1
SPARQL 约束中预绑定的变量 $this中所述。
此外,在约束中,
约束组件的
每个参数的值
必须被预绑定到一个以相应参数名称命名的变量。
验证结果的生成规则
与基于 SPARQL 的约束的生成规则相同,
使用上文生成的解 QS。
本节扩展了使用基于 SPARQL 的约束或 约束组件生成验证结果的通用机制。
对 SHACL-SPARQL 验证处理器而言,支持此功能是可选的,参见1.3 符合性。
支持此功能的处理器允许将注解属性
注入到基于 SPARQL 的约束或约束组件的
SELECT 查询所产生的每个解对应的验证
结果节点中。
任何此类注解属性都需要通过 sh:select 或 sh:ask 三元组的主语上的
sh:resultAnnotation 值进行声明。
sh:resultAnnotation 的值
称为结果注解,可以是IRI 或空白
节点。
结果注解具有以下属性:
| 属性 | 摘要和语法规则 |
|---|---|
sh:annotationProperty |
要设置的属性。
每个结果注解都恰好具有一个属性
sh:annotationProperty 的值,
且该值是一个IRI。
|
sh:annotationVarName |
用于获取注解值的 SPARQL 变量名称。
每个结果注解最多具有一个属性
sh:annotationVarName 的值,
且该值是
字面量,
其数据类型为
xsd:string。
|
sh:annotationValue |
用作默认值的常量 RDF 术语。 |
对于 SELECT 结果集中的每个解,支持注解的 SHACL 处理器
会遍历已声明的结果注解。
从结果注解到 SPARQL 变量的映射遵循以下规则:
如果能够确定变量名称,则 SHACL 处理器会将该变量的绑定
作为通过 sh:annotationProperty 指定的属性的值,
复制到为当前解生成的验证
结果中。
如果该变量在结果集的解中没有绑定,
则使用 sh:annotationValue 的值(如果存在)。
{
"@id": "ex:AnnotationExample",
"@type": "sh:NodeShape",
"sh:sparql": {
"sh:resultAnnotation": {
"sh:annotationProperty": {
"@id": "ex:time"
},
"sh:annotationVarName": "time"
},
"sh:select": "\n\t\t\tSELECT $this ?message ?time\n\t\t\tWHERE {\n\t\t\t\tBIND (CONCAT(\"The \", \"message.\") AS ?message) .\n\t\t\t\tBIND (NOW() AS ?time) .\n\t\t\t}\n\t\t\t"
},
"sh:targetNode": {
"@id": "ex:ExampleResource"
}
}
{
"@type": "sh:ValidationReport",
"sh:conforms": {
"@type": "xsd:boolean",
"@value": "false"
},
"sh:result": {
"@type": "sh:ValidationResult",
"ex:time": {
"@type": "xsd:dateTime",
"@value": "2015-03-27T10:58:00"
},
"sh:focusNode": {
"@id": "ex:ExampleResource"
},
"sh:resultMessage": "The message.",
"sh:resultSeverity": {
"@id": "sh:Violation"
},
"sh:sourceConstraint": {
"@id": "_:b1"
},
"sh:sourceConstraintComponent": {
"@id": "sh:SPARQLConstraintComponent"
},
"sh:sourceShape": {
"@id": "ex:AnnotationExample"
}
}
}
本节介绍基于 SPARQL 的节点表达式函数。
本节中的节点表达式函数嵌入完整的 SPARQL 查询或 SPARQL 表达式。
对于 sparql:concat 等无需 SPARQL 查询即可求值的单个 SPARQL 函数,
其对应的节点表达式函数定义于
SHACL 1.2 节点表达式中。
具有关键参数
值的关键参数
sh:select 的节点
表达式称为选择表达式,其函数名称为
sh:SelectExpression。
如果 RDF 图中的
一个节点是空白节点,
且恰好具有一个谓词 sh:select 的值,
并且该值是一个
字面量,
其数据类型为
xsd:string,则该节点是一个良构的选择表达式。
一个良构的选择表达式最多可以具有一个
属性 sh:prefixes 的值,
且该值只能是一个IRI 或一个空白节点。
按照前缀处理
规则,sh:select 的值是有效的 SPARQL 1.2 SELECT 查询。
从
sh:select 的值派生的 SPARQL 查询在 SELECT 子句中恰好投影
一个变量。
选择表达式的输出
节点是列表 resultNodes,
该列表恰好由查询针对焦点
图求值时,从 SELECT 子句投影的唯一变量的绑定组成。
focusNode 的值被预绑定为 SPARQL
变量 this 的值。
每个作用域变量的值都被预绑定到具有相同名称和值的 SPARQL 变量。
如果作用域中变量的名称不是字符串字面量,则使用 "arg" + str(name)。
例如,如果变量名称为 "0"^^xsd:integer,则使用 arg0。
如果某个作用域变量名为 this,
或者以这种方式派生的变量名称不是有效的
SPARQL VARNAME,则产生失败。
evalExpr(expr, focusGraph, focusNode, scope) -> resultNodes
本节其余部分均为非规范性内容。
以下示例展示了选择表达式的用法,
通过连接 ex:firstName、一个空格以及
ex:lastName,计算名为“全名”的属性
所对应的属性形状的值。
{
"@graph": [
{
"@id": "ex:Person-fullName",
"@type": "sh:PropertyShape",
"sh:datatype": {
"@id": "xsd:string"
},
"sh:name": "full name",
"sh:path": {
"@id": "ex:fullName"
},
"sh:values": {
"sh:prefixes": {
"@id": "http://example.com/ns#"
},
"sh:select": "\n\t\t\tSELECT ?fullName\n\t\t\tWHERE {\n\t\t\t\t$this ex:firstName ?firstName .\n\t\t\t\t$this ex:lastName ?lastName .\n\t\t\t\tBIND (CONCAT(?firstName, \" \", ?lastName) AS ?fullName) .\n\t\t\t}\n\t\t"
}
},
{
"@id": "http://example.com/ns#",
"@type": "owl:Ontology",
"sh:declare": {
"sh:namespace": {
"@type": "xsd:anyURI",
"@value": "http://example.com/ns#"
},
"sh:prefix": "ex"
}
}
]
}
此示例还说明了如何使用 sh:prefixes 在解析之前将 PREFIX 声明插入
查询的开头。
请注意,执行查询时会将当前焦点节点预绑定到变量
this。
以下示例展示了选择表达式的用法,
计算一个形状的目标节点,使其包含所有
ex:age 小于 18 的 ex:Person 实例。
{
"@id": "ex:ChildShape",
"@type": "sh:NodeShape",
"rdfs:comment": "This shape applies to all persons under 18 years of age.",
"rdfs:label": "Child shape",
"sh:targetNode": {
"sh:select": "\n\t\t\tPREFIX ex: <http://example.com/ns#>\n\t\t\tSELECT ?person\n\t\t\tWHERE {\n\t\t\t\t?person a/rdfs:subClassOf* ex:Person .\n\t\t\t\t?person ex:age ?age .\n\t\t\t\tFILTER (?age < 18) .\n\t\t\t}\n\t\t"
}
}
在以下数据图中,只有 ex:Benjamin 是目标节点。
{
"@graph": [
{
"@id": "ex:Benjamin",
"@type": "ex:Person",
"ex:age": {
"@type": "xsd:integer",
"@value": "17"
}
},
{
"@id": "ex:Bernd",
"@type": "ex:Person"
},
{
"@id": "ex:Klaus",
"@type": "ex:Person",
"ex:age": {
"@type": "xsd:integer",
"@value": "48"
}
}
]
}
具有关键参数
sh:sparqlExpr 的值的节点
表达式称为SPARQL expr 表达式,其函数名称为
sh:SPARQLExprExpression。
如果 RDF 图中的一个节点是一个空白节点,
且对于谓语
sh:sparqlExpr 恰好有一个值,并且该值是一个
字面量,
其数据类型
为 xsd:string,则该节点是一个良构的SPARQL expr 表达式。
一个良构的SPARQL expr 表达式对于属性
sh:prefixes 最多可以有一个值,
并且该值是一个 IRI 或一个 空白节点。
令
$EXPR$ 为
sh:sparqlExpr 的值,并令
$PREFIXES$
为使用 sh:prefixes 的值按照前缀处理规则
得到的 SPARQL 前缀块;
然后,将 $EXPR$ 和
$PREFIXES$ 插入如下内容后得到的字符串定义为 select
$PREFIXES$ SELECT ($EXPR$ AS ?result) WHERE {}
select 是一个有效的 SPARQL 1.2 SELECT
查询。
SPARQL expr 表达式的输出
节点是列表
resultNodes,该列表恰好由
上文定义的 select 查询的
SELECT 子句所投影的唯一变量在查询针对焦点图求值时的绑定组成。
focusNode 的值被预绑定为 SPARQL
变量 this 的值。
每个作用域变量的值都被预绑定到具有
相同名称和值的 SPARQL 变量。
如果作用域中变量的名称不是字符串字面量,则使用 "arg" + str(name)。
例如,如果变量名称为 "0"^^xsd:integer,则使用 arg0。
如果某个作用域变量名为 this,
或者以这种方式派生的变量名称不是有效的 SPARQL VARNAME,则产生
失败。
evalExpr(expr, focusGraph, focusNode, scope) -> resultNodes
本节其余部分为非规范性内容。
下面是一个SPARQL expr 表达式的用法示例, 它计算属性 “uri length”的属性形状值,即焦点节点 IRI 的长度。
{
"@id": "ex:Resource-uriLength",
"@type": "sh:PropertyShape",
"sh:datatype": {
"@id": "xsd:integer"
},
"sh:name": "uri length",
"sh:path": {
"@id": "ex:uriLength"
},
"sh:values": {
"sh:sparqlExpr": "STRLEN(STR($this))"
}
}
当应用于 URI 为 http://example.com/ns#Test 的焦点节点时,结果将是
26。
这会产生与以下变体相同的结果:
{
"@id": "ex:Resource-uriLength",
"@type": "sh:PropertyShape",
"sh:datatype": {
"@id": "xsd:integer"
},
"sh:name": "uri length",
"sh:path": {
"@id": "ex:uriLength"
},
"sh:values": {
"sh:select": "\n\t\t\tSELECT (STRLEN(STR($this)) AS ?result)\n\t\t\tWHERE {\n\t\t\t}\n\t\t"
}
}
SHACL 1.2 节点表达式将自定义列表参数 函数 定义为一种声明新节点表达式函数的机制。 这些函数可以作为其他 SHACL 节点表达式的一部分进行求值,也可能对其他 支持类似函数执行方式的引擎有用。
SPARQL 规范定义了一个扩展点, 使某些 SPARQL 引擎能够提供额外的 SPARQL 函数。 本节介绍一种声明式机制,允许 SPARQL 处理器利用该扩展点, 将 SHACL 列表参数函数 作为 SPARQL 函数提供。
此函数接受一个类作为其唯一参数,并返回该 类的实例数量。
{
"@id": "ex:instanceCount",
"@type": "sh:ListParameterExpressionFunction",
"rdfs:label": {
"@language": "en",
"@value": "instance count"
},
"rdfs:subClassOf": {
"@id": "sh:ListParameterExpression"
},
"sh:bodyExpression": {
"shnex:count": {
"shnex:instancesOf": {
"shnex:arg": {
"@type": "xsd:integer",
"@value": "0"
}
}
}
},
"sh:parameter": {
"@type": "sh:Parameter",
"sh:description": "The class to count the instances of.",
"sh:name": "class",
"sh:nodeKind": {
"@id": "sh:IRI"
},
"sh:path": {
"@id": "shnex:arg0"
}
}
}
支持基于节点表达式的 SPARQL 函数的 SPARQL 引擎能够 处理如下 SPARQL 查询:
SELECT ?class ?count
WHERE {
?class a owl:Class .
BIND (ex:instanceCount(?class) AS ?count) .
}
以下自定义列表参数函数在求值时使用“嵌套的”SPARQL 查询。
此函数接受两个参数,并使用SPARQL expr
表达式作为其函数体表达式。
在该 SPARQL 表达式中,变量 $arg0 和 $arg1 用于
访问列表参数值。
它是 [shacl12-node-expr] 中
ex:spacedConcat 示例的一个变体,后者使用
sparql:concat 节点表达式函数,而不是 SPARQL 表达式。
{
"@id": "ex:spacedConcat",
"@type": "sh:ListParameterExpressionFunction",
"rdfs:label": {
"@language": "en",
"@value": "spaced concat"
},
"rdfs:subClassOf": {
"@id": "sh:ListParameterExpression"
},
"sh:bodyExpression": {
"sh:sparqlExpr": "CONCAT($arg0, ' ', $arg1)"
},
"sh:parameter": [
{
"@type": "sh:Parameter",
"sh:datatype": {
"@id": "xsd:string"
},
"sh:description": "The first string to concatenate.",
"sh:name": "first string",
"sh:path": {
"@id": "shnex:arg0"
}
},
{
"@type": "sh:Parameter",
"sh:datatype": {
"@id": "xsd:string"
},
"sh:description": "The second string to concatenate.",
"sh:name": "second string",
"sh:path": {
"@id": "shnex:arg1"
}
}
]
}
支持基于节点表达式的 SPARQL 函数的 SPARQL 引擎能够 处理如下 SPARQL 查询:
SELECT ?person ?fullName
WHERE {
?person a ex:Person .
?person ex:firstName ?firstName .
?person ex:lastName ?lastName .
BIND (ex:spacedConcat(?firstName, ?lastName) AS ?fullName) .
}
以下示例使用 sh:select 节点表达式作为其函数体。
此函数接受两个参数,其中第二个是可选的,并使用选择表达式作为其函数体表达式。
在该 SPARQL 查询中,变量 $arg0 和 $arg1 用于访问
列表参数值。
{
"@id": "ex:langLabelCount",
"@type": "sh:ListParameterExpressionFunction",
"rdfs:label": {
"@language": "en",
"@value": "lang label count"
},
"rdfs:subClassOf": {
"@id": "sh:ListParameterExpression"
},
"sh:bodyExpression": {
"sh:select": "\n\t\t\tPREFIX ex: <http://example.com/ns#>\n\t\t\tPREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n\t\t\tSELECT (COUNT(?label) AS ?result)\n\t\t\tWHERE {\n\t\t\t\t?predicate rdfs:subPropertyOf* rdfs:label .\n\t\t\t\t$arg0 ?predicate ?label .\n\t\t\t\tBIND (COALESCE($arg1, 'en') AS ?matchLang) .\n\t\t\t\tFILTER langMatches(lang(?label), ?matchLang) .\n\t\t\t}\n\t\t"
},
"sh:parameter": [
{
"@type": "sh:Parameter",
"sh:description": "The subject node to get the label count of.",
"sh:name": "subject",
"sh:nodeKind": {
"@id": "sh:IRI"
},
"sh:path": {
"@id": "shnex:arg0"
}
},
{
"@type": "sh:Parameter",
"sh:datatype": {
"@id": "xsd:string"
},
"sh:defaultValue": "en",
"sh:description": "The language to filter, defaulting to 'en'.",
"sh:name": "match language",
"sh:optional": {
"@type": "xsd:boolean",
"@value": "true"
},
"sh:path": {
"@id": "shnex:arg1"
}
}
]
}
此函数接受一个可选的匹配语言参数,该参数通过
sh:optional true 三元组声明。
但请注意,sh:parameter 声明中的 SHACL 约束
不会自动强制执行,声明的 sh:defaultValue 也不会在运行时使用。
除决定如何处理参数错误的 sh:optional 外
(参见7.3 自定义
SPARQL 函数的求值),这些声明仅用于文档说明。
{
"@id": "ex:Cougar",
"rdfs:label": [
{
"@language": "en",
"@value": "Cougar"
},
{
"@language": "en-US",
"@value": "Mountain Lion"
},
{
"@language": "de",
"@value": "Puma"
}
]
}
本文档未定义添加此类自定义 SPARQL 函数的确切方式和时机限制。
建议 SPARQL 引擎应该为任何所提供形状图中的
sh:ListParameterExpressionFunction 的每个SHACL
实例注册一个函数。
如果具有相同 IRI
的函数已经注册为内置函数或
其他非自定义函数,
则 SPARQL 引擎必须忽略重新定义该函数的尝试。
如果已注册的函数本身就是自定义 SPARQL 函数,例如来自先前提供的形状图,
则新声明会替换它。
SPARQL 引擎在执行任何 SPARQL 查询期间不得修改已注册的 SPARQL 函数。
设 f 为 SPARQL 函数调用的
iri,
args 为 Expression 参数列表。
设 function 为定义该函数的图中
对应的自定义列表参数函数,其 IRI
为 f。
对 args 中的每个 SPARQL 表达式求值,得到一个新的节点
列表 nodesList。
如果求值过程中产生了错误,
则 SPARQL 函数调用的结果也是错误,
除非对应参数的 sh:parameter 声明具有
sh:optional true。
在这种情况下,该参数在作用域中将处于未绑定状态。
请注意,空白
节点不能作为参数传递:它们不是常量节点表达式,
因此,求值结果为空白节点的参数会导致求值失败,
从而产生错误。
设 rs 为 evalExpr(function, focusGraph, f, scope) 的输出节点,
其中 focusGraph 是 SPARQL 上下文中当前活动的查询图,
scope 是从 nodesList 中已求值参数构成的映射,以参数索引作为变量名称(映射键)。
如果输出节点列表 rs 恰好包含一个成员,则返回该节点。
否则,或者如果求值产生求值失败,
则 SPARQL 函数调用的结果是错误。
SHACL-SPARQL 的某些特性依赖于本节定义的变量预绑定概念。
此特性“存在风险”,可能会进行修改(但不会被移除), 以与 RDF 和 SPARQL 1.2 在此领域当前正在进行的工作保持一致。 最初在议题 647中讨论。
SHACL 使用的预绑定定义要求对 SPARQL 查询施加以下限制。
当 SHACL-SPARQL 处理器处理的形状图包含
通过 sh:ask、sh:construct、
sh:select 和 sh:sparqlExpr 指定的 SHACL-SPARQL 查询,
且这些查询在使用预绑定变量执行时违反以下任何标记为“必须”的
限制,则处理器必须报告失败。
请注意,术语可能预绑定的变量包括变量 this、
value(对于 ASK 查询)、
表示使用该查询的约束
组件的参数的任何变量,
以及表示基于 SPARQL 的
节点表达式的作用域变量的变量
(例如 arg0)。
MINUS 子句VALUES 子句AS ?var
此外,SPARQL 查询不应该包含联合查询
(SERVICE)。
不允许使用 SERVICE 的实现必须按照
上文所述报告失败。
但是,某些 SPARQL 实现使用 SERVICE 关键字作为
特定操作(通常是本地操作)的语法,
因此并未普遍禁止使用该关键字。
对于解映射 μ,定义 Table(μ) 为由
μ 构成的多重集。
Table(μ) = { μ }
Card[μ] = 1
定义值插入函数 Replace(X, μ),
将 X 中每次出现的
基本图
模式、
属性路径
表达式、
Graph(Var, pattern)
Y 替换为 join(Y, Table(μ))。
具有预绑定变量 μ 的 SPARQL
查询
Q = (E, DS, QF) 的求值
定义为对 SPARQL 查询 Q' = (Replace(E, μ), DS, QF) 的求值。
本节列举了本文档的所有规范性语法规则。 本节由本规范的其他部分自动生成,并提供了返回正文的超链接, 以便在规则的上下文不明确时进行查阅。 在形状图中违反这些规则的节点是非良构的。
| 语法规则 ID | 语法规则文本 |
|---|---|
| prefix-count | 前缀声明恰好具有一个属性
sh:prefix 的值
|
| prefix-datatype | sh:prefix 的值是数据类型为
xsd:string 的字面量。
|
| namespace-count | 前缀声明恰好具有一个属性
sh:namespace 的值。
|
| namespace-datatype | sh:namespace 的值是数据类型为
xsd:anyURI 或 xsd:string 的字面量。
|
| declare-nodeKind | 属性 sh:declare 的值是前缀声明 |
| prefixes-nodeKind | sh:prefixes 的值是 IRI 或空白节点。 |
| prefixes-duplicates | 如果这样收集的前缀声明包含对应同一个 sh:prefix
值的多个不同命名空间,
则该形状
图是非良构的。
|
| sparql-nodeKind | 形状可以具有属性 sh:sparql 的值,这些值是 IRI 或空白
节点。 |
| SPARQLConstraint-select-count | 基于 SPARQL 的约束恰好具有一个
属性 sh:select 的值 |
| SPARQLConstraint-select-datatype | sh:select 的值是数据类型为
xsd:string 的字面量。
|
| select-query-valid | 按照前缀处理规则,sh:select 的值
是有效的 SPARQL 1.2 SELECT 查询。 |
| select-query-this | 从 sh:select 的值派生的 SPARQL 查询在 SELECT 子句中投影变量
this。
|
| SPARQLConstraint-message-datatype | 基于 SPARQL 的约束可以具有
属性 sh:message 的值,
这些值是字面量,其数据类型为
xsd:string、rdf:dirLangString、rdf:langString 或
rdf:HTML。
sh:message 不应具有多个使用相同语言标签的值,
也不应具有多个数据类型为 xsd:string 的值。
|
| SPARQLConstraint-deactivated-maxCount | 基于 SPARQL 的约束最多可以具有一个
属性 sh:deactivated 的值 |
| SPARQLConstraint-severity | 基于 SPARQL 的约束最多可以具有一个
属性 sh:severity 的值,
且该值是一个 IRI。 |
| PATH-position | 在基于 SPARQL 的约束
和基于 SELECT 的验证器的 SPARQL 查询中,
变量 PATH 唯一合法的用法是出现在谓词
位置,即三元组模式的谓词位置。
|
| ConstraintComponent | 基于 SPARQL 的约束组件是
在形状图中具有
SHACL 类型
sh:ConstraintComponent 的 IRI。
|
| Parameter-predicate-count | 每个参数声明都恰好具有一个
属性 sh:path 的值 |
| Parameter | 在参数声明中,sh:path 的值是一个 IRI。 |
| parameter-name-VARNAME | 每个参数名称都是有效的 SPARQL VARNAME。 |
| parameter-name-not-in | 参数名称不得为以下任何一个:
this、path、PATH、value、message、
failure。
|
| parameter-name-unique | 如果一个约束组件中的两个或多个参数声明使用 相同的参数名称,则该约束组件是非良构的。 |
| optional-datatype | sh:optional 的值必须是数据类型为 xsd:boolean 的字面量。 |
| optional-maxCount | 一个参数声明最多可以具有一个
属性 sh:optional 的值。 |
| ConstraintComponent-parameter | 每个约束组件都具有 至少一个非可选参数。 |
| Parameter-conformance | 不符合为参数声明的约束的形状 是非良构的。 |
| labelTemplate-datatype | sh:labelTemplate 的值是字面量,其数据类型为
xsd:string、rdf:langString 或 rdf:dirLangString
|
| nodeValidator-class | sh:nodeValidator 的值必须是基于 SELECT 的
验证器。 |
| propertyValidator-class | sh:propertyValidator 的值必须是基于 SELECT 的
验证器。 |
| SPARQLSelectValidator-select-count | 基于 SELECT 的验证器恰好具有一个
属性 sh:select 的值。 |
| SPARQLSelectValidator-select-datatype | sh:select 的值是数据类型为
xsd:string 的字面量。
|
| SPARQLSelectValidator-select-query-valid | 按照前缀处理规则,sh:select 的值
是有效的 SPARQL 1.2 SELECT 查询。 |
| SPARQLSelectValidator-select-query-this | 从 sh:select 的值派生的 SPARQL 查询在其 SELECT 子句中投影变量
this。
|
| validator-class | sh:validator 的值必须是基于 ASK 的
验证器。 |
| ask-count | 基于 ASK 的验证器恰好具有一个
属性 sh:ask 的值 |
| ask-datatype | sh:ask 的值必须是数据类型为 xsd:string 的字面量。 |
| ask-sparql | sh:ask 的值必须是按照上述前缀处理规则构成的有效 SPARQL ASK 查询。 |
| resultAnnotation-nodeKind | sh:resultAnnotation 的值
称为结果注解,可以是
IRI 或空白节点
|
| annotationProperty | 每个结果注解都恰好具有一个
属性 sh:annotationProperty 的值,且该值是一个
IRI。
|
| annotationVarName | 每个结果注解最多具有一个
属性 sh:annotationVarName 的值,且该值是
字面量,其
数据类型为
xsd:string。
|
| SelectExpression-syntax | 如果 RDF 图中的一个节点是空白节点,
且恰好具有一个谓词 sh:select 的值,
并且该值是一个
字面量,
其数据类型为
xsd:string,则该节点是一个良构的选择表达式。
|
| SelectExpression-syntax-prefixes | 一个良构的
选择表达式最多可以具有一个
属性 sh:prefixes 的值,
且该值只能是一个IRI 或一个空白节点。
|
| SelectExpression-query-valid | 按照前缀处理规则,sh:select 的值
是有效的 SPARQL 1.2 SELECT 查询。 |
| SelectExpression-query-output-nodes | 从 sh:select 的值派生的 SPARQL 查询在
SELECT 子句中恰好投影一个变量。
|
| SPARQLExprExpression-syntax-eval | 如果 RDF 图中的一个节点
是空白节点,
且恰好具有一个谓词 sh:sparqlExpr 的值,
并且该值是一个
字面量,
其数据类型为
xsd:string,则该节点是一个良构的SPARQL expr 表达式。
|
| SPARQLExprExpression-syntax-prefixes | 一个良构的
SPARQL expr 表达式最多可以具有一个
属性 sh:prefixes 的值,
且该值是一个IRI 或一个空白节点。
|
| SPARQLExprExpression-template | 设 $EXPR$ 为 sh:sparqlExpr 的值,
$PREFIXES$
为使用 sh:prefixes 的值按照前缀处理规则
得到的 SPARQL 前缀块;
则 select 定义为将 $EXPR$ 和
$PREFIXES$ 插入以下模板后得到的字符串:
$PREFIXES$ SELECT ($EXPR$ AS ?result) WHERE {} |
| SPARQLExprExpression-query-valid | select 是有效的 SPARQL 1.2 SELECT 查询。 |
| pre-binding-limitations |
SHACL 使用的预绑定定义要求对 SPARQL
查询施加以下限制。
当 SHACL-SPARQL 处理器处理的形状
图
包含通过
此外,SPARQL 查询不应该包含联合查询
( |
本节不具有规范性。
本附录使用 SPARQL 1.2 的部分内容,为 [shacl12-core] 中的约束 组件和目标 的语义提供非规范性的替代定义。 虽然这些定义可能对某些实现者有所帮助,但实现 SHACL Core 语言并不要求使用 SPARQL。
sh:targetClass 和 sh:class 的定义仅在
数据图中查找
rdfs:subClassOf 三元组。如果设置了处理器参数
subClassOfInShapesGraph,
则还需要考虑形状图中的
rdfs:subClassOf 三元组。
使用 $ 标记的 SPARQL 变量表示外部绑定,这些绑定会被预绑定,或者对于 $PATH,会在 SPARQL 查询执行前被替换(如3.3 使用
基于 SPARQL 的约束进行验证中所述)。
以下查询用 SPARQL 表达了类目标的一种可能定义。
变量 targetClass 将被预绑定到
sh:targetClass 的给定值。
从解中获得的变量 this 的所有绑定都将成为焦点节点。
SELECT DISTINCT ?this # ?this 是焦点节点
WHERE {
?this rdf:type/rdfs:subClassOf* $targetClass .
}
以下查询用 SPARQL 表达了主语目标的一种可能定义。
变量 targetSubjectsOf 将被预绑定到
sh:targetSubjectsOf 的给定值。
从解中获得的变量 this 的所有绑定都将成为焦点节点。
SELECT DISTINCT ?this # ?this 是焦点节点
WHERE {
?this $targetSubjectsOf ?any .
}
以下查询用 SPARQL 表达了宾语目标的一种可能定义。
变量 targetObjectsOf 将被预绑定到
sh:targetObjectsOf 的给定值。
从解中获得的变量 this 的所有绑定都将成为焦点节点。
SELECT DISTINCT ?this # ?this 是焦点节点
WHERE {
?any $targetObjectsOf ?this .
}
以下查询表达了一个适用于 sh:class 的可能的基于 SPARQL 的验证器。
ASK {
$value rdf:type/rdfs:subClassOf* $class .
}
以下查询表达了一个适用于 sh:nodeKind 的可能的基于 SPARQL 的验证器。
ASK {
FILTER ((isIRI($value) && $nodeKind IN ( sh:IRI, sh:BlankNodeOrIRI, sh:IRIOrLiteral ) ) ||
(isLiteral($value) && $nodeKind IN ( sh:Literal, sh:BlankNodeOrLiteral, sh:IRIOrLiteral ) ) ||
(isBlank($value) && $nodeKind IN ( sh:BlankNode, sh:BlankNodeOrIRI, sh:BlankNodeOrLiteral ) )) .
}
以下查询表达了一个适用于 sh:minExclusive 的可能的基于 SPARQL 的验证器。 如果值节点无法与指定范围进行比较,例如有人将字符串与整数进行比较,SPARQL 表达式就会产生错误。 如果无法执行比较,则会产生一个验证结果。 这不同于普通的 SPARQL 查询,在普通 SPARQL 查询中,此类错误会悄无声息地不产生任何 结果。
ASK {
FILTER ($minExclusive < $value)
}
以下属性可以采用类似的定义:
以下查询表达了一个适用于 sh:minLength 的可能的基于 SPARQL 的验证器。
ASK {
FILTER (STRLEN(str($value)) >= $minLength) .
}
以下查询表达了一个适用于 sh:maxLength 的可能的基于 SPARQL 的验证器。
ASK {
FILTER (STRLEN(str($value)) <= $maxLength) .
}
以下查询表达了一个适用于 sh:pattern 的可能的基于 SPARQL 的验证器。
ASK {
FILTER (!isBlank($value) && IF(bound($flags), regex(str($value), $pattern, $flags), regex(str($value), $pattern)))
}
以下查询表达了一个适用于 sh:disjoint 的可能的基于 SPARQL 的验证器。
SELECT DISTINCT $this ?value
WHERE {
$this $PATH ?value .
$this $disjoint ?value .
}
以下查询表达了一个适用于 sh:lessThan 的可能的基于 SPARQL 的验证器。
SELECT $this ?value
WHERE {
$this $PATH ?value .
$this $lessThan ?otherValue .
BIND (?value < ?otherValue AS ?result) .
FILTER (!bound(?result) || !(?result)) .
}
以下查询表达了一个适用于 sh:lessThanOrEquals 的可能的基于 SPARQL 的验证器。
SELECT $this ?value
WHERE {
$this $PATH ?value .
$this $lessThanOrEquals ?otherValue .
BIND (?value <= ?otherValue AS ?result) .
FILTER (!bound(?result) || !(?result)) .
}
本节为非规范性内容。
请注意,GRAPH 和 FROM 等 SPARQL 关键字可能会提供对
数据集中活动数据图以外图的访问。
SHACL-SPARQL 引擎应确保 SPARQL 引擎不会提供对
触发验证的用户无权访问的命名图的访问。
SHACL-SPARQL 的安全考量包括
SPARQL、
SPARQL 联邦查询
(SERVICE)以及
SHACL Core
的所有安全考量。
本节为非规范性内容。
原始 SHACL 核心规范由 RDF 数据形状工作组制作。 参见核心规范的致谢 章节以及 高级特性规范的 致谢章节。
本节为非规范性内容。
sh:SPARQLTarget 和
sh:SPARQLTargetType 的 sh:target);
其用例现由 sh:targetNode 处的节点表达式涵盖,
参见6.1
选择表达式
sh:SPARQLFunction 声明的 SPARQL 函数(来自 SHACL 高级特性)已被
7. 基于节点表达式
声明 SPARQL 函数取代
sh:SPARQLRule)现定义于 [shacl12-inference-rules] 中
sh:message)现在还可以使用数据类型 rdf:HTML 和
rdf:dirLangString
sh:SelectExpression,参见议题 288
sh:SPARQLExprExpression,参见议题 315
shapesGraph 和
currentShape 的支持,参见议题 426
sh:severity,参见议题
573sh:prefixes,系统将使用任何
sh:ShapesGraph 中声明的任意 sh:prefix/sh:namespace 配对,参见
议题 176
Referenced in:
Referenced in:
Referenced in:
Referenced in:
Referenced in:
Referenced in:
Referenced in:
Referenced in:
Referenced in:
Referenced in:
Referenced in:
Referenced in:
Referenced in:
Referenced in: