SHACL 1.2 SPARQL 関連機能

概要

この文書は、SHACL Shapes Constraint Language の SPARQL 関連機能を定義する。 SHACL の Core 部分がシェイプの基本構文および SHACL でサポートされる最も一般的な制約コンポーネントを定義する一方、SPARQL 関連機能は SPARQL を用いて Core の表現力を拡張する。特に、この文書は、SPARQL を使用して制約および制約コンポーネントをどのように定義できるかを定義する。さらに、この文書は、ノードのリストを導出するために使用できる SPARQL ベースのノード式を導入する。最後に、この文書は、SHACL ノード式に基づいて新しい SPARQL 関数を定義するための宣言的な仕組みを定義する。

この文書は、Shapes Constraint Language (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 で使用されます。 1 つのリンクがあれば、この文書内に出現する特定の用語のすべての箇所に対する定義を提供するのに十分です。

定義はこの文書内で完結しています。すなわち、この文書にある状況を真にする規則が存在しない場合、その状況は偽です。

基本的な RDF 用語

この文書では、 RDF グラフ、 RDF トリプル、 IRI、リテラル、空白ノード、 RDF グラフのノード、データ型、具体化子、 RDF 用語、ならびに RDF トリプルの主語、述語、および目的語という用語を、 RDF 1.2 Concepts and Abstract Syntax [rdf12-concepts] で定義されているとおりに使用します。

SHACL の基本用語

この文書では、SHACL 1.2 コア仕様 [shacl12-core] で定義されているフォーカスノード、値、値ノード、制約、制約コンポーネント、パラメーター、必須パラメーター、任意パラメーター、パラメーター値、シェイプ、ノードシェイプ、プロパティシェイプ、 SHACL プロパティパス、 SPARQL プロパティパス、データグラフ、シェイプグラフ、ターゲット、バリデーター、ノード式、ノード式関数、関数名、出力ノード、評価失敗、フォーカスグラフ、適合、失敗、検証結果、 SHACL インスタンス、 SHACL サブクラス、 SHACL スーパークラス、 SHACL 型、整形式、非整形式という用語を使用します。

バインディング、解

バインディングとは、(変数, RDF 用語) の組であり、 [sparql12-query] におけるこの用語の用法と一致します。解とは、各変数が一意でなければならないバインディングの集合です。非公式には、解は SPARQL クエリの結果表の本体における 1 行として理解されることがよくあります。

SHACL の構文は RDF です。この文書の例では Turtle [rdf12-turtle] を使用します。実際には RDF/XML などの他の RDF シリアル化を使用できます。読者は、トリプルなどの基本的な 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 は、上記の名前空間と同等であり、つまり # を含むことに注意してください。たとえば owl:imports による SHACL 語彙への参照には、# を含めるべきです。

文書全体に、Turtle の RDF グラフを含む色分けされたボックスが現れます。これらの Turtle 文書の断片は、上記のプレフィックスバインディングを使用します。

# このボックスは入力シェイプグラフを表します <s> ex:p <o> .

// このボックスは入力シェイプグラフを表します

{
	"@id": "s",
	"ex:p": {
		"@id": "o"
	}
}

# このボックスは入力データグラフを表します。

{
	"@graph": [
	]
}

# このボックスは出力結果グラフを表します

// このボックスは出力結果グラフを表します

{}

SHACL 定義は青いボックスに表示されます:

SPARQL またはテキスト定義

# このボックスには SPARQL またはテキスト定義が含まれます。

このような灰色のボックスには、シェイプグラフに適用される構文規則が含まれます。

$マーカーを使用するSPARQL変数は、外部の束縛を表し、これらは事前に束縛されるか、$PATHの場合には、置換される。これらの処理はSPARQLクエリの実行前に行われる（詳しくは 3.3 次を用いた検証： SPARQLベースの制約で説明されている）。

true は RDF 用語 "true"^^xsd:boolean を表します。 false は RDF 用語 "false"^^xsd:boolean を表します。

非規範的と明示された節に加えて、この仕様に含まれるすべての作成ガイドライン、図、例、注記は非規範的です。この仕様のその他のすべての内容は規範的です。

この文書におけるキーワード MAY、MUST、MUST NOT、OPTIONAL、および SHOULD は、ここに示すようにすべて大文字で記述されている場合に限り、BCP 14 [RFC2119] [RFC8174] に記載されているとおりに解釈しなければなりません。

この文書は、SHACL コアを拡張する SHACL-SPARQL 言語を定義します。この仕様では、次の適合基準について説明します。

SHACL-SPARQL 検証プロセッサーは、 3. SPARQL ベースの制約および4. SPARQL ベースの制約コンポーネントを使用した SHACL 検証をサポートするプロセッサーです（テストスイートでは SPARQLValidation として識別されます）。このようなプロセッサーは、追加で5. 注釈プロパティをサポートしてもかまいません（MAY）。サポートするプロセッサーは、その節の規則に従わなければなりません（MUST）。
SPARQL ノード式プロセッサーは、 6. SPARQL ベースのノード式を評価できるプロセッサーです（テストスイートでは SPARQLNodeExpr）
SPARQL カスタム関数プロセッサーは、 7. ノード式に基づく SPARQL 関数の宣言を評価できるプロセッサーです（テストスイートでは SPARQLCustomFunctions）

SHACL コアの適合性の節にある整形式に関する説明も参照してください。

注記

SHACL 1.2 推論ルール仕様 [shacl12-inference-rules] は、SHACL 向けの追加の SPARQL ベースの機能を定義します。

この節では、SPARQLクエリの名前空間接頭辞を宣言するために、この文書全体で使用される仕組みを紹介します。

シェイプグラフには、同じシェイプグラフから導出されたSPARQLクエリを短縮するために使用できる名前空間接頭辞の宣言を含めることができます。このような接頭辞宣言の構文を、次の例に示します。

例 1：シェイプグラフにおける接頭辞宣言

ex: sh:declare [ sh:prefix "ex" ; sh:namespace "http://example.com/ns#"^^xsd:anyURI ; ] ; sh:declare [ sh:prefix "schema" ; sh:namespace "http://schema.org/" ; ] ; a sh:ShapesGraph ; # Optional owl:imports sh: . # Optional

{
	"@id": "http://example.com/ns#",
	"@type": "sh:ShapesGraph",
	"owl:imports": {
		"@id": "http://www.w3.org/ns/shacl#"
	},
	"sh:declare": [
		{
			"sh:namespace": {
				"@type": "xsd:anyURI",
				"@value": "http://example.com/ns#"
			},
			"sh:prefix": "ex"
		},
		{
			"sh:namespace": "http://schema.org/",
			"sh:prefix": "schema"
		}
	]
}

sh:prefixとsh:namespaceの両方の値を持つ IRIまたは空白ノードは、接頭辞宣言と呼ばれます。 SHACL語彙には、このような接頭辞宣言の型としてクラスsh:PrefixDeclarationが含まれていますが、これらにrdf:typeトリプルは必要ありません。接頭辞宣言は、プロパティsh:prefixの値を正確に1つ持ちます。 sh:prefixの値は、データ型 xsd:stringのリテラルです。接頭辞宣言は、プロパティsh:namespaceの値を正確に1つ持ちます。 sh:namespaceの値は、データ型 xsd:anyURIまたはxsd:stringのリテラルです。このような値の組は、接頭辞から名前空間への単一のマッピングを指定します。プロパティ sh:declareの値は、接頭辞宣言です。

sh:declareの値に推奨される主語は、接頭辞を使用するシェイプを含む名前付きグラフのIRIです。これらの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 プロセッサーは、到達しない接頭辞宣言を無視してもかまいません（MAY））。

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 プロセッサーは失敗を生成しなければなりません（MUST）。

この文書の残りの部分では、簡潔にするために sh:prefixes 文を省略している場合があります。

SHACL-SPARQLは、SPARQL SELECTクエリに基づく制限を表現するために使用できる制約コンポーネントをサポートします。

制約コンポーネントIRI: sh:SPARQLConstraintComponent

パラメーター:

プロパティ	概要
`sh:sparql`	評価するSPARQLクエリを宣言するSPARQLベースの制約。

SPARQLベースの制約の構文規則および検証プロセスは、この節の以降の部分で定義します。

この節は非規範的です。

次の例は、SPARQLベースの制約の構文を示しています。

例 2: SPARQLベースの制約

ex:LanguageExampleShape a sh:NodeShape ; sh:targetClass ex:Country ; sh:sparql [ a sh:SPARQLConstraint ; # This triple is optional sh:message "Values are literals with German language tag." ; sh:prefixes ex: ; sh:select """ SELECT $this (ex:germanLabel AS ?path) ?value WHERE { $this ex:germanLabel ?value . FILTER (!isLiteral(?value) || !langMatches(lang(?value), "de")) } """ ; ] . ex: sh:declare [] . # See prefix declarations

{
	"@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インスタンスが含まれます。 SPARQLクエリは、それらのノード（変数thisによって表されます）について、 ex:germanLabelの値をたどり、それらがドイツ語の言語コードを持つリテラルであることを検証します。

ex:ValidCountry a ex:Country ; ex:germanLabel "Spanien"@de . ex:InvalidCountry a ex:Country ; ex:germanLabel "Spain"@en .

{
	"@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"
			}
		}
	]
}

[ a sh:ValidationReport ; sh:conforms false ; sh:result [ a sh:ValidationResult ; sh:resultSeverity sh:Violation ; sh:focusNode ex:InvalidCountry ; sh:resultPath ex:germanLabel ; sh:value "Spain"@en ; sh:sourceConstraintComponent sh:SPARQLConstraintComponent ; sh:sourceShape ex:LanguageExampleShape ; # ... ] ] .

{
	"@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のすべての束縛について、結果集合の解を返します。後述するマッピング規則を適用し、その結果集合内の各解に対して1つの検証結果があります。この例では、各検証結果は、変数 thisの束縛をsh:focusNodeとして、 ex:germanLabelをsh:resultPathとして、違反する値を sh:valueとして持ちます。

次の例は、上記と同様のシナリオをプロパティシェイプで示します。

例 3：プロパティシェイプにおける SPARQL ベースの制約

ex:LanguageExamplePropertyShape a sh:PropertyShape ; sh:targetClass ex:Country ; sh:path ex:germanLabel ; sh:sparql [ a sh:SPARQLConstraint ; # This triple is optional sh:message "Values are literals with German language tag." ; sh:prefixes ex: ; sh:select """ SELECT $this ?value WHERE { $this $PATH ?value . FILTER (!isLiteral(?value) || !langMatches(lang(?value), "de")) } """ ; ] . ex: sh:declare [] . # See prefix declarations

{
	"@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の値を正確に1つ持ちます。 sh:selectの値は、データ型 xsd:stringのリテラルです。クラスsh:SPARQLConstraintはSHACL語彙で定義されており、これらの制約の型として使用できます（ただし、型は必須ではありません）。接頭辞処理規則を使用すると、sh:selectの値は有効なSPARQL 1.2 SELECTクエリになります。 sh:selectの値から導出されるSPARQLクエリは、SELECT句で変数 thisを射影します。

次の2つのプロパティは、シェイプでの使用方法と同様です。

SPARQL ベースの制約は、プロパティ sh:message の値を持つことができ、これらはリテラルであり、そのデータ型は xsd:string、rdf:dirLangString、rdf:langString、または rdf:HTML です。同じ言語タグを持つ sh:message の値が複数存在してはならず、データ型が xsd:string の値も複数存在すべきではありません。 SPARQL ベースの制約は、プロパティ sh:deactivated の値を最大 1 つ持つことができますが、この値はノード式であり、シェイプの場合と同様に、（唯一の）出力ノードとして true または false を持たなければなりません。 SPARQL ベースの制約は、プロパティ sh:severity の値を最大 1 つ持つことができ、この値はIRIです。

プロパティシェイプのコンテキストで使用される SELECT クエリーは、 PATH という名前の特別な変数を、シェイプが使用するパスのプレースホルダーとして使用します。

SPARQL ベースの制約および SPARQL ベースの制約の SPARQL クエリーにおいて、 SELECT ベースのバリデーターで変数 PATH を使用できるのは、述語のトリプルパターン内の位置のみです。変数 PATH を他の位置で使用するクエリーは非整形式です。

変数 PATH は、プロパティシェイプの場合にのみ置換されます。ノードシェイプの SPARQL クエリーでは、バインドされていない変数のままです。

この節では、sh:SPARQLConstraintComponent のバリデーターについて説明します。このバリデーターは、考えられる実装戦略の 1 つを示すにすぎず、 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 を解の変数 failure に対するバインディングとして持たない各解につき 1 つ生成されます。これらの検証結果は、MUST、3.3.2 解のバインディングから結果プロパティへのマッピングで説明されているプロパティ値を持たなければなりません。 $sparql が sh:severity の値を持つ場合、検証結果は、MUST、その値を唯一の sh:resultSeverity として持たなければなりません。いずれかの失敗は、MUST、解のいずれかが failure に対するバインディングとして true を持つ場合、かつその場合に限り生成されなければなりません。

SPARQLベースの制約の SPARQLクエリ、およびSPARQLベースの制約コンポーネントのバリデーターが処理されるとき、 SHACL-SPARQLプロセッサは、変数$thisの値を現在のフォーカスノードに事前束縛します。

検証結果ノードのプロパティの値は、結果の解と制約自体の値を組み合わせて、次の規則によって導出されます。規則は上から下へ実行され、最初に束縛された値が使用されることを意図しています。

プロパティ	生成規則
`sh:focusNode`	変数`this`の束縛
`sh:resultPath`	変数`path`の束縛（それがIRIの場合）プロパティシェイプによって生成された結果の場合、シェイプの `sh:path`の値と同等の SHACL プロパティパス
`sh:value`	変数`value`の束縛値ノード
`sh:resultMessage`	変数`message`の束縛 SPARQLベースの制約の場合: SPARQLベースの制約の `sh:message`の値。 SPARQLベースの制約コンポーネントの場合: SPARQLベースの制約コンポーネントのバリデーターの `sh:message`の値。 SPARQLベースの制約コンポーネントの場合: SPARQLベースの制約コンポーネントの`sh:message`の値。それ以外の場合は、シェイプまたは制約でメッセージを宣言するための既定の仕組みが適用されます。これらのメッセージリテラルには、`{?varName}`または `{$varName}`を介して任意のSELECT結果変数の名前を含めることができます。制約がSPARQLベースの制約コンポーネントに基づく場合、コンポーネントのパラメーター名も使用できます。これらの`{?varName}`および`{$varName}`ブロックは、それらの変数の値を表す適切な文字列表現に置き換えるべきである。
`sh:sourceConstraint`	SPARQLベースの制約、すなわち`sh:sparql`の値

変数 failure は予約されており、結果プロパティにはマッピングされません。上記で定義されているように、failure の解が true を failure のバインディングとして持つ場合、失敗が生成され、検証結果は生成されません。

SPARQLベースの制約は高い柔軟性を提供しますが、人によっては理解しにくかったり、繰り返しにつながったりする可能性があります。この節では、SPARQLの複雑さを抽象化し、Core制約コンポーネントに類似した高水準で再利用可能なコンポーネントを宣言する方法として、SPARQLベースの制約コンポーネントを導入します。このような制約コンポーネントは、SHACL RDF語彙を使用して宣言できるため、共有および再利用できます。

この節は非規範的です。

次の例は、SHACL-SPARQL言語を使用して新しい制約コンポーネントを指定するために、 SPARQLをどのように使用できるかを示しています。この例では、各値ノードが指定された正規表現に一致することを検証するために、sh:patternおよび sh:flagsを SPARQL ASKクエリを使用して実装します。これは実装例にすぎず、規範的なものと見なすべきではないことに注意してください。

例 4: SPARQLに基づく制約コンポーネント

sh:PatternConstraintComponent a sh:ConstraintComponent ; sh:parameter [ sh:path sh:pattern ; ] ; sh:parameter [ sh:path sh:flags ; sh:optional true ; ] ; sh:validator ex:hasPattern . ex:hasPattern a sh:SPARQLAskValidator ; sh:message "値がパターン {$pattern} に一致しません" ; sh:ask """ ASK { FILTER (!isBlank($value) && IF(bound($flags), regex(str($value), $pattern, $flags), regex(str($value), $pattern))) }""" .

{
	"@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"
			}
		}
	]
}

制約コンポーネントを宣言すると、次の例に示すように、そのパラメーターをシェイプで使用できます。

例 5: SPARQL に基づく制約コンポーネント

ex:CaseInsensitiveSearch a sh:NodeShape ; sh:property [ sh:path ex:code ; sh:pattern "^[A-Z]{3}[0-9]{2}$" ; sh:flags "i" ; # 大文字と小文字を区別しない照合 ] .

{
	"@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の値を正確に1つ持ちます。パラメーター宣言において、 sh:pathの値はIRIです。

IRIのローカル名は、IRIの末尾にある最長の NCNAMEであり、 IRI内の最初のコロンがその直前にないものとして定義されます。パラメーター宣言のパラメーター名は、sh:pathの値のローカル名として定義されます。パラメーターからSPARQL変数への正しいマッピングを可能にするため、次の構文規則が適用されます。

すべてのパラメーター名は、有効なSPARQL VARNAMEです。パラメーター名は、次のいずれでもあってはなりません。 this、path、PATH、value、 message、failure。 2 つ以上のパラメーター宣言が同じパラメーター名を使用する制約コンポーネントは非整形式です。

sh:optionalの値は、データ型xsd:booleanを持つリテラルでなければなりません。パラメーター宣言は、プロパティ sh:optionalの値を最大1つ持つことができます。 trueに設定されている場合、パラメーター宣言は任意選択のパラメーターを宣言します。すべての制約コンポーネントは、任意選択ではないパラメーターを少なくとも1つ持ちます。

クラス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用）に基づく2種類のバリデーターが含まれています。

バリデーターのうち、 SHACL 型が sh:SPARQLSelectValidator であるものをSELECT ベースのバリデーターと呼びます。 sh:nodeValidator の値は、SELECT ベースのバリデーターでなければなりません。 sh:propertyValidator の値は、SELECT ベースのバリデーターでなければなりません。 SELECT ベースのバリデーターは、プロパティ sh:select に対してちょうど 1 つの値を持ちます。 sh:select の値は、データ型が xsd:string のリテラルです。接頭辞の処理規則を使用すると、sh:select の値は有効な SPARQL 1.2 SELECT クエリーになります。 sh:select の値から導出された SPARQL クエリーは、SELECT 句で変数 this を射影します。

この節の残りは非規範的です。

次の例は、SPARQL SELECT クエリに基づく制約コンポーネントの宣言を示しています。これは、3.1 SPARQL に基づく制約の例の例を一般化したものです。その SPARQL クエリには、特定のプロパティ ex:germanLabel と言語タグ de という2つの定数が含まれていましたが、この例では、任意のプロパティを言語タグ付きで定義できるように制約を一般化しています。実際には、制約コンポーネントは、パラメータ述語をシェイプに追加することで適用され（例: ex:lang "de"）、SHACL-SPARQL プロセッサは、SELECT バリデータを実行する前に、これを対応する SPARQL 変数（例: $lang）に事前バインドします。制約コンポーネントを使用すると、このようなシナリオを一般化し、定数が事前バインドされる際にパラメータを使用できます。これにより、新しい SPARQL を記述することなく、複数の場所でクエリロジックを再利用できます。

例 6: SPARQL に基づく制約コンポーネント

ex:LanguageConstraintComponentUsingSELECT a sh:ConstraintComponent ; rdfs:label "言語制約コンポーネント" ; sh:parameter [ sh:path ex:lang ; sh:datatype xsd:string ; sh:minLength 2 ; sh:name "言語" ; sh:description "言語タグ（例: \"de\"）。" ; ] ; sh:labelTemplate "値は言語 \"{$lang}\" のリテラルです" ; sh:propertyValidator [ a sh:SPARQLSelectValidator ; sh:message "値は言語 \"{?lang}\" のリテラルです" ; sh:select """ SELECT DISTINCT $this ?value WHERE { $this $PATH ?value . FILTER (!isLiteral(?value) || !langMatches(lang(?value), $lang)) } """ ] .

{
	"@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 をその値にバインドします）。

例 7：ex:LanguageConstraintComponentUsingSELECT を使用したシェイプ宣言

ex:LanguageExampleShape a sh:NodeShape ; sh:targetClass ex:Country ; sh:property [ sh:path ex:germanLabel ; ex:lang "de" ; ] ; sh:property [ sh:path ex:englishLabel ; ex:lang "en" ; ] .

{
	"@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 パラメータの値を持つ2つのプロパティシェイプによって指定されています。

多くの制約コンポーネントでは、すべての値ノードを何らかのブール条件に対して個別にテストします。特に、制約コンポーネントをプロパティシェイプとノードシェイプの両方で使用できる場合、このためのSELECTクエリの記述は煩雑になります。 SHACL-SPARQLは、ASKクエリに基づくバリデーター用に、より簡潔な代替構文を提供します。

SHACL 型sh:SPARQLAskValidatorを持つバリデーターは、 ASKベースのバリデーターと呼ばれます。 sh:validatorの値は、ASKベースのバリデーターでなければなりません。 ASKベースのバリデーターは、プロパティ sh:askの値を正確に1つ持ちます。 sh:askの値は、データ型xsd:stringを持つリテラルでなければなりません。 sh:askの値は、前述の接頭辞処理規則を使用する有効なSPARQL ASKクエリでなければなりません。

この節の残りは非規範的です。

ASKクエリは、指定された値ノード（事前束縛された変数valueによって表されます）が制約に適合する場合、かつその場合に限りtrueを返します。

次の例は、ASKクエリを使用して制約コンポーネントを宣言します。

例 8: SPARQL に基づく制約コンポーネント

ex:LanguageConstraintComponentUsingASK a sh:ConstraintComponent ; rdfs:label "Language constraint component" ; sh:parameter [ sh:path ex:lang ; sh:datatype xsd:string ; sh:minLength 2 ; sh:name "language" ; sh:description "The language tag, e.g. \"de\"." ; ] ; sh:labelTemplate "Values are literals with language \"{$lang}\"" ; sh:validator ex:hasLang . ex:hasLang a sh:SPARQLAskValidator ; sh:message "Values are literals with language \"{$lang}\"" ; sh:ask """ ASK { FILTER (isLiteral($value) && langMatches(lang($value), $lang)) } """ .

{
	"@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 ベースの制約コンポーネントのバリデーターを定義します。このバリデーターは、考えられる実装戦略の 1 つを説明するにすぎず、 SHACL プロセッサーは、結果が同等である限り、別の方法を選択できます。

最初のステップとして、バリデーターを、MUST の要件に従い、以下に示す規則に基づいて選択しなければなりません。 4.2.3 バリデーター。次に、以下の規則を適用し、SPARQL クエリーの解の集合を生成します。

ASK ベースのバリデーターの場合： SPARQL ASK クエリーが false を返す各値ノード v について、 v が変数 value に事前バインドされている場合、バインディングからなる 1 つの解を作成します。 ($this, フォーカスノード) および ($value, v) です。 QS をこれらの解のリストとします。
SELECT ベースのバリデーターの場合：シェイプがプロパティシェイプである場合、実行前に、トリプルパターンの述語の位置に現れる変数 PATH を置換します。トリプルパターンの述語位置に、有効な SPARQL 表層構文文字列として表現されたSHACL プロパティパスを使用します。このパスは、sh:path を介してプロパティシェイプで指定されます。 QS を SPARQL クエリーの実行によって生成された解とします。

上記の SPARQL クエリーの実行では、変数 this を事前バインドしなければなりません（MUST）。その方法は、3.3.1 SPARQL 制約における事前バインドされた変数 $thisで説明されています。さらに、制約における制約コンポーネントの各パラメーターの値は、パラメーター名を名前とする変数として、 MUST 事前バインドされなければなりません。

検証結果の生成規則は、 SPARQL ベースの制約の生成規則と同一であり、上記で生成された解 QS を使用します。

この節では、一般的な仕組みを拡張し、 SPARQL ベースの制約または制約コンポーネントを使用して検証結果を生成します。

この機能のサポートは、SHACL-SPARQL 検証プロセッサーでは任意（OPTIONAL）です。1.3 適合性を参照してください。この機能をサポートするプロセッサーでは、注釈プロパティを、 SPARQL ベースの制約または制約コンポーネントの SELECT クエリーによって生成された各解に対して作成される検証結果ノードに追加できます。このような注釈プロパティは、sh:select または sh:ask のトリプルの主語において、 sh:resultAnnotation の値を介して宣言する必要があります。

sh:resultAnnotation の値は、結果注釈と呼ばれ、IRIまたは空白ノードです。

結果注釈には、次のプロパティがあります。

プロパティ	概要と構文規則
`sh:annotationProperty`	設定するプロパティ。各結果注釈は、プロパティ `sh:annotationProperty` に対してちょうど 1 つの値を持ち、その値はIRIです。
`sh:annotationVarName`	注釈値の取得元となる SPARQL 変数の名前。各結果注釈は、プロパティ `sh:annotationVarName` に対して最大 1 つの値を持ち、この値は、データ型が `xsd:string` のリテラルです。
`sh:annotationValue`	デフォルト値として使用する定数のRDF 用語。

SELECT 結果集合の各解について、注釈をサポートする SHACL プロセッサーは、宣言された結果注釈を順に処理します。結果注釈から SPARQL 変数へのマッピングには、次の規則を使用します。

プロパティ sh:annotationVarName の値を使用します。
そのような値が存在しない場合は、sh:annotationProperty の値のローカル名を変数名として使用します。

変数名を決定できた場合、SHACL プロセッサーは、指定された変数のバインディングを、 sh:annotationProperty を使用して指定されたプロパティの値として、現在の解に対して生成中の検証結果にコピーします。結果集合の解において、変数にバインディングがない場合は、 sh:annotationValue の値が存在すれば、それを使用します。

例 9：結果注釈の使用例

ex:AnnotationExample a sh:NodeShape ; sh:targetNode ex:ExampleResource ; sh:sparql [ # _:b1 sh:resultAnnotation [ sh:annotationProperty ex:time ; sh:annotationVarName "time" ; ] ; sh:select """ SELECT $this ?message ?time WHERE { BIND (CONCAT("The ", "message.") AS ?message) . BIND (NOW() AS ?time) . } """ ; ] .

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

[ a sh:ValidationReport ; sh:conforms false ; sh:result [ a sh:ValidationResult ; sh:focusNode ex:ExampleResource ; sh:resultMessage "The message." ; sh:resultSeverity sh:Violation ; sh:sourceConstraint _:b1 ; sh:sourceConstraintComponent sh:SPARQLConstraintComponent ; sh:sourceShape ex:AnnotationExample ; ex:time "2015-03-27T10:58:00"^^xsd:dateTime ; # 例 ] ] .

{
    "@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 に対してちょうど 1 つの値を持ち、その値がデータ型 xsd:string のリテラルである場合です。整形式の選択式は、プロパティ sh:prefixes に対して最大 1 つの値を持つことができ、その値はIRIまたは空白ノードに限られます。

接頭辞の処理規則を使用すると、sh:select の値は有効な SPARQL 1.2 SELECT クエリーになります。 sh:select の値から導出された SPARQL クエリーは、SELECT 句でちょうど 1 つの変数を射影します。

SELECT 式の評価

選択式の出力ノードは、リスト resultNodes であり、クエリーがフォーカスグラフに対して評価されたときに、SELECT 句から射影される（唯一の）変数のバインディングのみで構成されます。 focusNode の値は、SPARQL 変数 this の値として事前バインドされます。スコープ内の各変数の値は、同じ名前と値を持つ SPARQL 変数として事前バインドされます。スコープ内の変数名が文字列リテラルでない場合は、"arg" + str(name) を使用します。例えば、変数名が "0"^^xsd:integer の場合は、arg0 を使用します。スコープ内の変数のいずれかが this という名前である場合、またはこの方法で導出された変数名が有効な SPARQL VARNAME でない場合、失敗が生成されます。

evalExpr(expr, focusGraph, focusNode, scope) -> resultNodes

この節の残りの部分は非規範的です。

例 10：SPARQL クエリーに基づくノード式を使用した動的に計算されるプロパティ

これは選択式の使用例であり、プロパティ「フルネーム」のプロパティシェイプの値を、 ex:firstName、スペース、および ex:lastName の連結として計算します。

ex:Person-fullName a sh:PropertyShape ; sh:name "full name" ; sh:path ex:fullName ; sh:values [ sh:prefixes ex: ; sh:select """ SELECT ?fullName WHERE { $this ex:firstName ?firstName . $this ex:lastName ?lastName . BIND (CONCAT(?firstName, " ", ?lastName) AS ?fullName) . } """ ] ; sh:datatype xsd:string . ex: a owl:Ontology ; sh:declare [ sh:prefix "ex" ; sh:namespace "http://example.com/ns#"^^xsd:anyURI ; ] .

{
    "@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 に事前バインドして実行されることに注意してください。

例 11：SPARQL クエリーに基づくノード式を使用した動的に計算されるターゲットノード

これは選択式の使用例であり、 ex:age が 18 未満である ex:Person のすべてのインスタンスをシェイプのターゲットノードとして計算します。

ex:ChildShape a sh:NodeShape ; rdfs:label "Child shape" ; rdfs:comment "This shape applies to all persons under 18 years of age." ; sh:targetNode [ sh:select """ PREFIX ex: <http://example.com/ns#> SELECT ?person WHERE { ?person a/rdfs:subClassOf* ex:Person . ?person ex:age ?age . FILTER (?age < 18) . } """ ] .

{
    "@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 だけがターゲットノードです。

ex:Benjamin a ex:Person ; ex:age 17 . ex:Klaus a ex:Person ; ex:age 48 . ex:Bernd a ex:Person .

{
    "@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 の値を持つものを、関数名 sh:SPARQLExprExpression を持つSPARQL expr 式と呼びます。

RDF グラフ内のノードが整形式の SPARQL expr 式であるのは、それが空白ノードであり、値を述語 sh:sparqlExpr に対してちょうど 1 つ持ち、その値がリテラルであり、そのデータ型が xsd:string である場合です。整形式の SPARQL expr 式は、プロパティ sh:prefixes に対して最大 1 つの値を持つことができ、この値は IRI または空白ノードです。

$EXPR$ を sh:sparqlExpr の値とし、 $PREFIXES$ を sh:prefixes の値を使用する接頭辞処理規則から得られる SPARQL 接頭辞ブロックとします。このとき、select は $EXPR$ と $PREFIXES$ を次のように挿入した文字列として定義されます。

$PREFIXES$ SELECT ($EXPR$ AS ?result) WHERE {}

select は有効な SPARQL 1.2 SELECT クエリです。

SPARQL EXPR 式の評価

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

このセクションの残りは非規範的です。

例 12: SPARQL expr 式を使用した動的に計算されるプロパティ

これは、フォーカスノードの IRI の長さとして、プロパティ "uri length" のプロパティシェイプの値を計算する、 SPARQL expr 式の使用例です。

ex:Resource-uriLength a sh:PropertyShape ; sh:name "uri length" ; sh:path ex:uriLength ; sh:values [ sh:sparqlExpr "STRLEN(STR($this))" ; ] ; sh:datatype xsd:integer .

{
	"@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 になります。これは次の変形と同じ結果を生成します:

ex:Resource-uriLength a sh:PropertyShape ; sh:name "uri length" ; sh:path ex:uriLength ; sh:values [ sh:select """ SELECT (STRLEN(STR($this)) AS ?result) WHERE { } """ ; ] ; sh:datatype xsd:integer .

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

クエリは、現在のフォーカスノードが変数 this に事前バインドされた状態で実行されることに注意してください。

SHACL 1.2 ノード式は、新しいノード式関数を宣言する仕組みとしてカスタムリストパラメーター関数を定義しています。これらは他の SHACL ノード式の一部として評価できますが、関数形式の実行をサポートする他のエンジンでも役立つ場合があります。

SPARQL 仕様は、特定の SPARQL エンジンが追加の SPARQL 関数を提供できるようにする拡張ポイントを定義しています。この節では、SPARQL プロセッサーがこの拡張ポイントを使用して SHACL リストパラメーター関数を SPARQL 関数として利用可能にするための宣言的な仕組みを紹介します。

例 13：shnex: ノード式を使用するカスタム関数の例

この関数は、クラスを（唯一の）パラメーターとして受け取り、そのクラスのインスタンス数を返します。

ex:instanceCount a sh:ListParameterExpressionFunction ; rdfs:label "instance count"@en ; rdfs:subClassOf sh:ListParameterExpression ; sh:bodyExpression [ shnex:count [ shnex:instancesOf [ shnex:arg 0 ] ] ] ; sh:parameter [ a sh:Parameter ; sh:path shnex:arg0 ; sh:name "class" ; sh:description "The class to count the instances of." ; sh:nodeKind sh:IRI ; ] .

{
    "@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 クエリーを使用します。

例 14：sh:sparqlExpr を使用するカスタム関数の例

この関数は 2 つのパラメーターを受け取り、SPARQL expr 式を本体式として使用します。その SPARQL 式では、変数 $arg0 と $arg1 を使用して、リストパラメーターの値にアクセスします。これは、SPARQL 式の代わりに sparql:concat ノード式関数を使用する [shacl12-node-expr] の ex:spacedConcat の例の変種です。

ex:spacedConcat a sh:ListParameterExpressionFunction ; rdfs:label "spaced concat"@en ; rdfs:subClassOf sh:ListParameterExpression ; sh:bodyExpression [ sh:sparqlExpr "CONCAT($arg0, ' ', $arg1)" ] ; sh:parameter [ a sh:Parameter ; sh:path shnex:arg0 ; sh:name "first string" ; sh:description "The first string to concatenate." ; sh:datatype xsd:string ; ] ; sh:parameter [ a sh:Parameter ; sh:path shnex:arg1 ; sh:name "second string" ; sh:description "The second string to concatenate." ; sh:datatype xsd:string ; ] .

{
    "@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 ノード式を本体として使用します。

例 15：sh:select を使用するカスタム関数の例

この関数は 2 つのパラメーターを受け取り、そのうち 2 番目は任意であり、選択式を本体式として使用します。その SPARQL クエリーでは、変数 $arg0 と $arg1 を使用してリストパラメーターの値にアクセスします。

ex:langLabelCount a sh:ListParameterExpressionFunction ; rdfs:label "lang label count"@en ; rdfs:subClassOf sh:ListParameterExpression ; sh:bodyExpression [ sh:select """ PREFIX ex: <http://example.com/ns#> PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#> SELECT (COUNT(?label) AS ?result) WHERE { ?predicate rdfs:subPropertyOf* rdfs:label . $arg0 ?predicate ?label . BIND (COALESCE($arg1, 'en') AS ?matchLang) . FILTER langMatches(lang(?label), ?matchLang) . } """ ; ] ; sh:parameter [ a sh:Parameter ; sh:path shnex:arg0 ; sh:name "subject" ; sh:description "The subject node to get the label count of." ; sh:nodeKind sh:IRI ; ] ; sh:parameter [ a sh:Parameter ; sh:path shnex:arg1 ; sh:name "match language" ; sh:description "The language to filter, defaulting to 'en'." ; sh:datatype xsd:string ; sh:defaultValue "en" ; sh:optional true ; ] .

{
    "@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 関数の評価を参照）、それ以外の宣言は文書化を目的としています。

ex:Cougar rdfs:label "Cougar"@en ; rdfs:label "Mountain Lion"@en-US ; rdfs:label "Puma"@de . # SPARQL 関数呼び出しの例： # ex:langLabelCount(ex:Cougar, 'en') = 2 # ex:langLabelCount(ex:Cougar) = 2 # ex:langLabelCount(ex:Cougar, 'de') = 1 # ex:langLabelCount(?unbound, 'en') = 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 インスタンスに対して関数を登録することが推奨されます（SHOULD）。同じIRIを持つ関数が、組み込み関数またはその他の非カスタム関数としてすでに登録されている場合、 SPARQL エンジンは再定義の試みを無視しなければなりません（MUST）。登録済みの関数自体が、以前に提供されたシェイプグラフなどに由来するカスタム SPARQL 関数である場合、新しい宣言がそれを置き換えます。 SPARQL エンジンは、SPARQL クエリーの実行中に登録済みの SPARQL 関数を変更してはなりません（MUST NOT）。

カスタム SPARQL 関数の評価

f を SPARQL 関数呼び出しの iri、 args を Expression 引数のリストとします。 function を、対応するカスタムリストパラメーター関数とします。この関数は、グラフ内で定義され、f をそのIRIとして持ちます。

args 内の各 SPARQL 式を評価し、新しいノードのリスト nodesList を生成します。評価によってエラーが発生した場合、SPARQL 関数呼び出しの結果もエラーになります。ただし、対応する引数の sh:parameter に sh:optional true が指定されている場合は例外です。その場合、引数はスコープ内でバインドされません。空白ノードは引数として渡せないことに注意してください。これらは定数ノード式ではないため、空白ノードに評価される引数は評価失敗を引き起こし、したがってエラーになります。

rs を evalExpr(function, focusGraph, f, scope) の出力ノードとします。ここで、focusGraph は SPARQL コンテキストで現在有効なクエリーグラフであり、 scope は nodesList の評価済み引数を、引数のインデックスを変数名（マップのキー）として対応付けたマップです。

出力ノードのリスト rs に要素がちょうど 1 つある場合、そのノードを返します。それ以外の場合、または評価によって評価失敗が発生した場合、 SPARQL 関数呼び出しの結果はエラーになります。

注記

SPARQL クエリーの評価中には、専用のフォーカスノードは存在しません。代わりに、ノード式に基づくカスタム SPARQL 関数に渡される focusNode は、関数自体のIRIです。

この節では、この文書のすべての規範的な構文規則を列挙します。この節は、この仕様の他の部分から自動的に生成されており、規則の文脈が不明確な場合に本文へ戻れるようハイパーリンクが提供されています。シェイプグラフ内でこれらの規則に違反するノードは不正形式です。

構文規則 ID	構文規則のテキスト
prefix-count	接頭辞宣言は、プロパティ `sh:prefix` に対してちょうど 1 つの値を持ちます。
prefix-datatype	`sh:prefix` の値は、データ型がリテラルである `xsd:string` です。
namespace-count	接頭辞宣言は、プロパティ `sh:namespace` に対してちょうど 1 つの値を持ちます。
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` に対してちょうど 1 つの値を持ちます。
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` の値を最大 1 つ持つことができます。
SPARQLConstraint-severity	SPARQL ベースの制約は、プロパティ `sh:severity` の値を最大 1 つ持つことができ、この値はIRIです。
PATH-position	SPARQL ベースの制約および SELECT ベースのバリデーターの SPARQL クエリーで変数 `PATH` を合法的に使用できるのは、述語のトリプルパターン内の位置のみです。
ConstraintComponent	SPARQL ベースの制約コンポーネントは、 IRIであり、シェイプグラフ内で SHACL 型 `sh:ConstraintComponent` を持ちます。
Parameter-predicate-count	各パラメーター宣言は、プロパティ `sh:path` に対してちょうど 1 つの値を持ちます。
Parameter	パラメーター宣言では、`sh:path` の値は IRIです。
parameter-name-VARNAME	すべてのパラメーター名は、有効な SPARQL VARNAMEです。
parameter-name-not-in	パラメーター名は、次のいずれでもあってはなりません。 `this`、`path`、`PATH`、`value`、`message`、 `failure`。
parameter-name-unique	2 つ以上のパラメーター宣言が同じパラメーター名を使用する制約コンポーネントは、非整形式です。
optional-datatype	`sh:optional` の値は、データ型が `xsd:boolean` のリテラルでなければなりません。
optional-maxCount	パラメーター宣言は、プロパティ `sh:optional` の値を最大 1 つ持つことができます。
ConstraintComponent-parameter	すべての制約コンポーネントは、少なくとも 1 つの必須パラメーターを持ちます。
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` に対してちょうど 1 つの値を持ちます。
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` に対してちょうど 1 つの値を持ちます。
ask-datatype	`sh:ask` の値は、データ型が `xsd:string` のリテラルでなければなりません。
ask-sparql	`sh:ask` の値は、前述の接頭辞の処理規則を使用した有効な SPARQL ASK クエリーでなければなりません。
resultAnnotation-nodeKind	`sh:resultAnnotation` の値は、結果注釈と呼ばれ、IRI または空白ノードです。
annotationProperty	各結果注釈は、プロパティ `sh:annotationProperty` に対してちょうど 1 つの値を持ち、その値はIRIです。
annotationVarName	各結果注釈は、プロパティ `sh:annotationVarName` に対して最大 1 つの値を持ち、その値は、データ型が `xsd:string` のリテラルです。
SelectExpression-syntax	RDF グラフ内のノードが整形式の選択式となるのは、それが空白ノードであり、述語 `sh:select` に対してちょうど 1 つの値を持ち、その値がデータ型 `xsd:string` のリテラルである場合です。
SelectExpression-syntax-prefixes	整形式の選択式は、プロパティ `sh:prefixes` に対して最大 1 つの値を持つことができ、その値はIRI または空白ノードに限られます。
SelectExpression-query-valid	接頭辞の処理規則を使用すると、`sh:select` の値は有効な SPARQL 1.2 SELECT クエリーになります。
SelectExpression-query-output-nodes	`sh:select` の値から導出された SPARQL クエリーは、SELECT 句でちょうど 1 つの変数を射影します。
SPARQLExprExpression-syntax-eval	RDF グラフ内のノードが整形式の SPARQL expr 式となるのは、それが空白ノードであり、述語 `sh:sparqlExpr` に対してちょうど 1 つの値を持ち、その値がデータ型 `xsd:string` のリテラルである場合です。
SPARQLExprExpression-syntax-prefixes	整形式の SPARQL expr 式は、プロパティ `sh:prefixes` に対して最大 1 つの値を持つことができ、その値は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 プロセッサーは、事前バインドされた変数を使用して実行される SHACL-SPARQL クエリー（`sh:ask`、`sh:construct`、 `sh:select` および `sh:sparqlExpr` を介したもの）を含むシェイプグラフを処理する際、これらの「MUST」制限のいずれかに違反する場合は、失敗を報告しなければなりません。「事前バインドされる可能性のある変数」には、変数 `this`、 `value`（ASK クエリーの場合）、クエリーを使用する制約コンポーネントのパラメーターを表す任意の変数、およびSPARQL ベースのノード式のスコープ変数を表す変数（`arg0` など）が含まれることに注意してください。 SPARQL クエリーには `MINUS` 句を含めてはなりません（MUST）。 SPARQL クエリーには、事前バインドされる可能性のある変数に言及する `VALUES` 句を含めてはなりません（MUST）。 SPARQL クエリーでは、事前バインドされる可能性のある変数に対して `AS ?var` という構文形式を使用してはなりません（MUST）。さらに、SPARQL クエリーには連合クエリーを含めるべきではありません（SHOULD）。（`SERVICE`）。 `SERVICE` を許可しない実装は、上記のように失敗を報告しなければなりません（MUST）。ただし、一部の SPARQL 実装では `SERVICE` キーワードを特定の（通常はローカルな）操作の構文として使用しているため、このキーワードは一般的には禁止されていません。

この節は非規範的です。

この付録では、制約コンポーネントおよびターゲットの意味論について、 [shacl12-core] にある非規範的な代替定義で SPARQL 1.2 の一部を使用します。これらは一部の実装者に役立つ場合がありますが、SHACL コア言語の実装に SPARQL は必要ありません。

sh:targetClass および sh:class の定義では、 rdfs:subClassOf トリプルをデータグラフ内でのみ検索します。プロセッサーパラメーター subClassOfInShapesGraph が設定されている場合は、シェイプグラフの rdfs:subClassOf トリプルも考慮する必要があります。

$マーカーを使用するSPARQL変数は、外部の束縛を表し、これらは事前に束縛されるか、$PATHの場合には、置換される。これらの処理はSPARQLクエリの実行前に行われる（詳しくは3.3 次を用いた検証： SPARQLベースの制約で説明されている）。

次のクエリは、クラスターゲットのSPARQLによる定義の候補を表す。変数targetClassは、事前束縛され、その対象は指定された sh:targetClassの値となる。すべての束縛のうち、変数thisについて解から得られるものは、すべてフォーカスノードになる。

SPARQLにおける可能な定義

SELECT DISTINCT ?this    # ?thisはフォーカスノード
WHERE {
	?this rdf:type/rdfs:subClassOf* $targetClass .
}

次のクエリーは、SPARQL における主語ターゲットの定義候補を表します。変数 targetSubjectsOf は、指定された事前バインドによって sh:targetSubjectsOf の値に結び付けられます。バインディングのうち、解から得られる変数 this のすべてがフォーカスノードになります。

SPARQLにおける可能な定義

SELECT DISTINCT ?this    # ?thisはフォーカスノード
WHERE {
	?this $targetSubjectsOf ?any .
}

次のクエリは、オブジェクトターゲットのSPARQLによる定義の候補を表す。変数targetObjectsOfは、事前束縛され、その対象は指定された sh:targetObjectsOfの値となる。すべての束縛のうち、変数thisについて解から得られるものは、すべてフォーカスノードになる。

SPARQLにおける可能な定義

SELECT DISTINCT ?this    # ?thisはフォーカスノード
WHERE {
	?any $targetObjectsOf ?this .
}

次のクエリーは、sh:classの SPARQLベースの可能なバリデーターを表す。