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 Extensions は、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 プロパティパス、 SPARQL プロパティパス、データグラフ、シェイプグラフ、ターゲット、バリデーター、ノード式、ノード式関数、関数名、出力ノード、フォーカスグラフ、適合する、失敗、検証結果、 SHACL インスタンス、 SHACL サブクラス、 SHACL スーパークラス、 SHACL 型、整形式、不正形式、という用語を、SHACL 1.2 Core 仕様 [shacl12-core] で定義されているとおりに使用します。

バインディング、解

バインディングとは、(変数, 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#`

この文書内では、次の 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#"
  }
}

SHACL 語彙自体を定義するグラフの URI は、上記の名前空間と同等であり、つまり # を含むことに注意してください。たとえば owl:imports による SHACL 語彙への参照には、# を含めるべきです。

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

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

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

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

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

{
	"@graph": [
	]
}

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

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

{}

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

SPARQL またはテキスト定義

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

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

$ マーカーを使用する SPARQL 変数は、実行前に事前バインドされる、または $PATH の場合は (4.3 SPARQL ベースの制約コンポーネントによる検証で説明されるように) SPARQL クエリ内で置換される外部バインディングを表します。

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

非規範的とマークされたセクションに加えて、この仕様のすべての作成ガイドライン、図、例、および注記は非規範的です。この仕様のそれ以外のすべては規範的です。

この文書におけるキーワードしてもよい、しなければならない、してはならない、およびすべきであるは、ここに示すように、すべて大文字で表記されている場合に限り、 BCP 14 [RFC2119] [RFC8174] に記述されているとおりに解釈されるものとします。

この文書は、SHACL Core を拡張する SHACL-SPARQL 言語を定義します。この仕様は、次のものに対する適合基準を説明します:

SHACL-SPARQL 検証プロセッサーは、 3. SPARQL ベースの制約および 4. SPARQL ベースの制約コンポーネントを用いた SHACL 検証をサポートするプロセッサーとして
SPARQL ノード式プロセッサーは、 6. SPARQL ベースのノード式を評価できるプロセッサーとして
SPARQL カスタム関数プロセッサーは、 7. Node Expressions に基づく SPARQL 関数の宣言を評価できるプロセッサーとして

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

この節では、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ベースの制約またはバリデーターの SPARQLプロパティパス sh:prefixes/(^owl:versionIRI?/owl:imports)*/sh:declareの値であるすべての個別の接頭辞マッピングの和集合として、接頭辞マッピングの集合を収集します。 ^owl:versionIRI?要素は、 owl:versionIRI によってインポートされるグラフをサポートし、後続のowl:importsをたどる前に、バージョンIRIからシェイプグラフIRIへ移動します。このように収集された接頭辞宣言に、sh:prefixの同じ値に対する複数の異なる名前空間が含まれる場合、シェイプグラフは非整形式です。（SHACLプロセッサは、到達されない接頭辞宣言を無視してもよいことに注意してください）。

SPARQL クエリーに sh:prefixes の値がない場合、システムは、 owl:Ontology、sh:DataGraph、sh:ShapesGraph、または sh:RulesGraph（sh:ShapesGraph のサブクラス）の SHACL インスタンスにおいて sh:declare の値である、シェイプグラフからのプレフィックス宣言を使用します。

SHACLプロセッサは、すべての接頭辞マッピングに対応する PREFIX宣言を先頭に追加して、 sh:selectの値（およびsh:askやsh:constructなどの同様のプロパティ）を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ベースの制約の構文を示しています。

例 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

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ベースの制約およびSELECTベースのバリデーターのSPARQLクエリにおいて、変数PATHを合法的に使用できる唯一の場所は、トリプルパターンの述語の位置です。変数PATHを他の位置で使用するクエリは、非整形式です。

この節では、sh:SPARQLConstraintComponentのバリデーターについて説明します。このバリデーターは、考えられる実装戦略の1つだけを説明するものであり、結果が同等である限り、SHACLプロセッサは別の方法を選択できることに注意してください。

テキストによる定義

$sparqlをsh:sparqlの値とします。 SPARQLベースの制約が、プロパティ sh:deactivatedの値としてtrueを持つ場合、検証結果はありません。それ以外の場合は、3.3.1 SPARQL制約における事前束縛変数$thisで説明されているように、変数thisを事前束縛し、SPARQLベースの制約$sparqlで指定されたSPARQLクエリを実行します。シェイプがプロパティシェイプである場合、実行前に、述語の位置に現れる変数PATHを、プロパティシェイプのsh:pathによって指定された SHACLプロパティパスの有効なSPARQL表層構文文字列で置換します。変数failureの束縛としてtrueを持たない各解に対して、1つの検証結果があります。これらの検証結果は、3.3.2 解の束縛から結果プロパティへのマッピングで説明されているプロパティ値を持たなければならない。 $sparqlがsh:severityの値を持つ場合、検証結果は、その値を唯一のsh:resultSeverityとして持たなければならない。いずれかの解が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`の値

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" ; # 大文字と小文字を区別しない照合 ] .

{
  "@graph": [
    {
      "@id": "ex:CaseInsensitiveSearch",
      "@type": "sh:NodeShape",
      "sh:property": {
        "@type": "sh:PropertyShape",
        "sh:path": { "@id": "ex:code" },
        "sh:pattern": "^[A-Z]{3}[0-9]{2}$",
        "sh:flags": "i"
      }
    }
  ]
}

制約コンポーネントは、シェイプ内の制約を識別して検証する方法を、検証エンジンに指示します。一般に、シェイプ 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。 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の値は文字列（言語タグが付く場合があります）です。これらはラベルテンプレートと呼ばれます。

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

ラベルテンプレートには、制約コンポーネントに対して宣言されたパラメーターの名前を、{?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 の値は、前述の接頭辞処理規則を使用する有効な 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:LanguageConstraintComponent を使用したシェイプ宣言

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プロセッサは別の方法を選択できることに注意してください。

最初の手順として、4.2.3 バリデーターで説明されている規則に基づいて、バリデーターを選択 しなければならない。次に、以下の規則を適用して、SPARQLクエリの解の集合を生成します。

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

上記のSPARQLクエリの実行では、3.3.1 SPARQL制約における事前束縛変数$thisで説明されているように、変数thisを事前束縛しなければならない。さらに、制約内の制約コンポーネントのパラメーターの各値は、パラメーター名を名前として持つ変数として、事前束縛しなければならない。

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

プロパティ	概要と構文規則
`sh:annotationProperty`	設定されるべきプロパティ。各結果注釈は、プロパティ `sh:annotationProperty` に対して正確に 1 つの値を持ち、この値は IRIです。
`sh:annotationVarName`	注釈値を取得する SPARQL 変数の名前。各結果注釈は、プロパティ `sh:annotationVarName` に対して高々 1 つの値を持ち、この値はデータ型 `xsd:string` を持つリテラルです。
`sh:annotationValue`	既定値として使用されるべき定数の RDF 用語。

この節では、SPARQLに基づくノード式関数を導入します。

sh:select の値を持つノード式は、関数名 sh:SelectExpression を持つ select 式と呼ばれます。

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

プレフィックス処理規則を使用すると、sh:select の値は有効な SPARQL 1.2 SELECT クエリです。 sh:select の値から導出される SPARQL クエリは、SELECT 句で正確に 1 つの変数を射影します。

SELECT 式の評価

output nodes は、select expression の resultNodes のリストであり、クエリを focus graph に対して評価したときに、 SELECT 句から射影される（唯一の）変数の束縛だけから構成されます。 focusNode の値は、SPARQL 変数 this の値として pre-bound されます。各スコープ変数の値は、同じ名前と値を持つ SPARQL 変数として pre-bound されます。スコープ内の変数名が文字列リテラルでない場合は、"arg" + str(name) を使用します。たとえば、変数名が "0"^^xsd:integer なら、arg0 を使用します。スコープ変数の 1 つが this という名前の場合は、 failure が生成されます。

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

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

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

これは、プロパティ "full name" のプロパティシェイプの値を、ex:firstName、スペース、および ex:lastName の連結として計算する、 select 式の使用例です。

ex:Person-fullName a sh:PropertyShape ; sh:name "full name" ; sh:path ex:fullName ; sh:values [ sh:prefixes <http://example.com/ns> ; sh:select """ SELECT ?fullName WHERE { $this ex:firstName ?firstName . $this ex:lastName ?lastName . BIND (CONCAT(?firstName, " ", ?lastName) AS ?fullName) . } """ ] ; sh:datatype xsd:string . <http://example.com/ns> 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"
			}
		}
	]
}

この例は、解析前にクエリの先頭へ PREFIX 宣言を挿入するための sh:prefixes の使用も示しています。クエリは、現在のフォーカスノードが変数 this に事前バインドされた状態で実行されることに注意してください。

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

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

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 式の評価

output nodes は、SPARQL expr expression の resultNodes のリストであり、 select クエリの SELECT 句から投影される（唯一の）変数の束縛だけから構成されます。これは above で定義されたとおり、クエリを focus graph に対して評価したときに適用されます。 focusNode の値は、SPARQL 変数 this の値として pre-bound されます。各スコープ変数の値は、同じ名前と値を持つ SPARQL 変数として pre-bound されます。スコープ内の変数名が文字列リテラルでない場合は、"arg" + str(name) を使用します。たとえば、変数名が "0"^^xsd:integer なら、arg0 を使用します。スコープ変数の 1 つが this と呼ばれる場合は、 failure が生成されます。

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 Node Expressions はカスタム List Parameter Functions を、新しい node expression 関数を宣言するための仕組みとして定義しています。これらは他の SHACL node expression の一部として評価できますが、関数のような実行をサポートする他のエンジンにとっても有用である場合があります。

SPARQL 仕様は、いくつかの SPARQL エンジンが追加の SPARQL 関数を提供できるようにする拡張ポイントを定義しています。この節では、その拡張ポイントを用いて、SPARQL プロセッサーが SHACL の list parameter functions を SPARQL 関数として利用可能にするための宣言的な仕組みを導入します。

Example 13: shnex: node expressions を用いたカスタム関数の例

この関数は 1 つの引数としてクラスを受け取り、そのクラスのインスタンス数を返します。

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 ; ] .

ノード式に基づく SPARQL 関数をサポートする SPARQL エンジンは、次のような SPARQL クエリを処理できます:

SELECT ?class ?count
WHERE {
	?class a owl:Class .
	BIND (ex:instanceCount(?class) AS ?count) .
}

次のカスタム list parameter functions は、評価時に「入れ子になった」SPARQL クエリを使用します。

Example 14: sh:sparqlExpr を用いたカスタム関数の例

この関数は 2 つの引数を受け取り、SPARQL expr expression を本体式として使用します。その SPARQL 式では、$arg0 と $arg1 という変数が list parameter の値へアクセスするために使われます。

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 ; ] .

ノード式に基づく 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 node expression を使用します。

Example 15: sh:select を用いたカスタム関数の例

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 ; ] .

この関数は、sh:optional true トリプルで宣言される任意の引数を受け付けます。ただし、sh:parameter 宣言からの SHACL 制約は自動的には強制されず、宣言された sh:defaultValue も実行時には使用されません。これらは主として文書化のために用いられます。

この文書では、そのようなカスタム SPARQL 関数がいつ、どのように追加されるかについての厳密な制約は定義しません。推奨は、SPARQL エンジンが、提供された任意の SHACL instance of sh:ListParameterExpressionFunction を、その shapes graph 内に対して登録すべきだというものです。同じ IRI を持つ関数がすでに登録されている場合、 SHACL エンジンは、その関数が以前にカスタム SPARQL 関数として追加されたものでない限り、それを再定義しようとする試みを無視しなければなりません。 SPARQL エンジンは、SPARQL クエリを実行している間は登録済みの SPARQL 関数を変更してはなりません。

カスタム SPARQL 関数の評価

f を SPARQL function call の iri とし、 args を Expression 引数のリストとします。 function を、f をその IRI として定義した graph 内の対応するカスタム list parameter function とします。

args から各 SPARQL 式を評価し、新しい nodes のリスト nodesList を得ます。評価で error が発生した場合、対応する引数の sh:parameter が sh:optional true を持つのでない限り、 SPARQL 関数呼び出しの結果も error になります。その場合、その引数は scope 内で unbound になります。

rs を、focusGraph が SPARQL コンテキストで現在アクティブな query graph であり、 scope が nodesList から評価済み引数を、引数の index を変数名（map key）として持つ map であるときの evalExpr(function, focusGraph, f, scope) の output nodes とします。

出力ノードのリスト rs がちょうど 1 つの要素を持つ場合、そのノードを返します。それ以外の場合、または評価が evaluation failure を生じる場合、SPARQL 関数呼び出しの結果は error になります。

Note

SPARQL クエリの評価中には、専用の focus node はありません。代わりに、node expression に基づく custom SPARQL function に渡される 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	SHACL プロセッサーは、SPARQL ベースの制約またはバリデーターの SPARQL プロパティパス `sh:prefixes/(^owl:versionIRI?/owl:imports)*/sh:declare` の値であるすべての個別の接頭辞マッピングの和集合として、接頭辞マッピングの集合を収集します。 `^owl:versionIRI?` 要素は、 `owl:versionIRI` によってインポートされたグラフをサポートし、さらに `owl:imports` をたどる前に、バージョン IRI からシェイプグラフ IRI へ移動します。このような接頭辞宣言の集合に、同じ `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`。
parameter-name-unique	2 つ以上のパラメーター宣言が同じパラメーター名を使用する制約コンポーネントは不正形式です。
optional-datatype	`sh:optional` の値は、データ型 `xsd:boolean` のリテラルでなければなりません。
optional-maxCount	パラメーター宣言は、プロパティ `sh:optional` に対して最大 1 つの値を持つことができます。
ConstraintComponent-parameter	すべての制約コンポーネントは、少なくとも 1 つの非任意パラメーターを持ちます。
Parameter-conformance	パラメーターに対して宣言された制約に適合しないシェイプは不正形式です。
labelTemplate-datatype	`sh:labelTemplate` の値は文字列です（言語タグを持つ場合があります）
nodeValidator-class	`sh:nodeValidator` の値は、SELECT ベースのバリデーターでなければなりません。
propertyValidator-class	`sh:propertyValidator` の値は、SELECT ベースのバリデーターでなければなりません。
SPARQLSelectValidator-select-count	SELECT ベースのバリデーターは、プロパティ `sh:select` に対してちょうど 1 つの値を持ちます。
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 グラフ内のノードが整形式のselect 式であるのは、それが空白ノードであり、述語 `sh:select` に対してちょうど 1 つの値を持ち、この値が、データ型 `xsd:string` のリテラルである場合です。
SelectExpression-syntax-prefixes	整形式の select 式は、プロパティ `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` を介したもの）を含むシェイプグラフを処理している場合、失敗を報告しなければなりません。事前バインドされる可能性のある変数という用語には、変数 `this`、 `value`（ASK クエリの場合）、およびそのクエリを使用する制約コンポーネントのパラメーターを表す任意の変数が含まれることに注意してください。 SPARQL クエリは `MINUS` 節を含んではなりません SPARQL クエリは、事前バインドされる可能性のある変数に言及する `VALUES` 節を含んではなりません SPARQL クエリは、事前バインドされる可能性のある変数に対して構文形式 `AS ?var` を使用してはなりませんさらに、SPARQL クエリにはフェデレーテッドクエリ（`SERVICE`）を含めるべきではありません。 `SERVICE` を許可しない実装は、上記のように失敗を報告しなければなりません。ただし、一部の SPARQL 実装では `SERVICE` キーワードを特定の（通常はローカルな）操作の構文として使用していることが認識されているため、このキーワードは一般的には禁止されません。

この節は非規範的です。

この附属書では、[shacl12-core]の制約コンポーネントおよびターゲットのセマンティクスについて、非規範的な代替定義でSPARQL 1.2の一部を使用する。これらは一部の実装者に役立つ可能性があるが、SHACL Core言語の実装にSPARQLは必須ではない。

$マーカーを使用するSPARQL変数は、実行前にSPARQLクエリー内で事前束縛される外部束縛、または $PATHの場合は置換される外部束縛を表す（4.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ベースの可能なバリデーターを表す。