SHACL 1.2 コア

要約

この文書は、SHACL のコアを定義する。

SHACL、すなわち Shapes Constraint Language は、RDF グラフの構造を記述するための言語である。 SHACL は、クラスおよびそれらのクラスのインスタンスが持つことができるプロパティを定義するために使用できる。クラスおよびインスタンスよりも一般的に、SHACL は形状という概念を導入し、 RDF ノードおよびエッジの構造に対する制約を形式的に指定できるようにする。 SHACL 形状は、それ自体が形状グラフと呼ばれる RDF グラフで表される。形状グラフによって記述される RDF グラフは、データグラフと呼ばれる。

SHACL は、検証、推論、ドメインのモデリング、他のエージェントに情報を与えるためのオントロジー生成、ユーザーインターフェイスの構築、コード生成、およびデータ統合など、さまざまな目的に使用できる。

接頭辞	名前空間
`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 語彙における主要なクラスの一部の概要を示す。各ボックスはクラスを表す。クラス名の下にあるボックスは、これらのクラスのインスタンスが持つ可能性のあるよく使われるプロパティの小さな部分集合を、その値型とともに列挙している。矢印は rdfs:subClassOf トリプルを示す。

sh:Shape

sh:targetClass : rdfs:Class

sh:targetNode : any

sh:targetObjectsOf : rdf:Property

sh:targetSubjectsOf : rdf:Property

sh:deactivated : xsd:boolean

sh:message : text

sh:severity : sh:Severity

sh:NodeShape

制約パラメーター、例:

sh:closed : xsd:boolean または sh:ByTypes

sh:or, sh:and, sh:xone : rdf:List

sh:not : sh:Shape

sh:property : sh:PropertyShape

sh:PropertyShape

制約パラメーター、例:

sh:minCount, sh:maxCount : xsd:integer

sh:minLength, sh:maxLength : xsd:integer

sh:class, sh:datatype : rdfs:Resource または rdfs:Resources の rdf:List

sh:node : sh:NodeShape

sh:name : xsd:string または rdf:dirLangString または rdf:langString

sh:description : text

sh:defaultValue : any

sh:values : any

sh:group : sh:PropertyGroup

sh:path : rdfs:Resource

SHACL 語彙の Turtle シリアライズには、完全な SHACL 語彙が含まれている。

形状は、IRI または空白ノード s であり、形状グラフ内で次の条件の少なくとも1つを満たすものである:

s が sh:NodeShape または sh:PropertyShape の SHACL インスタンスである。
s が、sh:targetClass、sh:targetNode、 sh:targetObjectsOf または sh:targetSubjectsOf を述語として持つトリプルの主語である。
s が、パラメーターを述語として持つトリプルの主語である。
s が、sh:node などの形状を期待する、非リスト受容のパラメーターの値であるか、または sh:or などの形状を期待するかつリスト受容のパラメーターの値である SHACL リストのメンバーである。

上記の定義には、正形式の形状に関するすべての構文規則が含まれているわけではないことに注意されたい。それらは文書全体に見られ、付録 A. SHACL 構文規則の要約にまとめられている。たとえば、sh:targetClass の値としてリテラルを持つ形状は不正形式である。

非形式的には、形状は、プロパティの値およびフォーカスノードの他の特性に基づいて、フォーカスノードをどのように検証するかを決定する。たとえば、形状は、フォーカスノードが IRI であること、またはフォーカスノードがあるプロパティについて特定の値を持ち、さらにそのプロパティについて最小数の値を持つことを条件として宣言できる。

SHACL Core 言語は、2種類の形状を定義する:

フォーカスノード自体に関する形状。これはノード形状と呼ばれる
フォーカスノードの特定のプロパティまたはパスの値に関する形状。これはプロパティ形状と呼ばれる

sh:Shape は、SHACL 語彙におけるこれら2種類の形状型の SHACL スーパークラスである。そのサブクラスである sh:NodeShape および sh:PropertyShape は、それぞれノード形状およびプロパティ形状の SHACL 型として使用できる。

形状は、制約コンポーネントのパラメーターを用いて制約を宣言できる。

制約コンポーネントは IRIである。各制約コンポーネントは、1つ以上の必須パラメーターを持ち、それぞれはプロパティである。各制約コンポーネントは、0個以上の任意パラメーターを持ち、それぞれはプロパティである。制約コンポーネントのパラメーターは、その必須パラメーターと任意パラメーターを合わせたものである。

たとえば、コンポーネント sh:MinCountConstraintComponent は、パラメーター sh:minCount を宣言し、ノードが特定のプロパティについて少なくとも最小数の値を持つという制限を表す。

必須パラメーター p1, ... pn を持つ制約コンポーネント C について、形状 s が、形状グラフ SG 内で pi について vi を値として持つとき、 s は、SG 内で必須パラメーターの値 <p1,v1>, ... <pn,vn> を持つ C という種別の制約を宣言する。任意パラメーターを持つ制約コンポーネントでは、その制約宣言は、その形状がそのコンポーネントのすべての必須および任意パラメーターについて持つ値から成る。

一部の制約コンポーネントは、単一のパラメーターのみを宣言する。たとえば sh:ClassConstraintComponent は単一のパラメーター sh:class を持つ。これらのパラメーターは同じ形状内で複数回使用でき、そのようなパラメーターの各値は個別の制約を宣言する。そのような宣言の解釈は連言、すなわちすべての制約が適用されるということである。次の例は、ex:customer の値が ex:Customer と ex:Person の両方の SHACL インスタンスでなければならないことを指定する。

例 5: 制約コンポーネントの使用例

sh:PatternConstraintComponent などの一部の制約コンポーネントは、複数のパラメーターを宣言する。そのようなコンポーネントのいずれかのパラメーターについて複数の値を持つ形状は不正形式である。

この構文規則を回避する1つの方法は、次の例に示すように、制約を複数の（プロパティ）形状に分散させることである。

例 6: 制約を複数の形状に分散できる方法の例

制約コンポーネントは、パラメーターがデータの検証にどのように使用されるかについての指示（たとえば SPARQL クエリーで表現される）を提供する検証器と関連付けられる。 RDF 項を形状に対して検証することは、その形状が制約のコンポーネントのすべての必須パラメーターについて値を持つ各制約に対して、その項を検証することを含み、それぞれのコンポーネントに関連付けられた検証器を使用する。

SHACL Core に含まれる制約コンポーネントの一覧は、第4節で説明される。 SHACL-SPARQL は、SPARQL に基づく制約コンポーネントを追加で宣言するために使用できる。

データグラフからのトリプルを用いて形状に対して検証される RDF 項は、フォーカスノードと呼ばれる。

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

形状に対するフォーカスノードの集合は、次のように識別できる:

ターゲット宣言を用いて形状内で指定される
形状を期待する制約パラメーター（例: sh:node）のパラメーターで形状を参照する任意の制約内で指定される
特定の RDF 項を形状に対して検証するために、SHACL プロセッサーへの明示的な入力として指定される

形状グラフ内の形状のターゲット宣言は、形状を主語とし、この文書で説明される特定のプロパティ（例: sh:targetClass）を述語とするトリプルである。さらに、sh:shape トリプルは、データグラフ内でターゲットを宣言できる。ターゲット宣言は、形状に対するフォーカスノードを生成するために使用できる。ターゲット宣言のターゲットは、この節の残りで説明される規則をデータグラフに適用することにより生成される RDF 項の集合である。形状のターゲットは、その形状に対して宣言された個々のターゲットによって生成されるすべての RDF 項の和集合である。

SHACL Core には、次の種類のターゲットが含まれる:

ノードターゲット
クラスベースのターゲット（暗黙のクラスベースのターゲットを含む）
subjects-of ターゲット
objects-of ターゲット
where ターゲット
明示的な形状ターゲット

この導入の残りは非規範的である。

ターゲットによって生成される RDF 項は、データグラフ内にノードとして存在することを要求されない。形状のターゲットは、その形状の検証プロセスへの入力としてフォーカスノードが直接提供される場合には無視される。これには、形状が sh:node などの形状を期待する制約パラメーターの1つの値であり、対応する制約コンポーネント（たとえば sh:NodeConstraintComponent）の検証中にフォーカスノードが決定される場合が含まれる。そのような場合、提供されたフォーカスノードは形状のターゲット内にある必要はない。

ノードターゲットは、sh:targetNode 述語を用いて指定される。形状内の sh:targetNode の各値は、正形式のノード式である。

テキスト定義

s が形状であり、形状グラフ SG 内で s が sh:targetNode について値 expr を持つ場合、 evalExpr(expr, data graph, s, {}) の出力ノードは、フォーカスグラフとしてのデータグラフ DG に対するターゲットである。

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

下の例のデータでは、提供された形状のターゲットは ex:Alice のみである:

例 7: ノードターゲットの例

クラスターゲットは、sh:targetClass 述語を用いて指定される。形状内の sh:targetClass の各値は IRIである。

テキスト定義

s が形状グラフ SG 内の形状であり、 s が SG 内で sh:targetClass について値 c を持つ場合、データグラフ DG 内における c の SHACL インスタンスの集合は、SG 内の s に対する DG からのターゲットである。

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

例 8: クラスベースのターゲットの例

この例では、ex:Alice と ex:Bob のみがフォーカスノードである。 SHACL インスタンスの定義によれば、クラス階層をたどるために必要なすべての rdfs:subClassOf 宣言はデータグラフ内に存在する必要があることに注意されたい。ただし、ex:Person a rdfs:Class トリプルは、どちらのグラフにも存在する必要はない。

次の例では、選択されるフォーカスノードは ex:Who のみである。

rdfs:subClassOf トリプルは、形状グラフから照会される場合がある（6.3 rdfs:subClassOf トリプルのためのグラフを参照）。この場合、上の例の rdfs:subClassOf トリプルはデータグラフ内にある必要はない。

非形式的には、形状が形状グラフ内でクラスでもあると宣言されている場合、このクラスのすべての SHACL インスタンスは、その形状のターゲットである。

s が RDF グラフ G 内で sh:NodeShape または sh:PropertyShape の SHACL インスタンスであり、 s が G 内で rdfs:Class の SHACL インスタンスでもあり、かつ s が IRI でない場合、s は G 内の不正形式の形状である。

テキスト定義

s が形状グラフ SG 内で sh:NodeShape または sh:PropertyShape の SHACL インスタンスであり、かつ s が SG 内で rdfs:Class の SHACL インスタンスでもある場合、データグラフ DG 内における s の SHACL インスタンスの集合は、 SG 内の s に対する DG からのターゲットである。

SHACL 名前空間には、暗黙のクラスターゲットのパターンの構文上の近道として機能できる専用クラス sh:ShapeClass が含まれる。

テキスト定義

クラス sh:ShapeClass は、 sh:NodeShape と rdfs:Class の両方の rdfs:subClassOf である。 s が形状グラフ SG 内で sh:ShapeClass の SHACL インスタンスである場合、データグラフ DG 内における s の SHACL インスタンスの集合は、 SG 内の s に対する DG からのターゲットである。

sh:ShapeClass は、SHACL を認識しない一部の実装では rdfs:Class のサブクラスであると理解されない可能性があることに留意されたい。したがって、sh:ShapeClass を使用するグラフには owl:imports sh: 文を含めることが推奨される（ただし要求はされない）。

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

次の例では、ex:Alice はフォーカスノードである。なぜなら、それは SHACL インスタンスであり、その対象である ex:Person は形状グラフ内でクラスでも形状でもあるからである。

例 10: 暗黙のクラスターゲットの例

上の例の次のバリエーションでは、ex:Person は sh:ShapeClass のインスタンスとして宣言されており、同じ解釈を持つ。

subjects-of ターゲットは、述語 sh:targetSubjectsOf を用いて指定される。形状内の sh:targetSubjectsOf の値は IRIである。

テキスト定義

s が形状グラフ SG 内の形状であり、 s が SG 内で sh:targetSubjectsOf について値 p を持つ場合、データグラフ DG 内で p を述語として持つトリプルの主語であるノードの集合は、 SG 内の s に対する DG からのターゲットである。

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

例 12: subjects-of ターゲットの例

上の例では、与えられた形状に対して検証されるのは ex:Alice のみである。なぜなら、それは ex:knows を述語として持つトリプルの主語だからである。

objects-of ターゲットは、述語 sh:targetObjectsOf を用いて指定される。形状内の sh:targetObjectsOf の値は IRIである。

テキスト定義

s が形状グラフ SG 内の形状であり、 s が SG 内で sh:targetObjectsOf について値 p を持つ場合、データグラフ DG 内で p を述語として持つトリプルの目的語であるノードの集合は、 SG 内の s に対する DG からのターゲットである。

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

例 13: objects-of ターゲットの例

上の例では、与えられた形状に対して検証されるのは ex:Bob のみである。なぜなら、それは ex:knows を述語として持つトリプルの目的語だからである。

where ターゲットは、sh:targetWhere 述語を用いて指定される。形状内の sh:targetWhere の各値は、正形式の形状である。

テキスト定義

s が形状グラフ SG 内の形状であり、 s が SG 内で sh:targetWhere について値 w を持つ場合、データグラフ DG 内で w に適合するノードの集合は、 SG 内の s に対する DG からのターゲットである。

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

例 14: where ターゲットの例

ex:AdultPerson a sh:NodeShape ; sh:targetWhere [ sh:class ex:Person ; sh:property [ sh:path ex:age ; sh:minCount 1 ; sh:minInclusive 18 ; ] ; ] ; sh:property [ sh:path ex:votedFor ; sh:class ex:Person ; sh:minCount 1 ; sh:maxCount 1 ; ] .

TODO

この例では、ex:Bob のみが ex:AdultPerson のフォーカスノードである。なぜなら、彼は sh:targetWhere 形状によって定義された2つの制約に適合するからである。 sh:class 制約に基づき、彼は ex:Person の SHACL インスタンスであり、彼の ex:age は18以上である。しかし、ex:AdultPerson 形状はすべての成人が ex:votedFor について1つの値を持たなければならないと述べているため、 ex:Bob は ex:AdultPerson に適合しない。

注

sh:targetWhere は、形状に対する必要十分条件を提供する「定義」として解釈できることに注意されたい。したがって、たとえば所与の条件集合を満たすすべてのノードを収集するなどの「分類」タスクに使用できる可能性がある。

注

注意点として、where ターゲットの計算性能は実装間で異なる可能性がある。最悪の場合、エンジンはデータグラフ内のすべてのノードを反復処理し、それらを1つずつフィルターする必要がある。

明示的な形状ターゲットは、sh:shape 述語を用いて指定される。 sh:shape の各値は IRIである。

テキスト定義

s が形状グラフ内の形状であり、 n がデータグラフ内のノードであるとする。 n がデータグラフ内で sh:shape について値 s を持つ場合、 n は s のターゲットである。

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

注

sh:shape は sh:targetNode とは異なるが、どちらも個々のノードを形状にリンクするために使用できる。 sh:shape は、特定の主語ノードから目的語である形状を指す。さらに、sh:targetNode トリプルは形状グラフから照会されるのに対し、 sh:shape トリプルはデータグラフ内にあることが期待される。

下の例のデータでは、提供された形状のターゲットは ex:Alice のみである:

例 15: sh:shape を用いた明示的な形状ターゲットの例

形状は、形状グラフ内でプロパティ sh:severity について 1つの値を指定できる。 sh:severity の各値は IRIである。

形状ごとに重大度を宣言することに加えて、プロパティ sh:severity は、形状を主語とし、制約のパラメーターの1つを述語とするトリプルの具象化子上でも使用できる。

T を、形状内の制約を表すトリプルの集合とする。形状グラフは、T 内のトリプルの具象化子内で、プロパティ sh:severity について最大1つの値を指定できる。

sh:severity の値は重大度と呼ばれる。 SHACL には、重大度を表すための、下の表に列挙される IRI が含まれる。これらは SHACL 語彙内で sh:Severity の SHACL インスタンスとして宣言されている。

重大度	説明
`sh:Trace`	制約違反ではないトレースメッセージ。
`sh:Debug`	制約違反ではないデバッグメッセージ。
`sh:Info`	情報メッセージを示す非重大な制約違反。
`sh:Warning`	警告を示す非重大な制約違反。
`sh:Violation`	制約違反。

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

検証プロセスは、適合性チェックに従って sh:severity の値を扱う。さらに、ユーザーインターフェイスツールは、その値を用いて検証結果を分類できる。 sh:severity の値は、検証結果の sh:resultSeverity フィールドを設定するために SHACL プロセッサーによって使用される。検証結果における重大度に関する節を参照。任意の IRI を重大度として使用できる。

各形状および制約について、sh:severity が指定されていない場合、 sh:Violation が既定値である。次の例はこれを示している。

例 16: 形状と制約に対して重大度を宣言する例

ex:MyShape a sh:NodeShape ; sh:targetNode ex:MyInstance ; sh:property ex:MyShape-myProperty1 ; sh:property ex:MyShape-myProperty2 ; . ex:MyShape-myProperty1 # sh:minCount および sh:datatype の違反は警告として生成される a sh:PropertyShape ; sh:path ex:myProperty ; sh:minCount 1 ; sh:datatype xsd:string ; sh:severity sh:Warning ; . ex:MyShape-myProperty2 # ここでの既定の重大度は sh:Violation である a sh:PropertyShape ; sh:path ex:myProperty ; sh:maxLength 10 ; sh:message "Too many characters"@en ; sh:message "Zu viele Zeichen"@de ; .

[ a sh:ValidationReport ; sh:conforms false ; sh:result [ a sh:ValidationResult ; sh:resultSeverity sh:Warning ; sh:focusNode ex:MyInstance ; sh:resultPath ex:myProperty ; sh:value "http://toomanycharacters"^^xsd:anyURI ; sh:sourceConstraintComponent sh:DatatypeConstraintComponent ; sh:sourceShape ex:MyShape-myProperty1 ; ] , [ a sh:ValidationResult ; sh:resultSeverity sh:Violation ; sh:focusNode ex:MyInstance ; sh:resultPath ex:myProperty ; sh:value "http://toomanycharacters"^^xsd:anyURI ; sh:resultMessage "Too many characters"@en ; sh:resultMessage "Zu viele Zeichen"@de ; sh:sourceConstraintComponent sh:MaxLengthConstraintComponent ; sh:sourceShape ex:MyShape-myProperty2 ; ] ] .

次の例は、上の形状グラフのバリエーションであり、具象化を用いて個々の制約の重大度を指定している:

例 17: 具象化を用いて形状と制約に対して重大度を宣言する例

ex:MyShape a sh:NodeShape ; sh:targetNode ex:MyInstance ; sh:property ex:MyShape-myProperty1 ; sh:property ex:MyShape-myProperty2 ; . ex:MyShape-myProperty1 a sh:PropertyShape ; sh:path ex:myProperty ; sh:minCount 1 {| sh:severity sh:Info |} ; sh:datatype xsd:string {| sh:severity sh:Warning |} ; . ex:MyShape-myProperty2 # ここでの既定の重大度は sh:Violation である sh:path ex:myProperty ; sh:maxLength 10 ; sh:message "Too many characters"@en ; sh:message "Zu viele Zeichen"@de ; .

形状はプロパティ sh:message について値を持つことができる。 sh:message の値は、データ型 xsd:string、rdf:dirLangString、rdf:langString、または rdf:HTML を持つリテラルである。主語は、同じ言語タグを持つ sh:message の値を2つ以上持つべきではなく、データ型 xsd:string を持つ値を複数持つべきでもない。

形状が形状グラフ内で sh:message について少なくとも1つの値を持つ場合、その形状の結果として生成されるすべての検証結果は、 sh:resultMessage の値として正確にこれらのメッセージを持つ。すなわち、値は形状グラフから結果グラフへコピーされる。

形状ごとにメッセージを宣言することに加えて、プロパティ sh:message は、形状を主語とし、制約のパラメーターの1つを述語とするトリプルの具象化子上でも使用できる。

T を、形状内の制約を表すトリプルの集合とする。形状グラフは、T 内のトリプルの具象化子内で、プロパティ sh:message について最大1つの値を指定できる。

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

sh:resultMessage の値がどのように設定されるかの詳細については、検証結果における sh:resultMessage に関する節を参照。

前節の例は、この仕組みを用いて2番目の検証結果に2つのメッセージを提供している。次の例は、メッセージが具象化を用いて宣言されるバリエーションである。

例 18: 具象化を用いて形状と制約に対してメッセージを宣言する例

ex:MyShape a sh:NodeShape ; sh:targetNode ex:MyInstance ; sh:property ex:MyShape-myProperty ; . ex:MyShape-myProperty a sh:PropertyShape ; sh:path ex:myProperty ; sh:maxLength 10 {| sh:message "Too many characters"@en ; sh:message "Zu viele Zeichen"@de |} .

形状は、プロパティ sh:deactivated について最大1つの値を持つことができる。 sh:deactivated の値はノード式であり、 true または false のいずれかを（唯一の）出力ノードとして持たなければならない。

expr を、形状内の sh:deactivated の値とする。 evalExpr(expr, data graph, focus node, {}) が true を唯一の出力ノードとして生成する場合、その形状は無効化されていると呼ばれる。無効化された形状は検証中に無視される。

形状のすべての制約を無効化することに加えて、個々の制約を無効化することも可能である。これは具象化を用いて行われる。

形状を主語とし、 sh:minCount などのパラメーターを述語とするトリプルは、プロパティ sh:deactivated について値を持つ具象化子を最大1つ持つことができる。

expr を、形状を主語とし、パラメーターを述語とするトリプル上の具象化子内における sh:deactivated の値とする。 evalExpr(expr, data graph, focus node, {}) が true を唯一の出力ノードとして生成する場合、そのトリプルを使用する制約は無効化された制約と呼ばれる。無効化された制約は検証中に無視される。

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

SHACL Core において、sh:deactivated の有効な値は定数リテラルノード式 true および false のみである。

この機能のユースケースには、形状の再利用とデバッグが含まれる。他のグラフまたはファイルからの形状が所与の形状グラフにインポートされるシナリオでは、 sh:deactivated をローカル形状グラフ内でインポートされた形状に対して true に設定し、現在のアプリケーションコンテキストに適用されない形状を除外できる。これにより、元の作者が行った特定の仮定に同意しない場合でも、他者が開発した SHACL グラフを再利用できる。形状の作者が、その形状が他者によって無効化または変更される可能性があると予期する場合、実際の形状には IRIを使用し、空白ノードを使用しないことがよい慣行である。たとえば、形状 ex:PersonShape におけるプロパティ ex:name のプロパティ形状は、 IRI ex:PersonShape-name を持つことができる。 sh:deactivated のもう1つの典型的なユースケースは、形状の開発とテスト中に、特定の形状を（一時的に）無効化することである。

次の例は、sh:deactivated を用いて形状を無効化する使用法を示す。形状が他のグラフからインポートされる場合、sh:deactivated true トリプルはインポートする側のグラフ内に置かれることになる。

例 19: プロパティ形状の無効化

次のデータでは、そのインスタンスが ex:name について値を持っていないにもかかわらず、制約違反は報告されない。

次のバリエーションは、具象化を用いて、同じプロパティ形状上の他の制約に影響を与えずに sh:minCount 制約だけを無効化する。

例 20: 具象化を用いた個々の制約の無効化

ノード形状は、形状グラフ内の形状であり、 sh:path を述語として持つトリプルの主語ではないものである。ノード形状は、 sh:NodeShape の SHACL インスタンスとして宣言されることが推奨されるが、要求はされない。 sh:NodeShape の SHACL インスタンスは、プロパティ sh:path について値を持つことができない。

非形式的には、ノード形状はフォーカスノードに関して満たされる必要がある制約を指定する。プロパティ形状とは対照的に、ノード形状は主としてプロパティ値ではなくフォーカスノード自体に適用される。

プロパティ形状は、形状グラフ内の形状であり、 sh:path を述語として持つトリプルの主語である。形状は sh:path について最大1つの値を持つ。プロパティ形状内の sh:path の値は、正形式の SHACL プロパティパスである。

プロパティ形状は、 sh:PropertyShape の SHACL インスタンスとして宣言されることが推奨されるが、要求はされない。 sh:PropertyShape の SHACL インスタンスは、プロパティ sh:path について 1つの値を持つ。

プロパティ形状は、プロパティ sh:values について最大1つの値を持ち、この値は正形式のノード式である。プロパティ形状は、プロパティ sh:defaultValue について最大1つの値を持ち、この値は正形式のノード式である。プロパティ形状は、sh:path についての値が述語パスである場合にのみ、 sh:values および/または sh:defaultValue について値を持つことができる。

非形式的には、プロパティ形状は、フォーカスノードから到達できるノードに関して満たされる必要がある制約を指定する。それは、(a) sh:path を用いて IRIとして指定された所与のプロパティを直接たどること、 (b) sh:path を用いて指定された他の任意の SHACL プロパティパスを直接たどること、 (c) sh:values を用いて指定されたノード式を評価すること、または、 (d) 他の値が存在しない場合に sh:defaultValue を用いて指定されたノード式を評価することによって行われる。

sh:values および sh:defaultValue のサポートは SHACL Core では要求されないが、 [shacl12-sparql] などの拡張には必要であることに注意されたい。

正形式のプロパティ形状およびノード形状の定義は、これら2つのノード集合を互いに素にすることに注意されたい。

次の例は、プロパティ形状のいくつかの構文上のバリエーションを示している。

例 21: プロパティ形状のいくつかの構文上のバリエーション

ex:ExampleNodeShapeWithPropertyShapes a sh:NodeShape ; sh:property [ # 空白ノードとしての「インライン」プロパティ形状の例 sh:path ex:email ; sh:name "e-mail"@en ; sh:description "We need at least one email value"@en ; sh:minCount 1 ; ] ; sh:property ex:ExampleNodeShapeWithPropertyShapes-knows-email ; . ex:ExampleNodeShapeWithPropertyShapes-knows-email a sh:PropertyShape ; sh:path (ex:knows ex:email) ; sh:name "Friend's e-mail"@en ; sh:description "We need at least one email for everyone you know"@en ; sh:minCount 1 ; .

検証は、データグラフと形状グラフを入力として受け取り、検証結果を含む検証レポートを生成する。適合性チェックは、検証の簡略版であり、真偽値の結果を生成する。検証を実行できるシステムはプロセッサーと呼ばれ、動詞処理は、検証プロセスを指すために使われることがある。

SHACL は、RDF 結果グラフとして検証レポートを生成するプロセッサーが使用できる RDF 検証レポート語彙を定義する。この仕様は、制約コンポーネントに関連付けられた検証器の規範的定義に、SHACL 結果語彙を使用する。検証レポート語彙のすべての必須プロパティを生成できる SHACL 実装のみが、標準適合である。

形状グラフは、SHACL 検証プロセスに形状および関連情報を提供する役割を持つ RDF グラフであり、それによってデータグラフを形状に対して検証できるようにする。

sh:ShapesGraph クラスは、通常、シェイプグラフの役割を果たすグラフのIRIの rdf:type として使用してもよい。グラフ型クラス（sh:DataGraph や sh:ShapesGraph など）は、相互に排他的ではない役割を表す。単一のグラフに、これらのクラスのうち複数を型として指定してもよい。

所与の検証に対する形状グラフは、たとえば owl:imports や sh:shapesGraph を通じて複数の形状グラフを結合した結果であってよい。どのように構築されたとしても、検証に使用される形状グラフは、検証プロセス中に固定されたままで MUST ある。詳細は6.5 検証を参照。

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

形状グラフは、述語 owl:importsで相互参照できる再利用可能な検証モジュールであり得る。検証前のステップとして、SHACL プロセッサーは、もともと提供された形状グラフを、 owl:imports 述語を通じて参照されるすべての形状グラフを推移的にたどってインポートすることで拡張するべきである。インポートされた IRI を解決する際、取得されたグラフが、そのインポートされた IRI を owl:versionIRI の目的語として持つトリプルを含む場合、プロセッサーは、さらなる owl:imports 文をたどる目的で、そのトリプルの主語を、インポートされたグラフの形状グラフ IRI として扱うべきである。形式的には、プロセッサーは、バージョン IRI を使用してバージョン付き形状グラフをインポートできるように、インポートを解決するためにプロパティパス ^owl:versionIRI?/owl:imports を反復的に使用するべきである。

次の例では、形状グラフは <http://example.com/shapes/company/v2> をインポートする。プロセッサーがその IRI のグラフを取得すると、その IRI が <http://example.com/shapes/company> の owl:versionIRI として宣言されていることを見つける。その後、プロセッサーは、さらなる owl:imports 文をたどる際に <http://example.com/shapes/company> を用いてそのグラフを識別し、この場合は <http://example.com/shapes/base> をインポートする。

例 23: owl:versionIRI を用いたバージョン付き形状グラフのインポート

# バージョン付き形状モジュールをインポートする形状グラフ <http://example.com/shapes/myapp> owl:imports <http://example.com/shapes/company/v2> . ex:PersonShape a sh:NodeShape ; sh:targetClass ex:Person ; sh:property [ sh:path ex:worksFor ; sh:class ex:Company ; ] .

{
	"@graph": [
		{
			"@id": "http://example.com/shapes/myapp",
			"owl:imports": {
				"@id": "http://example.com/shapes/company/v2"
			}
		},
		{
			"@id": "ex:PersonShape",
			"@type": "sh:NodeShape",
			"sh:targetClass": { "@id": "ex:Person" },
			"sh:property": {
				"sh:path": { "@id": "ex:worksFor" },
				"sh:class": { "@id": "ex:Company" }
			}
		}
	]
}

# <http://example.com/shapes/company/v2> から取得されたグラフ <http://example.com/shapes/company> owl:versionIRI <http://example.com/shapes/company/v2> ; owl:imports <http://example.com/shapes/base> . ex:CompanyShape a sh:NodeShape ; sh:targetClass ex:Company ; sh:property [ sh:path ex:name ; sh:minCount 1 ; sh:datatype xsd:string ; ] .

{
	"@graph": [
		{
			"@id": "http://example.com/shapes/company",
			"owl:versionIRI": {
				"@id": "http://example.com/shapes/company/v2"
			},
			"owl:imports": {
				"@id": "http://example.com/shapes/base"
			}
		},
		{
			"@id": "ex:CompanyShape",
			"@type": "sh:NodeShape",
			"sh:targetClass": { "@id": "ex:Company" },
			"sh:property": {
				"sh:path": { "@id": "ex:name" },
				"sh:minCount": 1,
				"sh:datatype": { "@id": "xsd:string" }
			}
		}
	]
}

結果として得られるグラフは、検証のための不変の形状グラフを形成する。

注

owl:versionIRI を使用してバージョン付き形状グラフをインポートする場合、互換性のないバージョンをインポートしないよう注意するべきである。特に、形状グラフのインポート閉包は、同一系列の異なるバージョンである2つのグラフ、または一方が他方に対して owl:incompatibleWith を宣言するグラフを含むべきではない（SHOULD NOT）。そのような形状グラフは不正形式とみなされる。詳細は、正形式の形状グラフの定義を参照。

形状宣言に加えて、形状グラフは sh:entailment 文など、SHACL プロセッサーのための追加情報を含むことがある。

任意の RDF グラフはデータグラフになり得る。

sh:DataGraph クラスは、通常、データグラフとして使用されるグラフのIRIの rdf:type として使用してもよい。グラフ型クラス（sh:DataGraph や sh:ShapesGraph など）は、相互に排他的ではない役割を表す。単一のグラフに、これらのクラスのうち複数を型として指定してもよい。たとえば、シェイプ自体を検証する場合、シェイプグラフは、データグラフの役割も果たしてもよい。

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

データグラフは、検証のための SHACL プロセッサーへの入力の1つである。 SHACL プロセッサーはそれを一般的な RDF グラフとして扱い、その性質について仮定を置かない。たとえば、それはメモリ内グラフ、RDF データセットの名前付きグラフ、または SPARQL エンドポイントであり得る。

SHACL は、ファイルシステム、HTTP リクエスト、または RDF データセットなど、任意の手段によって取得された RDF グラフとともに使用できる。 SHACL は、グラフが任意の RDF 含意レジームの下でそのグラフから含意されたトリプルを含むかどうかについて仮定しない。

SHACL がクラスターゲットを正しく識別し、Core SHACL 制約を検証するために、データグラフには、データに関連するすべてのオントロジー公理、特にすべての rdfs:subClassOf トリプルが含まれていることが期待される。

注

データグラフ内の owl:imports は、検証作業の制御不能な増加を避けるため、実行されない。複数の関連するオントロジーを検証したい場合は、それらを（まとめてまたは1つずつ） SHACL プロセッサーに渡し、owl:imports リンクに依存してはならない。

注

SHACL はデータグラフ内の owl:imports を実行しないが、データグラフの管理者は、インポート指示として owl:imports の振る舞いに依存するアプリケーションに引き続き注意するべきである。特に、一部のアプリケーションは、X a owl:Ontology . が直接存在することに構文上依存しており、X owl:imports Y . が owl:imports 文を Y をロードする指示として処理することがある。詳細は OWL 2 Web Ontology Language Mapping to RDF Graphs, Section 3.1.1 を参照。したがって、X a sh:DataGraph . という形式の文を使用する場合、 X a owl:Ontology . も含めるべきである。

SHACL のいくつかの機能（ 7.1.1 sh:class、 3.1.3.2 クラスベースのターゲット（sh:targetClass）、および 3.1.3.3 暗黙のクラスターゲットと sh:ShapeClassなど）は、あるノードが所与のクラスの SHACL インスタンスであるかどうかを判定するために、 SHACL 型の概念に依存する。既定では、これはデータグラフ内の rdfs:subClassOf および rdf:type トリプルを検索することによって決定される。しかし、これは一部の場合には不十分である。なぜなら、rdfs:subClassOf トリプルは多くの場合、インスタンスデータではなく、クラス定義および/または形状定義の一部として保存されるからである。

SHACL プロセッサーは、true に設定された場合に SHACL 型の定義を変更し、 rdfs:subClassOf トリプルをデータグラフに加えて形状グラフからも照会するようにする subClassOfInShapesGraph パラメーターを提供するべきである（SHOULD）。 rdf:type トリプルは常にデータグラフ内にあることが期待される。

データグラフは、述語 sh:shapesGraph を用いて SHACL プロセッサーに1つ以上のグラフを提案するために使用されるトリプルを含むことができる。 sh:shapesGraph のすべての値は IRIである。これは、データグラフを検証するために使用される形状グラフに含められるべき（SHOULD）グラフを表す。 sh:shapesGraph の値は owl:versionIRI の値であってよく、したがって形状グラフについて説明した、バージョン IRI から形状グラフ IRI を解決する同じ戦略がここにも適用される。

次の例では、SHACL プロセッサーは、所与のグラフを検証する際に、 ex:graph-shapes1 グラフおよび ex:graph-shapes2 グラフ（およびそれらの owl:imports）の和集合を形状グラフとして使用するべきである（SHOULD）。

検証は、何らかの入力から検証結果への写像であり、次の段落で定義される。

形状グラフに対するデータグラフの検証: データグラフおよび形状グラフが与えられたとき、検証結果は、形状グラフ内のすべての形状に対するデータグラフの検証結果の和集合である。

形状に対するデータグラフの検証: データグラフおよび形状グラフ内の形状が与えられたとき、検証結果は、データグラフ内における形状のターゲットに含まれるすべてのフォーカスノードの検証結果の和集合である。

形状に対するフォーカスノードの検証: データグラフ内のフォーカスノードおよび形状グラフ内の形状が与えられたとき、検証結果は、その形状によって宣言されたすべての制約に対するフォーカスノードの検証結果の和集合である。ただし、形状が無効化されている場合は、検証結果は空である。

制約に対するフォーカスノードの検証: データグラフ内のフォーカスノードおよび形状グラフ内の種別 C の制約が与えられたとき、検証結果は、制約コンポーネント C の検証器によって定義される。これらの検証器は通常、入力としてフォーカスノード、形状グラフ内の制約の C のパラメーターの具体的な値、およびその制約を宣言する形状の値ノードを取る。

検証中、データグラフおよび形状グラフは不変のままで MUST ある。すなわち、検証終了時の両グラフは、検証開始時のグラフと同一で MUST ある。 SHACL プロセッサーは、これらのグラフが保存済みグラフの変更を許す RDF ストアの一部である場合でも、形状グラフまたはデータグラフを構築するために使用するグラフを変更してはならない（MUST NOT）。 SHACL プロセッサーは、検証結果を含むグラフなど、自ら作成するグラフを保存することが MAY あり、この操作は RDF ストア内の既存のグラフを変更することが MAY あるが、形状グラフまたはデータグラフを構築するために使用されたいずれのグラフも変更してはならない。したがって、SHACL 処理は冪等である。

検証および適合性チェックは、失敗をもたらす場合がある。たとえば、特定の SHACL プロセッサーは再帰的な形状を許可するが、データ内のループを検出した場合に失敗を報告することがある。失敗は、リソース枯渇によって報告される場合もある。失敗は、実装固有のチャネルを通じて通知される。

形状グラフが不正形式のノードを含む場合、検証プロセスの結果は未定義である。 SHACL プロセッサーは、この場合に失敗を生成するべきである（SHOULD）。 6.7.1.4 形状グラフの構文チェック（sh:shapesGraphWellFormed）も参照。

次のプロパティは、SHACL Core におけるいわゆる形状を期待する制約パラメーターである:

sh:and
sh:not
sh:or
sh:property
sh:qualifiedValueShape
sh:node
sh:memberShape
sh:reifierShape
sh:someValue
sh:xone

次のプロパティは、SHACL Core におけるいわゆるリスト受容制約パラメーターである:

sh:and
sh:in
sh:languageIn
sh:or
sh:xone

RDF グラフ G 内の形状 s1 は、ある制約コンポーネントの非リスト受容で形状を期待するパラメーターについて s2 を値として持つ場合、またはある制約コンポーネントのリスト受容で形状を期待するパラメーターについての値のメンバーとして s2 を持つ場合、 G 内で形状 s2 を参照する。 RDF グラフ G 内の形状は、G 内で参照する関係の推移閉包によって自分自身に関連付けられている場合、G 内の再帰的な形状である。

再帰的な形状を伴う検証は SHACL では定義されず、SHACL プロセッサー実装に委ねられる。たとえば、SHACL プロセッサーは再帰シナリオをサポートしてもよく、再帰を検出したときに失敗を生成してもよい。

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

上記の再帰ポリシーは、幅広い実装戦略をサポートするために選択された。再帰を未定義のままにすることで、実装は再帰をサポートしないことを選べるため、循環をサポートせずに（SPARQL エンドポイントに対する）静的な SPARQL クエリー集合を発行できる。ワーキンググループは、他の実装が再帰をサポートする可能性があること、および一部の形状グラフがこれらの特定の特性に依存する可能性があることを認識している。将来の作業、たとえば W3C コミュニティグループにおける作業により、再帰が十分に定義された SHACL の特定の方言の定義につながることが期待される。

フォーカスノードは、シェイプに対するフォーカスノードの検証結果の集合に、不許可レベルの集合に含まれる重大度レベルを持つ検証結果が含まれず、かつそれによって失敗が報告されていない場合に限り、そのシェイプに適合する。

不許可の重大度レベルの集合は、述語が sh:conformanceDisallowsで、検証レポートを主語とするトリプルの目的語として定義される。検証レポートにそのようなトリプルが含まれない場合、sh:Violation、sh:Warning、および sh:Infoがデフォルトとして設定される。

適合性検査は、指定されたフォーカスノードが指定されたシェイプに適合する場合に限り trueを生成し、それ以外の場合はfalseを生成する。

SHACL Coreのすべてのシェイプを要求する制約パラメーターは、適合性検査に依存することに注意されたい。この場合、適合性検査の結果を決定するために使用される検証結果は、周囲の検証プロセスの検証結果から分離され、通常は同じ検証レポートには含まれない（ただし、sh:detailの値として含まれる可能性はある）。

データグラフは、指定されたシェイプグラフに適合することを示すために、プロパティ sh:conformsToShapesGraphを使用してもよい。値は、シェイプグラフを識別するIRIである。このプロパティは、rdfs:domain sh:DataGraphおよびrdfs:range sh:ShapesGraphを持つ。

注記

このプロパティの使用に関する詳細については、SHACL 1.2 Profilingのシェイプグラフへの適合セクションを参照されたい。

検証レポートは、適合性およびすべての検証結果の集合を報告する検証プロセスの結果である。検証レポートは、このセクションで定義されるSHACLの検証レポート語彙を使用して記述される。この語彙は、データグラフ内の違反を特定または修正する方法についての指針を提供できる構造情報を表現するためのRDFプロパティを定義する。

SHACL準拠プロセッサーは、この仕様で記述される必須の検証結果をすべて含む検証レポートを返すことができなければならない。 SHACL準拠プロセッサーは、返される結果の数を制限できるようにするオプション引数をサポートしてもよい。この柔軟性は、たとえば一部の大規模データセット検証のユースケースで必要となる。

次のグラフは、シェイプグラフに適合するデータグラフを検証した場合の検証レポートの例を表す。

例 25: 適合するデータグラフの検証レポートの例

[ a sh:ValidationReport ; sh:conforms true ; sh:conformanceDisallows sh:Violation ; sh:result [ a sh:ValidationResult ; sh:resultSeverity sh:Warning ; sh:focusNode ex:Bob ; sh:resultPath ex:age ; sh:value "twenty two"@en ; sh:resultMessage "ex:ageにはデータ型xsd:integerのリテラルが必要です。"@en ; sh:sourceConstraintComponent sh:DatatypeConstraintComponent ; sh:sourceShape ex:PersonShape-age ; ] ] .

次のグラフは、シェイプグラフに適合しないデータグラフを検証した場合の検証レポートの例を表す。 sh:resultMessageの具体的な値はSHACLによって規定されておらず、実装固有とみなされることに注意されたい。

例 26: 適合しないデータグラフの検証レポートの例

[ a sh:ValidationReport ; sh:conforms false ; sh:conformanceDisallows sh:Violation ; sh:result [ a sh:ValidationResult ; sh:resultSeverity sh:Violation ; sh:focusNode ex:Bob ; sh:resultPath ex:age ; sh:value "twenty two"@en ; sh:resultMessage "ex:ageにはデータ型xsd:integerのリテラルが必要です。"@en ; sh:sourceConstraintComponent sh:DatatypeConstraintComponent ; sh:sourceShape ex:PersonShape-age ; ] ] .

検証プロセスの結果は、sh:ValidationReportのSHACLインスタンスを正確に1つ持つRDFグラフである。 RDFグラフには、追加の来歴メタデータが含まれていてもよい。特に、検証レポートは、検証されたデータグラフを識別するためにsh:usedDataGraphを、使用されたシェイプグラフを識別するためにsh:usedShapesGraphを、また、検証時点におけるプロセッサーの状態と設定を記述する sh:ProcessorConfigurationインスタンスへリンクするためにsh:usedConfigurationを使用してもよい。これらのプロパティを組み合わせることで、レポートはそれが生成されたコンテキストに関して自己完結できる。

注記

自己完結型の検証レポートに関する詳細と例については、SHACL 1.2 Profilingの検証レポートセクションを参照されたい。

結果グラフ内のsh:ValidationReportの各SHACLインスタンスは、プロパティ sh:conformsについて正確に1つの値を持ち、その値のデータ型は xsd:booleanである。これは、適合性検査の結果を表す。

結果グラフ内のsh:ValidationReportの各SHACLインスタンスは、プロパティ sh:conformanceDisallowsについて1つ以上の値を持ってもよい。 sh:conformanceDisallowsのすべての値はIRIでなければならない。

すべての値を組み合わせたものが、不許可の重大度レベルの集合を定義する。不許可の重大度レベルの集合に含まれる重大度レベルを持つ sh:ValidationResultが存在する場合、関連付けられた sh:ValidationReportインスタンスのsh:conformsの値は falseでなければならない。

結果グラフ内にプロパティ sh:conformanceDisallowsの値が存在しない場合、 sh:Violation、sh:Warning、およびsh:Infoで構成されるデフォルトの集合を使用しなければならない。

適合性不許可集合は、検証エンジンによって定義される。検証エンジンは、この集合をカスタマイズするための仕組みを提供してもよい。

検証プロセスによって生成された各検証結果（適合性検査のコンテキストで言及されたものを除く）について、結果グラフ内のsh:ValidationReportのSHACLインスタンスは、プロパティ sh:resultの値を持つ。 sh:resultの各値は、クラス sh:ValidationResultのSHACLインスタンスである。

SHACL検証エンジンには、シェイプグラフが整形式であるかどうかを検査することが厳密には要求されない。そのような検査を実行する実装（たとえば、シェイプグラフがシステムにインストールされるとき、または検証の前もしくは実行中）は、プロパティ sh:shapesGraphWellFormedを使用して、その事実を検証レポートの利用者に通知することが望ましい。結果グラフ内のsh:ValidationReportのSHACLインスタンスが、 sh:shapesGraphWellFormedの値として trueを持つ場合、プロセッサーは、検証プロセスで使用されたシェイプグラフが整形式であることを確認済みであった。

結果グラフ内のsh:ValidationReportのSHACLインスタンスは、プロパティ sh:usedDataGraphの値を持ってもよい。値は、レポートを生成するためにプロセッサーによって検証されたデータグラフを識別するIRIである。データグラフのバージョンIRIも、このプロパティの値として使用してもよい。

結果グラフ内のsh:ValidationReportのSHACLインスタンスは、プロパティ sh:usedShapesGraphの値を持ってもよい。値は、検証プロセス中にプロセッサーによって使用されたシェイプグラフを識別するIRIである。シェイプグラフのバージョンIRIも、このプロパティの値として使用してもよい。

結果グラフ内のsh:ValidationReportのSHACLインスタンスは、プロパティ sh:usedConfigurationの値を持ってもよい。値は、レポートを生成したプロセッサーの状態と設定を記述する sh:ProcessorConfigurationのインスタンスである。 SHACLプロセッサーは、sh:ProcessorConfigurationインスタンスの内容に基づいて検証動作を変更してはならない。

sh:ProcessorConfigurationは、プロセッサー構成のクラスである。このクラスのインスタンスは、SHACLプロセッサーが検証レポートを生成した時点での状態と設定を記述する。 sh:ProcessorConfigurationインスタンスのプロパティは、この仕様では定義されない。

注記

実装は、プロセッサー名、プロセッサーのバージョン、最大再帰深度、その他の実行時パラメーターなど、このクラスのインスタンスに必要な任意のプロパティを自由に定義できる。

SHACLは、個々のSHACL検証結果を報告するために、 sh:ValidationResultをsh:AbstractResultのサブクラスとして定義する。 SHACL実装は、たとえば、正常に完了した制約検査または累積結果を報告するために、 sh:AbstractResultの他のSHACLサブクラスを使用してもよい。

このセクションの残りのサブセクションで記述されるすべてのプロパティは、 sh:ValidationResultで指定できる。プロパティsh:focusNode、sh:resultSeverity、および sh:sourceConstraintComponentのみが、すべての検証結果で必須となるプロパティである。

各検証結果は、プロパティsh:focusNodeについて正確に1つの値を持ち、その値は結果の原因となったフォーカスノードに等しい。これは、検証結果が生成されたときに検証されていたフォーカスノードである。

検証結果は、整形式のSHACL プロパティパスを指すプロパティsh:resultPathの値を持つことができる。プロパティシェイプによって生成された結果では、特に明記されない限り、このSHACLプロパティパスは、シェイプのsh:pathの値と等価である。 sh:pathのpが空白ノードである場合、 sh:resultPathは結果グラフ内のpのディープコピーとなる。

検証結果には、プロパティsh:valueの値として、結果の原因となったRDF用語を最大で1つ含めることができる。 SHACL Coreコンポーネントのバリデーターのテキストによる定義は、この値がどのように構築されるかを指定する。多くの場合、それらは制約に違反した値ノードである。

検証結果には、プロパティ sh:sourceShapeの唯一の値として、指定されたsh:focusNodeの検証対象となったシェイプを含めることができる。

検証結果は、プロパティ sh:sourceConstraintComponentについて正確に1つの値を持ち、この値は結果の原因となった制約コンポーネントのIRIである。たとえば、sh:minCountの値に基づく制約への違反によって生成された結果では、ソース制約コンポーネントはsh:MinCountConstraintComponentとなる。

プロパティsh:detailは、（親）結果を、（親）結果の原因に関するさらなる詳細を提供できるsh:AbstractResultの 1つ以上のSHACLインスタンスへリンクできる。 SHACLプロセッサーの機能に応じて、これには、たとえばsh:nodeを介した適合性検査の一部として評価された制約への違反が含まれる場合がある。

検証結果は、たとえば人間に追加のテキスト詳細を伝えるために、プロパティsh:resultMessageの値を持つことができる。 sh:resultMessageは複数の値を持つことができるが、同じ言語タグを持つ2つの値が存在するべきではない。これらの値は、シェイプグラフ内の制約のsh:messageの値に基づいて検証エンジンによって生成される。シェイプに対するメッセージの宣言を参照されたい。具体化を使用して宣言されたメッセージは、周囲のシェイプで宣言されたメッセージよりも優先される。シェイプグラフ内で制約がsh:messageの値を持たない場合、 SHACLプロセッサーはsh:resultMessageの他の値を自動的に生成してもよい。

各検証結果は、プロパティsh:resultSeverityについて正確に1つの値を持ち、この値はIRIである。値は、次の規則によって（記載順に）決定される。

結果の原因となった制約のパラメーターを含むいずれかのトリプルの具体化子におけるsh:severityの値
結果の原因となったシェイプグラフ内のシェイプのsh:severityの値
シェイプまたは制約にsh:severityが指定されていない場合、デフォルトでsh:Violationとなる。

ほとんどの制約コンポーネントの検証器は、次の2つの小節で定義される値ノードの概念を使用する。

ノード形状の場合、値ノードは個々のフォーカスノードであり、ちょうど1つのメンバーを持つ集合を形成する。

sh:path p について値を持つプロパティ形状の場合、値ノードの集合は、次の手順によって生成される:

フォーカスノードからpのパスマッピングによって到達できる、データグラフ内のすべてのノードを追加する。
eがプロパティシェイプにおけるsh:valuesの値である場合、 evalExpr(e, データグラフ, フォーカスノード, {})の出力ノードを追加する。
集合がまだ空であり、dがプロパティシェイプにおける sh:defaultValueの値である場合、 evalExpr(d, データグラフ, フォーカスノード, {})の出力ノードを追加する。

この節では、すべての SHACL Core プロセッサーがサポートしなければならない（MUST）組み込みの SHACL Core 制約コンポーネントを定義する。各制約コンポーネントの定義には、その IRI とパラメーターの表が含まれる。別段の定めがない限り、これらのパラメーターはすべて必須パラメーターである。これらのパラメーター表に列挙された構文規則のいずれかに違反する形状は不正形式である。

各制約コンポーネントには、そのコンポーネントに関連付けられたバリデーターを説明するテキストによる定義も含まれる。これらのテキストによる定義では、制約内のパラメーターの値を $paramName形式の変数で参照する。ここで、paramNameはパラメーターのIRIの sh:名前空間より後の部分である。たとえば、sh:ClassConstraintComponentのテキストによる定義では、 sh:classの値を変数$classを使用して参照する。 SHACL Coreでは、パラメーター値という用語は、パラメーターの値、すなわち、シェイプグラフ内で、主語がシェイプであり、述語が（sh:classなどの）パラメーターであるトリプルの目的語を意味する。

課題 1

執筆時点では、WG の意図は、SHACL Core の外部で SHACL の方言を定義し、その中でパラメーター値という用語がノード式も許容するようにすることである。すべての制約コンポーネントがパラメーター値という用語を使用するわけではなく、代わりに値という用語を参照することに注意されたい。たとえば、sh:node の値は、決してノード式にはなり得ない。なぜなら、そうすると空白ノードの扱いが複雑になるからである。 TODO: Node Expression 仕様が準備できている場合はそこへのリンクを追加し、そうでなければ上記の文を明確化する。

これらの検証器は、コンポーネントによって生成される検証結果の唯一のものを定義することに注意されたい。さらに、検証器は常に新しい結果ノードを生成する。すなわち、テキスト定義が「...検証結果が存在する...」と述べる場合、それは結果グラフ内の別個の新しいノードを指す。

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

SHACL Core に含まれる制約コンポーネントの選択は、 [shacl-ucr] 文書によって収集された要件に基づいて行われた。できるだけ多くの一般的なユースケースを網羅しようとすることと、 Core 言語の規模を扱いやすく保つこととのバランスに、特別な注意が払われた。すべてのユースケースを Core 言語だけで表現できるわけではない。代わりに、SHACL-SPARQL は、この仕様の第2部で説明される拡張機構を提供する。追加の再利用可能な制約コンポーネントのライブラリーが、第三者によって維持されることが期待される。

別段の定めがない限り、Core 制約コンポーネントはプロパティ形状とノード形状の両方で使用できる。一部の制約パラメーターには、それらを使用するノード形状を不正形式にする構文規則が付随している。これには、プロパティ形状でのみサポートされる sh:minCount などが含まれる。

この節の制約コンポーネントに共通する点は、値ノードの型を制限するために使用できることである。複数の値型の選択肢は、sh:or を用いて表現できることに注意されたい。

sh:class によって指定される条件は、各値ノードが、与えられた型の SHACL インスタンスであることである。

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

パラメーター:

プロパティ	概要および構文規則
`sh:class`	すべての値ノードの型。シェイプ内の `sh:class`の値は、IRI または、すべてのメンバーがIRIである整形式のSHACL リストである空白ノードのいずれかである。

テキストによる定義

$classを、sh:classのパラメーター値とする。 classesをIRIの集合とし、 $classがIRI である場合、その集合はそのIRIのみを正確に含み、 $classが空白ノードのSHACLリストである場合、その集合はリストのメンバーのみを正確に含むものとする。

リテラルであるか、またはデータグラフ内のclassesのいずれのSHACLインスタンスでもない非リテラルである各値ノードについて、その値ノードをsh:valueとする検証結果が存在する。

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

sh:class の複数の値は連言として解釈されることに注意されたい。すなわち、値はそれらすべての SHACL インスタンスである必要がある。和集合の意味にはリストを使用する。

例 27: 複数の値を持つ sh:class の使用例

次の例は、sh:class のリストベースの構文を示しており、プロパティ ex:pet の値は猫または犬のいずれかでなければならないことを意味する。

例 28: リスト値を持つ sh:class の使用例

sh:datatype は、各値ノードのデータ型に関して満たされるべき条件を指定する。

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

パラメーター:

プロパティ	概要および構文規則
`sh:datatype`	すべての値ノードで許可されるデータ型（例：`xsd:integer`）。シェイプは `sh:datatype`について最大で1つの値を持つ。シェイプ内の `sh:datatype`の値は、IRI または、すべてのメンバーがIRIである整形式のSHACL リストである空白ノードのいずれかである。

テキストによる定義

$datatypeを、sh:datatypeのパラメーター値とする。 datatypesをIRIの集合とし、 $datatypeがIRI である場合、その集合はそのIRIのみを正確に含み、 $datatypeが空白ノードのSHACLリストである場合、その集合はリストのメンバーのみを正確に含むものとする。

値ノードがリテラルではない場合、または、いずれの datatypesにも一致しないデータ型を持つリテラルである場合、その値ノードをsh:valueとする検証結果が存在する。

リテラルのデータ型は、SPARQL 1.2のデータ型関数に従って決定される。リテラルは、そのリテラルのデータ型が同じIRIを持ち、かつ、SPARQL 1.2でサポートされるデータ型については、型が不正なリテラルでない場合、そのデータ型と一致する。

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

sh:datatype の値は通常、xsd:string などのデータ型である。

例 29: sh:datatype プロパティ制約として IRI を持つ形状

次の例はリストベースの構文を示しており、 rdfs:label のすべての値は xsd:string または rdf:langString のいずれかでなければならないことを意味する。

例 30: sh:datatype プロパティ制約として IRI のリストを持つ形状

sh:nodeKind は、各値ノードの RDF ノード種別によって満たされるべき条件を指定する。

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

パラメーター:

プロパティ要約と構文規則

sh:nodeKind すべての値ノードのノード種別（IRI、空白ノード、リテラル、トリプル項、またはこれらの組み合わせ）。形状は sh:nodeKind について最大1つの値を持つ。形状内の sh:nodeKind の値は、IRI、またはすべてのメンバーが IRI である正形式の SHACL リストである空白ノードのいずれかである。

sh:nodeKind の値が IRI である場合、形状内の sh:nodeKind の値は、クラス sh:NodeKind の次の7つのインスタンスのいずれかである: sh:BlankNode, sh:IRI, sh:Literal sh:BlankNodeOrIRI, sh:BlankNodeOrLiteral, sh:IRIOrLiteral, および sh:TripleTerm。

sh:nodeKind の値が正形式の SHACL リストである場合、形状内のそれらのリストのメンバーは、クラス sh:NodeKind の次の4つのインスタンスのいずれかである: sh:BlankNode, sh:IRI, sh:Literal, および sh:TripleTerm。

プロパティ	要約と構文規則
`sh:nodeKind`	すべての値ノードのノード種別（IRI、空白ノード、リテラル、トリプル項、またはこれらの組み合わせ）。形状は `sh:nodeKind` について最大1つの値を持つ。形状内の `sh:nodeKind` の値は、IRI、またはすべてのメンバーが IRI である正形式の SHACL リストである空白ノードのいずれかである。 `sh:nodeKind` の値が IRI である場合、形状内の `sh:nodeKind` の値は、クラス `sh:NodeKind` の次の7つのインスタンスのいずれかである: `sh:BlankNode`, `sh:IRI`, `sh:Literal` `sh:BlankNodeOrIRI`, `sh:BlankNodeOrLiteral`, `sh:IRIOrLiteral`, および `sh:TripleTerm`。 `sh:nodeKind` の値が正形式の SHACL リストである場合、形状内のそれらのリストのメンバーは、クラス `sh:NodeKind` の次の4つのインスタンスのいずれかである: `sh:BlankNode`, `sh:IRI`, `sh:Literal`, および `sh:TripleTerm`。

テキストによる定義

$nodeKindを、sh:nodeKindのパラメーター値とする。 $nodeKindsをIRIの集合とし、 $nodeKindがIRI である場合、その集合はそのIRIのみを正確に含み、 $nodeKindが空白ノードのSHACLリストである場合、その集合はリストのメンバーのみを正確に含むものとする。

いずれの$nodeKindsにも一致しない各値ノードについて、その値ノードをsh:valueとする検証結果が存在する。すべてのIRIは、sh:IRI、 sh:BlankNodeOrIRIおよびsh:IRIOrLiteralにのみ一致する。すべての空白ノードは、sh:BlankNode、 sh:BlankNodeOrIRIおよびsh:BlankNodeOrLiteralにのみ一致する。すべてのリテラルは、sh:Literal、 sh:BlankNodeOrLiteralおよびsh:IRIOrLiteralにのみ一致する。すべてのトリプル項は、 sh:TripleTermにのみ一致する。

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

次の例は、任意の主語において ex:knows のすべての値が IRI である必要があることを述べている。

例 31: IRI 値を持つ sh:nodeKind の使用例

次の例はリストベースの構文を示しており、任意の主語において ex:knows のすべての値は IRI または空白ノードである必要があることを意味する。

例 32: 値として IRI のリストを持つ sh:nodeKind の使用例

次の制約コンポーネントは、所与のフォーカスノードに対する値ノードの数に関する制限を表す。

sh:minCount は、条件を満たす値ノードの最小数を指定する。最小カーディナリティ値が 0 の場合、この制約は常に満たされるため、省略してもよい。

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

パラメーター:

プロパティ	要約と構文規則
`sh:minCount`	最小カーディナリティ。ノード形状は `sh:minCount` についていかなる値も持つことができない。プロパティ形状は `sh:minCount` について最大1つの値を持つ。プロパティ形状内の `sh:minCount` の値は、データ型 `xsd:integer` を持つリテラルである。

テキスト定義

$minCount を sh:minCount のパラメーター値とする。値ノードの数が $minCount より少ない場合、検証結果が存在する。

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

例 33: sh:minCount の使用例

sh:maxCount は、条件を満たす値ノードの最大数を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:maxCount`	最大カーディナリティ。ノード形状は `sh:maxCount` についていかなる値も持つことができない。プロパティ形状は `sh:maxCount` について最大1つの値を持つ。プロパティ形状内の `sh:maxCount` の値は、データ型 `xsd:integer` を持つリテラルである。

テキスト定義

$maxCount を sh:maxCount のパラメーター値とする。値ノードの数が $maxCount より多い場合、検証結果が存在する。

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

例 34: sh:maxCount の使用例

次の制約コンポーネントは、<、<=、>、 >= などの演算子を介して比較可能な値ノードによって満たされるべき値範囲条件を指定する。次の例は、これらの制約コンポーネントの典型的なユースケースを示している。

例 35: 数値範囲制約の例

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

パラメーター:

プロパティ	要約と構文規則
`sh:minExclusive`	排他的最小値。形状内の `sh:minExclusive` の値はリテラルである。形状は `sh:minExclusive` について最大1つの値を持つ。

テキスト定義

$minExclusive を sh:minExclusive のパラメーター値とする。 SPARQL 式 $minExclusive < v が true を返さない値ノード v ごとに、 v を sh:value とする検証結果が存在する。

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

値ノードを指定された範囲と比較できない場合、たとえば文字列と整数を比較する場合には、検証結果が存在する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:minInclusive`	包括的最小値。形状内の `sh:minInclusive` の値はリテラルである。形状は `sh:minInclusive` について最大1つの値を持つ。

テキスト定義

$minInclusive を sh:minInclusive のパラメーター値とする。 SPARQL 式 $minInclusive <= v が true を返さない値ノード v ごとに、 v を sh:value とする検証結果が存在する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:maxExclusive`	排他的最大値。形状内の `sh:maxExclusive` の値はリテラルである。形状は `sh:maxExclusive` について最大1つの値を持つ。

テキスト定義

$maxExclusive を sh:maxExclusive のパラメーター値とする。 SPARQL 式 $maxExclusive > v が true を返さない値ノード v ごとに、 v を sh:value とする検証結果が存在する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:maxInclusive`	包括的最大値。形状内の `sh:maxInclusive` の値はリテラルである。形状は `sh:maxInclusive` について最大1つの値を持つ。

テキスト定義

$maxInclusive を sh:maxInclusive のパラメーター値とする。 SPARQL 式 $maxInclusive >= v が true を返さない値ノード v ごとに、 v を sh:value とする検証結果が存在する。

この節の制約コンポーネントに共通する点は、値ノードの文字列表現に関する条件を指定することである。

sh:minLength は、条件を満たす各値ノードの最小文字列長を指定する。これは任意のリテラルおよび IRIに適用できるが、空白ノードには適用できない。

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

パラメーター:

プロパティ	要約と構文規則
`sh:minLength`	最小長。形状内の `sh:minLength` の値は、データ型 `xsd:integer` を持つリテラルである。形状は `sh:minLength` について最大1つの値を持つ。

テキスト定義

$minLength を sh:minLength のパラメーター値とする。値ノード v ごとに、 v の文字列表現（SPARQL str 関数によって定義される）の長さ（SPARQL STRLEN 関数によって定義される）が $minLength より短い場合、または v が空白ノードである場合、 v を sh:value とする検証結果が存在する。

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

sh:minLength の値が 0 の場合、文字列長に関する制限はないが、値ノードが空白ノードであれば、それでも制約に違反することに注意されたい。

sh:maxLength は、条件を満たす各値ノードの最大文字列長を指定する。これは任意のリテラルおよび IRIに適用できるが、空白ノードには適用できない。

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

パラメーター:

プロパティ	要約と構文規則
`sh:maxLength`	最大長。形状内の `sh:maxLength` の値は、データ型 `xsd:integer` を持つリテラルである。形状は `sh:maxLength` について最大1つの値を持つ。

テキスト定義

$maxLength を sh:maxLength のパラメーター値とする。値ノード v ごとに、 v の文字列表現（SPARQL str 関数によって定義される）の長さ（SPARQL STRLEN 関数によって定義される）が $maxLength より長い場合、または v が空白ノードである場合、 v を sh:value とする検証結果が存在する。

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

例 36: sh:minLength および sh:maxLength の使用例

sh:pattern は、条件を満たすために各値ノードが一致する正規表現を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:pattern`	すべての値ノードが一致する必要のある正規表現。形状内の `sh:pattern` の値は、データ型 `xsd:string` を持つリテラルである。形状内の `sh:pattern` の値は、 SPARQL REGEX 関数に対する有効な pattern 引数である。
`sh:flags`	SPARQL 1.2 REGEX と同様に解釈される、任意のフラグ文字列。形状内の `sh:flags` の値は、データ型 `xsd:string` を持つリテラルである。

テキスト定義

$pattern を sh:pattern のパラメーター値とする。 $flags を sh:flags のパラメーター値とする。値ノードごとに、それが空白ノードであるか、または文字列表現（SPARQL str 関数によって定義される）が正規表現 $pattern（SPARQL REGEX 関数によって定義される）に一致しない場合、その値ノードを sh:value とする検証結果が存在する。 $flags が値を持つ場合、一致処理は、$flags を第3引数として使用して、 SPARQL REGEX 関数の3引数版の定義に従わなければならない（MUST）。

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

例 37: sh:pattern および sh:flags の使用例

ex:PatternExampleShape a sh:NodeShape ; sh:targetNode ex:Bob, ex:Alice, ex:Carol ; sh:property ex:PatternExampleShape-bCode ; . ex:PatternExampleShape-bCode a sh:PropertyShape ; sh:path ex:bCode ; sh:pattern "^B" ; # 'B' で始まる sh:flags "i" ; # 大文字小文字を無視 .

課題 2

この機能は、この機能（および類似の）便宜機能に関する WG の決議待ちのため「リスクあり」である。 WG は、Core に入れるべき機能と、他の文書に入れるべき機能との境界をどこに引くかについて、まだ確信していない。もともとは Issue 177 として議論された。

true に設定されている場合、sh:singleLine は値ノードが改行を含んではならないことを指定する。制約検証に加えて、この情報は、ユーザーインターフェイス構築器が（単一行の）テキストフィールドと（複数行の）テキストエリアを選択するために利用できる。

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

パラメーター:

プロパティ	要約と構文規則
`sh:singleLine`	この制約を有効化するための `true`。形状内の `sh:singleLine` の値は、データ型 `xsd:boolean` を持つリテラルである。形状は `sh:singleLine` について最大1つの値を持つ。

テキスト定義

$singleLine を sh:singleLine のパラメーター値とする。 $singleLine が true である場合、語彙形式が正規表現（SPARQL REGEX 関数によって定義される） [\f\r\n\v] に一致するリテラルである値ノードごとに、検証結果が存在する。

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

例 38: sh:singleLine の使用例

この例では、形状の有効なターゲットノードは rdfs:label について単一行の値のみを含むことができる。 rdfs:comment の値は改行を含むことが明示的に許可されており、フォーム構築器に対して、それらの値は複数行（テキストエリア）の入力ウィジェットで編集されるべきであることを示している。

ex:SingleLineExampleShape a sh:NodeShape ; sh:property ex:SingleLineExampleShape-label ; sh:property ex:SingleLineExampleShape-comment ; . ex:SingleLineExampleShape-label a sh:PropertyShape ; sh:path rdfs:label ; sh:datatype xsd:string ; sh:singleLine true ; . ex:SingleLineExampleShape-comment a sh:PropertyShape ; sh:path rdfs:comment ; sh:datatype ( xsd:string rdf:dirLangString rdf:langString ) ; sh:singleLine false ; .

sh:languageIn によって指定される条件は、各値ノードに許可される言語タグが、所与の言語タグのリストによって制限されることである。

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

パラメーター:

プロパティ	要約と構文規則
`sh:languageIn`	[BCP47] に従う基本言語範囲のリスト。形状内の `sh:languageIn` の各値は SHACL リストである。そのようなリストの各メンバーは、データ型 `xsd:string` を持つリテラルである。形状は `sh:languageIn` について最大1つの値を持つ。

テキスト定義

$languageIn を sh:languageIn の値とする。値ノードごとに、それがリテラルでない場合、または $languageIn のメンバーである基本言語範囲のいずれにも一致する言語タグを持たない場合、 SPARQL langMatches 関数で定義されるフィルタリングスキーマに従って、その値ノードを sh:value とする検証結果が存在する。

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

次の例の形状は、ex:prefLabel のすべての値が英語またはマオリ語のいずれかであり得ることを述べている。

例 39: sh:languageIn の使用例

例のインスタンスからは、ex:Berg がそのすべてのラベルについて制約違反につながる。

プロパティ sh:uniqueLang は、同じ言語タグを使用する値ノードの組が存在してはならないことを指定するために true に設定される。存在する場合は、テキスト方向も考慮に含める。

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

パラメーター:

プロパティ	要約と構文規則
`sh:uniqueLang`	この制約を有効化するための `true`。形状内の `sh:uniqueLang` の値は、データ型 `xsd:boolean` を持つリテラルである。プロパティ形状は `sh:uniqueLang` について最大1つの値を持つ。ノード形状は `sh:uniqueLang` についていかなる値も持つことができない。

テキスト定義

$uniqueLang を sh:uniqueLang のパラメーター値とする。 $uniqueLang が true である場合、少なくとも2つの値ノードによって使用される空でない言語タグごとに、検証結果が存在する。値ノードがデータ型 rdf:dirLangString を持つ場合、基底方向が一意性条件に含められる。たとえば、"1"@ar--rtl と "1"@ar-ltr は異なり、 "1"@ar--rtl と "1"@ar の組も同様に異なる。

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

例 40: sh:uniqueLang の使用例

この節の制約コンポーネントは、値ノードであり、SHACL リストであるものに適用される。それらは、SHACL リストの構造、長さ、およびメンバーに関する条件を指定する。

sh:memberShape は、SHACL リストである値ノードのすべてのメンバーが、与えられたノード形状に適合しなければならないことを指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:memberShape`	SHACL リストのすべてのメンバーが適合しなければならないシェイプ。 `sh:memberShape` の値は、整形式のノードシェイプでなければならない。

テキスト定義

$memberShape を sh:memberShape のパラメーター値とする。各値ノード v は SHACL リストでなければならない — v が SHACL リストでない場合、検証結果が存在する。 SHACL リスト v の任意のメンバー m が $memberShape に適合しない場合、検証結果が存在する。

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

$memberShape に適合しない値ノード v の各メンバー m は、 v に対する検証結果内で、個別の sh:detail として報告されるべきである。 v が有効なSHACL リストでない場合、これはトップレベルの検証結果として報告されるべきであり、個々のメンバーの検証は試みるべきではない。

検証結果内で sh:detail を生成する方法の例は、SHACL テストスイートの sh:memberShape のテストケースで見つけることができる: memberShape-001.ttl。

次の例では、プロパティ ex:speakerOrder のすべての値は、メンバーが IRI である SHACL リストでなければならない。

例 41: sh:memberShape の使用例

sh:minListLength は、SHACL リストである値ノードが持たなければならないメンバーの最小数を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:minListLength`	SHACL リスト内のメンバーの最小数。形状内の `sh:minListLength` の値は、データ型 `xsd:integer` を持つリテラルである。形状内の `sh:minListLength` の値は、0 以上の整数である。

テキスト定義

$minListLength を sh:minListLength のパラメーター値とする。各値ノード v は SHACL リストでなければならない — v が SHACL リストでない場合、検証結果が存在する。リスト v 内のメンバー数が $minListLength より少ない場合、検証結果が存在する。

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

次の例では、プロパティ ex:skills のすべての値は、少なくとも1つのメンバーを持つ SHACL リストでなければならない。 sh:minListLength の追加のテストケースは SHACL テストスイートで見つけることができる: minListLength-001.ttl。

例 42: sh:minListLength の使用例

sh:maxListLength は、SHACL リストである値ノードが持たなければならないメンバーの最大数を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:maxListLength`	SHACL リスト内のメンバーの最大数。形状内の `sh:maxListLength` の値は、データ型 `xsd:integer` を持つリテラルである。形状内の `sh:maxListLength` の値は、0 以上の整数である。

テキスト定義

$maxListLength を sh:maxListLength のパラメーター値とする。各値ノード v は SHACL リストでなければならない — v が SHACL リストでない場合、検証結果が存在する。リスト v 内のメンバー数が $maxListLength より多い場合、検証結果が存在する。

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

次の例では、プロパティ ex:hobbies のすべての値は、多くても2つのメンバーを持つ SHACL リストでなければならない。 sh:maxListLength の追加のテストケースは SHACL テストスイートで見つけることができる: maxListLength-001.ttl。

例 43: sh:maxListLength の使用例

sh:uniqueMembers は、SHACL リストである値ノードが一意のメンバーを持たなければならないかどうかを指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:uniqueMembers`	SHACL リストのメンバーが一意でなければならないかどうかを指定するブール値。形状内の `sh:uniqueMembers` の値は、データ型 `xsd:boolean` を持つリテラルである。

テキスト定義

$uniqueMembers を sh:uniqueMembers のパラメーター値とする。各値ノード v は SHACL リストでなければならない — v が SHACL リストでない場合、検証結果が存在する。 $uniqueMembers が true であり、リスト v に重複メンバーがある場合、検証結果が存在する。

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

リスト v の各重複メンバー m は、v に対する検証結果内で個別の sh:detail として報告されるべきである。リスト v が有効な SHACL リストでない場合、これはトップレベルの検証結果として報告されるべきであり、一意なメンバーシップの検証は試みるべきではない。

検証結果内で sh:detail を生成する方法の例は、SHACL テストスイートの sh:uniqueMembers のテストケースで見つけることができる: uniqueMembers-001.ttl。

次の例では、プロパティ ex:preferences のすべての値は、それぞれの SHACL リスト内で一意の値を持つメンバーから成る SHACL リストでなければならない。

例 44: sh:uniqueMembers の使用例

この節の制約コンポーネントは、他のプロパティまたはプロパティパスとの関係において、値ノードの集合に関する条件を指定する。これらの制約コンポーネントは、プロパティ形状によってのみ使用できる。

sh:equals は、すべての値ノードの集合が、フォーカスノードから、sh:equals を用いて指定された SHACL プロパティパスを介して到達できるノードの集合と等しい、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:equals`	比較対象となるプロパティパス。形状内の `sh:equals` の値は、正形式の SHACL プロパティパスである。

テキスト定義

$equals を sh:equals の値とし、$path を形状グラフ内で $equals によって表される SHACL プロパティパスとする。 $otherNodes を、フォーカスノードから $path を介して到達できるノードの集合とする。 $otherNodes 内に存在しない値ノードごとに、その値ノードを sh:value とする検証結果が存在する。 $otherNodes 内のノードであって、値ノードの1つでないものごとに、その値を sh:value とする検証結果が存在する。

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

次の例は、特定のフォーカスノードが ex:firstName と ex:givenName について同じ値集合を持つ必要があることを指定するために、形状内で sh:equals を使用することを示している。

例 45: 2つの IRI プロパティ間に sh:equals を持つ形状

次の例は、SHACL プロパティパスが sh:path と sh:equals の値の両方として使用できることを示している。

例 46: 2つのパス間に sh:equals を持つ形状

この例では、Bob が自分のタトゥーとは異なる名前の配偶者を持っていた場合、またはその逆の場合に警告が報告されることになる。 Bob が配偶者もタトゥーも持たない場合、または両方を持ち、それらの名前とテキストがまったく同じノード集合に一致する場合、警告は生成されない。

sh:disjoint は、値ノードの集合が、フォーカスノードから、 sh:disjoint の値である SHACL プロパティパスを介して到達できるノードの集合と互いに素である、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:disjoint`	値と比較するためのプロパティパス。形状内の `sh:disjoint` の値は、正形式の SHACL プロパティパスである。

テキスト定義

$disjoint を sh:disjoint のパラメーター値とし、 $path を形状グラフ内で $disjoint によって表される SHACL プロパティパスとする。 $otherNodes を、フォーカスノードから $path を介して到達できるノードの集合とする。 $otherNodes にも含まれる値ノードごとに、その値ノードを sh:value とする検証結果が存在する。

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

次の例は、特定のフォーカスノードが ex:prefLabel と ex:altLabel についていかなる値も共有できないことを指定するために、形状内で sh:disjoint を使用することを示している。

例 47: 2つの IRI プロパティ間に sh:disjoint を持つ形状

sh:subsetOf は、すべての値ノードが 同時に、フォーカスノードから、sh:subsetOf を用いて指定された SHACL プロパティパスを介して到達可能でなければならない、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:subsetOf`	比較対象となるプロパティパス。形状内の `sh:subsetOf` の値は、正形式の SHACL プロパティパスである。

テキスト定義

$subsetOf を sh:subsetOf の値とし、$path を形状グラフ内で $subsetOf によって表される SHACL プロパティパスとする。 $otherNodes を、フォーカスノードから $path を介して到達できるノードの集合とする。 $otherNodes 内に存在しない値ノードごとに、その値ノードを sh:value とする検証結果が存在する。

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

次の例は、ある人のお気に入りの子が実際の子の中に含まれていなければならないことを指定するために、形状内で sh:subsetOf を使用することを示している。

例 48: 2つの IRI プロパティ間に sh:subsetOf を持つ形状

sh:lessThan は、各値ノードが、フォーカスノードから sh:lessThan の値である SHACL プロパティパスを介して到達できるすべてのノードより小さい、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:lessThan`	値と比較するためのプロパティパス。形状内の `sh:lessThan` の値は、正形式の SHACL プロパティパスである。ノード形状は `sh:lessThan` についていかなる値も持つことができない。

テキスト定義

$lessThan を sh:lessThan の値とし、$path を形状グラフ内で $lessThan によって表される SHACL プロパティパスとする。 $otherNodes を、フォーカスノードから $path を介して到達できるノードの集合とする。値ノードと $otherNodes のメンバーとの各ペアについて、最初の値が2番目の値より小さくない場合（SPARQL の < 演算子に基づく）、または2つの値を比較できない場合、その値ノードを sh:value とする検証結果が存在する。

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

次の例は、ex:startDate のすべての値が ex:endDate の値より「前」であることを指定するために、形状内で sh:lessThan を使用することを示している。

例 49: 2つの IRI プロパティ間に sh:lessThan を持つ形状

sh:lessThanOrEquals は、各値ノードが、フォーカスノードから sh:lessThanOrEquals の値である SHACL プロパティパスを介して到達できるすべてのノード以下である、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:lessThanOrEquals`	値と比較するためのプロパティパス。形状内の `sh:lessThanOrEquals` の値は、正形式の SHACL プロパティパスである。ノード形状は `sh:lessThanOrEquals` についていかなる値も持つことができない。

テキスト定義

$lessThanOrEquals を sh:lessThanOrEquals の値とし、$path を、形状グラフ内で $lessThanOrEquals によって表される SHACL プロパティパスとする。 $otherNodes を、フォーカスノードから $path を介して到達できるノードの集合とする。値ノードと $otherNodes のメンバーとの各ペアについて、最初の値が2番目の値以下でない場合（SPARQL の <= 演算子に基づく）、または2つの値を比較できない場合、その値ノードを sh:value とする検証結果が存在する。

この節の制約コンポーネントは、一般的な論理演算子 and、or、not、および 排他的論理和 の変種を実装する。

sh:not は、各値ノードが、与えられた形状に適合できない、という条件を指定する。これは否定および論理的な "not" 演算子に相当する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:not`	否定する形状。形状内の `sh:not` の値は、正形式の形状でなければならない。

テキスト定義

$not を sh:not の値とする。各値ノード v について: 形状 $not に対する v の適合性チェックが失敗を生成する場合、失敗が報告されなければならない（MUST）。そうでなく、v が形状 $not に適合する場合、 v を sh:value とする検証結果が存在する。

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

次の例は、特定のフォーカスノードが ex:property のいかなる値も持てないという条件を指定するために、形状内で sh:not を使用することを示している。

例 50: 特定のフォーカスノードがプロパティのいかなる値も持てないことを指定する sh:not を持つ形状

sh:and は、各値ノードが、提供されたすべての形状に適合する、という条件を指定する。これは論理積および論理的な "and" 演算子に相当する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:and`	値ノードを検証する対象となる形状のSHACL リスト。形状内の `sh:and` の各値は、SHACL リストである。そのようなリストの各メンバーは、正形式の形状でなければならない。

テキスト定義

$and を sh:and の値とする。各値ノード v について: $and のメンバーのいずれかに対する v の適合性チェックが失敗を生成する場合、失敗が生成されなければならない（MUST）。そうでなく、v が $and の各メンバーに適合しない場合、 v を sh:value とする検証結果が存在する。

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

sh:and は値として形状のSHACL リストを持つが、それらの形状の順序は検証結果に影響しないことに注意されたい。ショートカット評価セマンティクスを使用する実装では、その順序が検証の効率に影響する場合がある。評価しやすい制約、または失敗する可能性が高い制約を、リストの前の方に置くことが推奨される。

次の例は、特定のフォーカスノードが ex:property の値をちょうど1つ持つという条件を指定するために、形状内で sh:and を使用することを示している。これは、最小カウントを指定する個別の名前付き形状（ex:SuperShape）と、追加で最大カウントを指定するプロパティ形状との論理積によって実現される。ここに示すように、sh:and は形状間の特殊化機構を実装するために使用できる。

例 51: sh:and の使用例

ex:SuperShape a sh:NodeShape ; sh:property [ sh:path ex:property ; sh:minCount 1 ; ] ; . ex:ExampleAndShape a sh:NodeShape ; sh:targetNode ex:ValidInstance, ex:InvalidInstance ; sh:and ( ex:SuperShape [ sh:path ex:property ; sh:maxCount 1 ; ] ) ; .

sh:or は、各値ノードが、提供された形状の少なくとも1つに適合する、という条件を指定する。これは論理和および論理的な "or" 演算子に相当する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:or`	値ノードを検証する対象となる形状のSHACL リスト。形状内の `sh:or` の各値は、SHACL リストである。そのようなリストの各メンバーは、正形式の形状でなければならない。

テキスト定義

$or を sh:or の値とする。各値ノード v について: いずれかのメンバーに対する v の適合性チェックが失敗を生成する場合、失敗が生成されなければならない（MUST）。そうでなく、v が $or のメンバーのいずれにも適合しない場合、 v を sh:value とする検証結果が存在する。

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

sh:or は値として形状のSHACL リストを持つが、それらの形状の順序は検証結果に影響しないことに注意されたい。ショートカット評価セマンティクスを使用する実装では、その順序が検証の効率に影響する場合がある。評価しやすい制約、または成功する可能性が高い制約を、リストの前の方に置くことが推奨される。

次の例は、特定のフォーカスノードが ex:firstName の値を少なくとも1つ、または ex:givenName の値を少なくとも1つ持つという条件を指定するために、形状内で sh:or を使用することを示している。

例 52: sh:or の使用例

次の例は、所与のプロパティ ex:address の値が、データ型 xsd:string を持つリテラル、またはクラス ex:Address のSHACL インスタンスのいずれかでよいことを述べるために、プロパティ形状内で sh:or を使用できることを示している。

例 53: プロパティ形状における sh:or の使用例

ex:PersonAddressShape a sh:NodeShape ; sh:targetClass ex:Person ; sh:property ex:PersonAddressShape-address ; . ex:PersonAddressShape-address a sh:PropertyShape ; sh:path ex:address ; sh:or ( [ sh:datatype xsd:string ; ] [ sh:class ex:Address ; ] ) .

SHACL におけるすべての制約は実行時に AND 結合されることに注意されたい。次の例を考える:

正しい解釈は、(shapeA OR shapeB) AND (shapeC OR shapeD) である。ターゲットノードは shapeA または shapeB に適合し、さらに shapeC または shapeD にも適合する必要がある。

sh:xone は、各値ノードが、提供された形状のうち ちょうど1つに適合する、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:xone`	値ノードを検証する対象となる形状のSHACL リスト。形状内の `sh:xone` の各値は、SHACL リストである。そのようなリストの各メンバーは、正形式の形状でMUST ある。そのような各リストは、少なくとも1つのメンバーを持つべきである（SHOULD）。

テキスト定義

$xone を sh:xone の値とする。各値ノード v について、 N を、$xone のメンバーである形状のうち、 v がその形状に適合するものの数とする。いずれかのメンバーに対する v の適合性チェックが失敗を生成する場合、失敗が生成されなければならない（MUST）。そうでなく、N がちょうど 1 でない場合、 v を sh:value とする検証結果が存在する。

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

sh:xone は値として形状のSHACL リストを持つが、それらの形状の順序は検証結果に影響しないことに注意されたい。

次の例は、特定のフォーカスノードが ex:fullName の値を持つか、または ex:firstName と ex:lastName の値を持つ必要があるが、両方であってはならない、という条件を指定するために、形状内で sh:xone を使用することを示している。

例 55: 論理和の論理積である条件を指定するための sh:xone の使用例

ex:XoneConstraintExampleShape a sh:NodeShape ; sh:targetClass ex:Person ; sh:xone ( [ sh:property [ sh:path ex:fullName ; sh:minCount 1 ; ] ] [ sh:property [ sh:path ex:firstName ; sh:minCount 1 ; ] ; sh:property [ sh:path ex:lastName ; sh:minCount 1 ; ] ] ) ; .

この節の制約コンポーネントは、特定の形状に対して値ノードを検証することにより、複雑な条件を指定するために使用できる。

sh:node は、各値ノードが、与えられたノード形状に適合する、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:node`	すべての値ノードが適合する必要のあるノード形状。形状内の `sh:node` の値は、正形式のノード形状でなければならない。

テキスト定義

$node を sh:node の値とする。各値ノード v について: $node に対する v の適合性チェックが失敗を生成する場合、失敗が生成されなければならない（MUST）。そうでなく、v が $node に適合しない場合、 v を sh:value とする検証結果が存在する。

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

次の例は、プロパティ形状内での sh:node の使用を示している。プロパティ ex:address のすべての値は、形状 ex:AddressShape によって表現される制約を満たさなければならない。

例 56: プロパティ形状における sh:node の例

ex:AddressShape a sh:NodeShape ; sh:property ex:AddressShape-postalCode ; . ex:AddressShape-postalCode a sh:PropertyShape ; sh:path ex:postalCode ; sh:datatype xsd:string ; sh:maxCount 1 ; . ex:PersonShape a sh:NodeShape ; sh:targetClass ex:Person ; sh:property ex:PersonShape-address ; . ex:PersonShape-address a sh:PropertyShape ; sh:path ex:address ; sh:minCount 1 ; sh:node ex:AddressShape ; .

[ a sh:ValidationReport ; sh:conforms false ; sh:result [ a sh:ValidationResult ; sh:resultSeverity sh:Violation ; sh:focusNode ex:Reto ; sh:resultPath ex:address ; sh:value ex:RetosAddress ; sh:resultMessage "Value does not conform to shape ex:AddressShape."@en ; sh:sourceConstraintComponent sh:NodeConstraintComponent ; sh:sourceShape ex:PersonShape-address ; ] ; ] .

次の例は、ノード形状内での sh:node の使用を示している。

例 57: ノード形状における sh:node の例

ex:PostalCodeShape a sh:NodeShape ; rdfs:label "Postal code"@en ; rdfs:comment "General constraints for postal codes around the world."@en ; sh:datatype xsd:string ; sh:minLength 3 ; . ex:AustralianPostalCode a sh:NodeShape ; rdfs:label "Postal code (Australia)"@en ; rdfs:comment "Constraints that specialize those from ex:PostalCodeShape."@en ; sh:intent "Australian postal codes consist of 4 digits."@en ; sh:pattern "^\\d{4}$" ; sh:minLength 4 ; sh:maxLength 4 ; sh:node ex:PostalCodeShape ; . ex:USZipCode a sh:NodeShape ; rdfs:label "Zip code (USA)"@en ; rdfs:comment "Constraints that specialize those from ex:PostalCodeShape."@en ; sh:intent "US zip codes are either 5 digits or 5 plus 4 with a dash in between."@en ; sh:pattern "^\\d{5}(-\\d{4})?$" ; sh:minLength 5 ; sh:maxLength 10 ; sh:node ex:PostalCodeShape ; .

この例は、郵便番号のための一般的な基本形状と、特定の国向けの2つの特殊化を定義する。 sh:datatype xsd:string や sh:minLength 3 などの基本制約は、すべての郵便番号に適用される。プロパティ sh:node は、rdfs:subClassOf がサブクラスをスーパークラスにリンクする方法と同様に、より狭い形状をより広い形状にリンクするために使用される。

SHACL における再帰的な形状の扱いについては、6.5.3 再帰的な形状の扱いを参照。

sh:property は、各値ノードが、与えられたプロパティ形状を持つことを指定するために使用できる。

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

パラメーター:

プロパティ	要約と構文規則
`sh:property`	すべての値ノードが持つ必要のあるプロパティ形状。形状内の `sh:property` の各値は、正形式のプロパティ形状でなければならない。

テキスト定義

$property を sh:property の値とする。各値ノード v について: プロパティ形状 $property に対して、v をフォーカスノードとして検証した結果が失敗を生成する場合、失敗が生成されなければならない（MUST）。そうでない場合、検証結果は、プロパティ形状 $property に対して、v をフォーカスノードとして検証する結果である。

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

sh:property と sh:node の間には重要な違いがあることに注意されたい: 値ノードが制約に違反している場合、sh:node についてはその値ノードに対して単一の検証結果のみが存在し、その sh:sourceConstraintComponent は sh:NodeConstraintComponent である。一方、sh:property については任意の数の検証結果が存在し得る。これらは、プロパティ形状内の制約の個々の制約コンポーネントを、 sh:sourceConstraintComponent の値として持つ。

他のすべての検証結果と同様に、プロパティ形状が sh:property を介して到達されるたびに、検証エンジンは新しい検証結果ノードを生成しなければならない（MUST）。これには、同じフォーカスノードが、形状グラフ内の異なるパスを介して到達されるにもかかわらず、同じプロパティ形状に対して検証される場合が含まれる。

sh:someValue は、少なくとも1つの値ノードが、与えられた形状に適合する、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:someValue`	値ノードの少なくとも1つが適合する必要のある形状。形状内の `sh:someValue` の値は、正形式の形状でなければならない。

テキスト定義

$someValue を sh:someValue の値とする。いずれかの値ノードに対する $someValue への適合性チェックが失敗を生成する場合、いずれか1つ以上の値ノードが $someValue に適合していない限り、失敗が生成されなければならない（MUST）。そうでなく、いずれの値ノードも $someValue に適合しない場合、検証結果が存在する。

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

実装は、いずれかの値ノードが適合した時点で値ノードの処理を停止してもよいことに注意されたい。値ノード集合におけるノードの順序は未定義であるため、失敗を引き起こすノードに到達する保証はない。したがって、処理を予測可能にするため、すべての値ノードが成功なしに訪問されない限り、失敗は暗黙に無視される。

次の例では、ex:DuckFarmerShape に適合する任意のノードは、 ex:tendsAnimal について、ex:Duck の SHACL インスタンスである値を少なくとも1つ持つ必要がある。

例 58: sh:someValue の使用例

sh:someValue は、sh:qualifiedValueShape と sh:qualifiedMinCount 1 の組み合わせに対する構文糖衣とみなすことができる。

また、sh:someValue は、プロパティ形状で使用される場合に主に意味を持つことにも注意されたい。ノード形状では、sh:someValue は sh:node または sh:property を使用することと同等である。

sh:qualifiedValueShape は、指定された数の値ノードが、与えられた形状に適合する、という条件を指定する。各 sh:qualifiedValueShape は、同じ主語において、sh:qualifiedMinCount の値を1つ、 sh:qualifiedMaxCount の値を1つ、またはそれぞれ1つずつ持つことができる。

パラメーター:

プロパティ	要約と構文規則
`sh:qualifiedValueShape`	指定された数の値ノードが適合する必要のある形状。形状内の `sh:qualifiedValueShape` の値は、正形式の形状でなければならない。ノード形状は `sh:qualifiedValueShape` についていかなる値も持つことができない。これは `sh:QualifiedMinCountConstraintComponent` および `sh:QualifiedMaxCountConstraintComponent` の必須パラメーターである。
`sh:qualifiedValueShapesDisjoint`	これは `sh:QualifiedMinCountConstraintComponent` および `sh:QualifiedMaxCountConstraintComponent` の任意パラメーターである。 `true` に設定された場合、（カウントのために）値ノードは兄弟形状のいずれにも適合してはならない。形状内の `sh:qualifiedValueShapesDisjoint` の値は、データ型 `xsd:boolean` を持つリテラルである。
`sh:qualifiedMinCount`	形状に適合する値ノードの最小数。形状内の `sh:qualifiedMinCount` の値は、データ型 `xsd:integer` を持つリテラルである。これは `sh:QualifiedMinCountConstraintComponent` の必須パラメーターである。
`sh:qualifiedMaxCount`	形状に適合できる値ノードの最大数。形状内の `sh:qualifiedMaxCount` の値は、データ型 `xsd:integer` を持つリテラルである。これは `sh:QualifiedMaxCountConstraintComponent` の必須パラメーターである。

兄弟形状のテキスト定義

Q を、形状グラフ G 内の形状であり、限定カーディナリティ制約を宣言しているもの（sh:qualifiedValueShape と、sh:qualifiedMinCount または sh:qualifiedMaxCount の少なくとも一方の値を持つことによって）とする。 ps を、Q を sh:property の値として持つ、G 内の形状の集合とする。 Q が sh:qualifiedValueShapesDisjoint について true を値として持つ場合、 Q の兄弟形状の集合は、ps 内の任意の形状について、 SPARQL プロパティパス sh:property/sh:qualifiedValueShape のすべての値から、Q 自身の sh:qualifiedValueShape の値を除いた集合として定義される。それ以外の場合、兄弟形状の集合は空である。

sh:qualifiedMinCount のテキスト定義

$qualifiedValueShape を sh:qualifiedValueShape の値とする。 $qualifiedMinCount を sh:qualifiedMinCount のパラメーター値とする。 C を、v が $qualifiedValueShape に適合し、かつ v が現在の形状、すなわち v が検証されていて、 $qualifiedValueShape を sh:qualifiedValueShape の値として持つ形状についての兄弟形状のいずれにも適合しない値ノード v の数とする。前述の適合性チェックのいずれかが失敗を生成する場合、失敗が生成されなければならない（MUST）。そうでなく、C が $qualifiedMinCount より小さい場合、検証結果が存在する。 sh:qualifiedMinCount の制約コンポーネントは sh:QualifiedMinCountConstraintComponent である。

sh:qualifiedMaxCount のテキスト定義

$qualifiedMaxCount を sh:qualifiedMaxCount のパラメーター値とする。 C を、上記の sh:qualifiedMinCount について定義されたものとする。前述の適合性チェックのいずれかが失敗を生成する場合、失敗が生成されなければならない（MUST）。そうでなく、C が $qualifiedMaxCount より大きい場合、検証結果が存在する。 sh:qualifiedMaxCount の制約コンポーネントは sh:QualifiedMaxCountConstraintComponent である。

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

次の例の形状は、プロパティ ex:parent がちょうど2つの値を持ち、そのうち少なくとも1つが女性であるという条件を指定するために使用できる。

例 59: 限定カーディナリティ制約を指定するための sh:qualifiedValueShape、sh:qualifiedMinCount、および sh:qualifiedMaxCount の使用例

ex:QualifiedValueShapeExampleShape a sh:NodeShape ; sh:targetNode ex:QualifiedValueShapeExampleValidResource ; sh:property ex:QualifiedValueShapeExampleShape-parent ; . ex:QualifiedValueShapeExampleShape-parent a sh:PropertyShape ; sh:path ex:parent ; sh:minCount 2 ; sh:maxCount 2 ; sh:qualifiedValueShape [ sh:path ex:gender ; sh:hasValue ex:female ; ] ; sh:qualifiedMinCount 1 ; .

次の例は、片手が ex:digit の値を最大5つ持たなければならないこと（sh:maxCount を用いて表現）、そのうちちょうど1つが ex:Thumb のインスタンスで、ちょうど4つが ex:Finger のインスタンスでなければならず、ただし親指と指は互いに素でなければならないことを表現するための sh:qualifiedValueShapesDisjoint の使用を示している。言い換えると、片手において、どの指も親指として数えられてはならない。

例 60: sh:qualifiedValueShapesDisjoint の使用例

ex:HandShape a sh:NodeShape ; sh:targetClass ex:Hand ; sh:property [ sh:path ex:digit ; sh:maxCount 5 ; ] ; sh:property [ sh:path ex:digit ; sh:qualifiedValueShape [ sh:class ex:Thumb ] ; sh:qualifiedValueShapesDisjoint true ; sh:qualifiedMinCount 1 ; sh:qualifiedMaxCount 1 ; ] ; sh:property [ sh:path ex:digit ; sh:qualifiedValueShape [ sh:class ex:Finger ] ; sh:qualifiedValueShapesDisjoint true ; sh:qualifiedMinCount 4 ; sh:qualifiedMaxCount 4 ; ] ; .

sh:reifierShape は、プロパティ形状を、1つ以上のノード形状にリンクするために使用できる。任意の具象化子は、これらのノード形状に適合しなければならない。

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

パラメーター:

プロパティ	要約と構文規則
`sh:reifierShape`	このトリプルの具象化子が適合しなければならないノード形状。 `sh:reifierShape` の値は、正形式のノード形状でなければならない。 `sh:reifierShape` の値が与えられた場合、`sh:path` の値は IRI に制限される。
`sh:reificationRequired`	これは `sh:ReifierShapeConstraintComponent` の任意パラメーターである。 `true` に設定された場合、データグラフ内で、フォーカスノード/パスの組み合わせについて少なくとも1つの具象化値が存在しなければならない。形状内の `sh:reificationRequired` の値は、データ型 `xsd:boolean` を持つリテラルである。

テキスト定義

tをトリプル項（フォーカスノード、 $path、値ノード）とする。各具体化子について、それがトリプル項tのものである場合、失敗を生成しなければならないのは、具体化子をノードシェイプ $reifierShapeに対して検証し、その具体化子をフォーカスノードとした結果、失敗が生成される場合である。各具体化子tについて、それが $reifierShapeに適合しない場合、tを sh:valueとする検証結果が存在する。

sh:reificationRequired のテキスト定義

$reificationRequired が true に設定されており、データグラフ内にトリプル項 t についての具象化文が存在しない場合、 t を sh:value とする検証結果が存在する。

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

例 61: sh:reifierShape および sh:reificationRequired の例

ex:PersonShape a sh:NodeShape ; sh:targetClass ex:Person ; sh:property ex:PersonShape-age ; . ex:PersonShape-age a sh:PropertyShape ; sh:path ex:age ; sh:datatype xsd:integer ; sh:minCount 1 ; sh:maxCount 1 ; sh:reifierShape ex:ProvenanceShape ; sh:reificationRequired true ; . ex:ProvenanceShape a sh:NodeShape ; sh:property ex:ProvenanceShape-date ; sh:property ex:ProvenanceShape-author ; . ex:ProvenanceShape-date a sh:PropertyShape ; sh:path ex:date ; sh:datatype xsd:date ; sh:minCount 1 ; sh:maxCount 1 ; . ex:ProvenanceShape-author a sh:PropertyShape ; sh:path ex:author ; sh:nodeKind sh:IRI ; sh:minCount 1 ; sh:maxCount 1 ; .

この例では、形状 ex:PersonShape は、ex:Person のすべてのインスタンスが ex:age の値を、形状 ex:ProvenanceShape に適合する具象化子で具象化しなければならない、すなわち ex:date と ex:author を指定する必要がある、と述べている。

この節では、他のカテゴリに当てはまらない Core 制約コンポーネントを列挙する。

RDF データモデルは非常に大きな柔軟性を提供する。任意のノードは、原則として任意のプロパティについて値を持つことができる。しかし、場合によっては、どのプロパティをノードに適用できるかについて条件を指定することが意味を持つ。 SHACL Core 言語には、sh:closed と呼ばれるプロパティが含まれており、各値ノードが、sh:property を介して形状に指定されたプロパティ形状によって明示的に列挙されたプロパティについてのみ値を持つ、という条件を指定するために使用できる。

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

パラメーター:

プロパティ	要約と構文規則
`sh:closed`	形状を閉じるには `true` に設定する。形状内の `sh:closed` の値は、データ型 `xsd:boolean` を持つリテラル、または IRI `sh:ByTypes` である。
`sh:ignoredProperties`	`sh:property` を介して明示的に列挙されたものに加えて許可されるプロパティの任意のSHACL リスト。形状内の `sh:ignoredProperties` の値は、SHACL リストでなければならない。そのようなリストの各メンバーは、 IRIでなければならない。

テキスト定義

$closed を sh:closed のパラメーター値とする。 $ignoredProperties を sh:ignoredProperties の値とする。

$closed が true または sh:ByTypes であり、 P が下で定義されるプロパティ集合である場合、値ノードをその主語とし、 P に含まれない述語を持つ各トリプルについて、検証結果が存在する。 $ignoredProperties が値を持つ場合、このSHACL リストのメンバーとして列挙されたプロパティも、値ノードについて許可される。検証結果は、そのトリプルの述語を sh:resultPath として持ち、そのトリプルの目的語を sh:value として持たなければならない（MUST）。

$closed が true である場合、P は、現在の形状から SPARQL パス sh:property/sh:path を介して到達できる IRI プロパティの集合である。

$closed が sh:ByTypes である場合、P は、次のアルゴリズムを介して値ノードから到達できる IRI プロパティの集合に rdf:type を加えたものである:

function collectProperties(S)
    SPARQL パス sh:property/sh:path を介して S から到達できるすべての
            IRI プロパティを追加する
    S が形状グラフ内で rdfs:Class の SHACL インスタンスである場合 {
        形状グラフ内で (S rdfs:subClassOf ?o) に一致する各トリプルについて
            collectProperties(?o)
        形状グラフ内で (?s sh:targetClass S) に一致する各トリプルについて
            collectProperties(?s)
    }
    S が形状グラフ内で sh:NodeShape の SHACL インスタンスである場合
        形状グラフ内で (S sh:node ?o) に一致する各トリプルについて
            collectProperties(?o)

データグラフ内の値ノードの各 rdf:type T について
    collectProperties(T)

実装は、上記のアルゴリズムで同じ S を2回訪問しないようにすることで、無限ループを避ける必要があることに注意されたい。

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

次の例は、特定のフォーカスノードが ex:firstName と ex:lastName についてのみ値を持つという条件を指定するために、形状内で sh:closed を使用することを示している。「無視される」プロパティ rdf:type も許可される。

例 62: sh:closed と sh:ignoredProperties の使用例

sh:closed sh:ByTypes のユースケースには、現在の値ノードの型のスーパークラスで宣言されたプロパティ（rdfs:subClassOf を介する）に加えて、 sh:targetClass を介してそれらの型にリンクされた他の形状、および sh:node を介してあるノード形状から別のノード形状へ到達できる形状が含まれる。 sh:ByTypes の例は、テストケースライブラリーで見つけることができる: closed-003.ttl, closed-004.ttl.

sh:hasValue は、少なくとも1つの値ノードが、与えられた RDF 項と等しい、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:hasValue`	特定の必須値。

テキスト定義

$hasValue を sh:hasValue のパラメーター値とする。 RDF 項 $hasValue が値ノードの中に含まれない場合、検証結果が存在する。

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

例 63: sh:hasValue の使用例

sh:in は、各値ノードが、提供された SHACL リストのメンバーである、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:in`	許可される値をメンバーとして持つ SHACL リスト。形状内の `sh:in` の各値は、SHACL リストである。形状は `sh:in` について最大1つの値を持つ。そのような各リストは、少なくとも1つのメンバーを持つべきである（SHOULD）。

テキスト定義

$in を sh:in の値とする。 $in のメンバーではない各値ノードについて、その値ノードを sh:value とする検証結果が存在する。

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

リテラルの一致は厳密である必要があることに注意されたい。たとえば "04"^^xsd:byte は "4"^^xsd:integer と一致しない。

例 64: sh:in の使用例

sh:rootClass によって指定される条件は、各値ノードが、与えられたクラス、またはそのクラスの（推移的な）サブクラスであることである。

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

パラメーター:

プロパティ	要約と構文規則
`sh:rootClass`	すべての値ノードが属さなければならないクラス階層のルート。形状内の `sh:rootClass` の値は、IRI、またはすべてのメンバーが IRIである正形式の SHACL リストである空白ノードのいずれかである。

テキストによる定義

$rootClassを、sh:rootClassのパラメーター値とする。 classesをIRIの集合とし、 $rootClassがIRI である場合、その集合はそのIRIのみを正確に含み、 $rootClassが空白ノードのSHACLリストである場合、その集合はリストのメンバーのみを正確に含むものとする。

値ノードが、IRI ではないか、またはIRIであり、かつ classes内に、データグラフが valueNode rdfs:subClassOf* classを伴意するようなclassが存在しない場合、その値ノードをsh:valueとする検証結果が存在する。

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

sh:rootClass 制約は通常、値としてクラスを持ち得るプロパティ形状（たとえば sh:class rdfs:Class を介する）とともに使用され、値ノードの許可されるサブクラス階層を制限する。与えられたクラスは、許可されるクラス階層の上限として機能する。

例 65: sh:rootClass の使用例

sh:uniqueValuesFor は、値ノードの1つ以上の指定されたプロパティの値が、現在の形状のすべてのターゲットノード内で一意でなければならない、という条件を指定する。

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

パラメーター:

プロパティ	要約と構文規則
`sh:uniqueValuesFor`	プロパティの IRI、または各メンバーがプロパティのIRIである SHACL リスト。

テキスト定義

$uniqueValuesFor を、シェイプ S における sh:uniqueValuesFor の値とする。 $properties を、次のような集合とする: $uniqueValuesFor が IRI である場合、 $properties = { uniqueValuesFor } とする。 $uniqueValuesFor が SHACL リストである場合、 $properties は、そのリストのメンバーの集合である。 $targetNodes を、S のターゲットノードとする。
$targetNodes 内に、V と同じく $properties 内のすべてのプロパティについて完全に同一の値を持つ別のノードが存在する各値ノード V について、検証結果が存在する。 V が $properties 内のいずれのプロパティについても値を持たない場合、結果は生成されない。

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

リテラルの一致は厳密である必要があることに注意されたい。たとえば "04"^^xsd:byte は "4"^^xsd:integer と一致しない。また、sh:uniqueValuesFor はこれらの値の存在を規定しないため、多くの場合 sh:minCount 1 制約と組み合わせられることにも注意されたい。

例 66: 単一プロパティに対する sh:uniqueValuesFor の例

ex:SingleIdExampleShape a sh:NodeShape ; sh:targetClass ex:Record ; sh:property ex:SingleIdExampleShape-id ; sh:uniqueValuesFor ex:id ; . ex:SingleIdExampleShape-id a sh:PropertyShape ; sh:path ex:id ; sh:minCount 1 ; sh:maxCount 1 ; .

この例では、ex:Record2 と ex:Record3 について2つの制約違反が報告される。なぜなら、それらは ex:id についてまったく同じ値を持ち、同じ形状のターゲット内にあるからである。

しかし、ex:id "One" については違反は報告されない。なぜなら ex:UnrelatedNode は ex:Record のインスタンスではなく、したがって ex:SingleIdExampleShape のターゲットではないからである。

ターゲットノードの計算は、形状の定義、たとえば sh:uniqueValuesFor 制約も保持している形状の sh:targetClass 宣言のみに依存することに注意されたい。

例 67: 2つのプロパティの組に対する sh:uniqueValuesFor の例

上記の例では、形状のフォーカスノードのいずれも、指定された2つのプロパティの同じ組み合わせを持たないため、違反は報告されない。

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

構文規則 ID	構文規則テキスト
SHACL-list	RDF グラフ `G` における SHACL リストは、 IRI または空白ノードであり、 `rdf:nil`（ただし `rdf:nil` が `rdf:first` または `rdf:rest` のいずれについても値を持たない場合）、または `G` においてプロパティ `rdf:first` についてちょうど1つの値を持ち、かつ `G` においてプロパティ `rdf:rest` について、 `G` における SHACL リストでもあるちょうど1つの値を持ち、さらにそのリストが `G` においてプロパティパス `rdf:rest+` の値として自分自身を持たないものである。
entailment-nodeKind	プロパティ `sh:entailment` の値は IRI である。
shape	形状は、 IRI または空白ノード `s` であり、形状グラフ内で次の条件の少なくとも1つを満たすものである: `s` が `sh:NodeShape` または `sh:PropertyShape` の SHACL インスタンスである。 `s` が、`sh:targetClass`、`sh:targetNode`、 `sh:targetObjectsOf` または `sh:targetSubjectsOf` を述語として持つトリプルの主語である。 `s` が、パラメーターを述語として持つトリプルの主語である。 `s` が、`sh:node` などの形状を期待する非リスト受け取りパラメーターの値であるか、または `sh:or` などの形状を期待するかつリスト受け取りパラメーターの値である SHACL リストのメンバーである。
multiple-parameters	`sh:PatternConstraintComponent` などの一部の制約コンポーネントは、複数のパラメーターを宣言する。そのようなコンポーネントのいずれかのパラメーターについて複数の値を持つ形状は不正形式である。
targetNode-nodeKind	形状内の `sh:targetNode` の各値は、正形式のノード式である。
targetClass-nodeKind	形状内の `sh:targetClass` の各値は IRIである。
implicit-targetClass-nodeKind	RDF グラフ `G` において `s` が `sh:NodeShape` または `sh:PropertyShape` の SHACL インスタンスであり、かつ `s` が `G` において `rdfs:Class` の SHACL インスタンスでもあり、かつ `s` が IRIでない場合、 `s` は `G` における不正形式の形状である。
targetSubjectsOf-nodeKind	形状内の `sh:targetSubjectsOf` の値は IRIである。
targetObjectsOf-nodeKind	形状内の `sh:targetObjectsOf` の値は IRIである。
targetWhere-node	形状内の `sh:targetWhere` の各値は、正形式の形状である。
shape-nodeKind	`sh:shape` の各値は IRIである。
severity-maxCount	形状は、形状グラフ内でプロパティ `sh:severity` について 1つの値を指定できる。
severity-nodeKind	`sh:severity` の各値は IRIである。
severity-reifier-maxCount	`T` を、形状内の制約を表すトリプルの集合とする。形状グラフは、`T` 内のトリプルの具象化子において、プロパティ `sh:severity` について最大1つの値を指定できる。
message-datatype	`sh:message` の値は、 `xsd:string`、`rdf:dirLangString`、`rdf:langString`、または `rdf:HTML` のデータ型を持つリテラルである。主語は、同じ言語タグを持つ `sh:message` の値を複数持つべきではなく、またデータ型 `xsd:string` を持つ複数の値も持つべきではない。
message-reifier-maxCount	`T` を、形状内の制約を表すトリプルの集合とする。形状グラフは、`T` 内のトリプルの具象化子において、プロパティ `sh:message` について最大1つの値を指定できる。
deactivated-maxCount	形状は、プロパティ `sh:deactivated` について最大1つの値を持つことができる。
deactivated-datatype	`sh:deactivated` の値はノード式であり、その（唯一の）出力ノードとして `true` または `false` のいずれかを持たなければならない。
deactivated-reified-maxCount	トリプルが形状を主語とし、 `sh:minCount` などのパラメーターを述語として持つ場合、そのトリプルは、プロパティ `sh:deactivated` について値を持つ具象化子を最大1つ持つことができる。
NodeShape-path-maxCount	`sh:NodeShape` の SHACL インスタンスは、プロパティ `sh:path` について値を持つことができない。
PropertyShape	プロパティ形状は、形状グラフ内の形状であり、 `sh:path` を述語として持つトリプルの主語である。
path-maxCount	形状は `sh:path` について最大1つの値を持つ。
path-node	プロパティ形状内の `sh:path` の値は、正形式の SHACL プロパティパスである。
PropertyShape-path-minCount	`sh:PropertyShape` の SHACL インスタンスは、プロパティ `sh:path` について1つの値を持つ。
path-values	プロパティ形状は、プロパティ `sh:values` について最大1つの値を持ち、この値は正形式のノード式である。
path-defaultValue	プロパティ形状は、プロパティ `sh:defaultValue` について最大1つの値を持ち、この値は正形式のノード式である。
path-values-iri	プロパティ形状は、 `sh:path` の値が述語パスである場合にのみ、 `sh:values` および/または `sh:defaultValue` について値を持つことができる。
path-metarule	RDF グラフ内のノードは、次の小節における構文規則のうちちょうど1つを満たす場合、正形式の SHACL プロパティパス `p` である。
path-non-recursive	ノード `p` は、`p` が空白ノードであり、 `p` の任意のパスマッピングが直接または推移的に `p` を参照する場合、正形式の SHACL プロパティパスではない。
path-sequence	シーケンスパスは、少なくとも2つのメンバーを持つ SHACL リストである空白ノードであり、各メンバーは正形式の SHACL プロパティパスである。
path-alternative	代替パスは、 `G` 内でちょうど1つのトリプルの主語である空白ノードである。このトリプルは `sh:alternativePath` を述語、`L` を目的語として持ち、 `L` は少なくとも2つのメンバーを持つ SHACL リストであり、 `L` の各メンバーは正形式の SHACL プロパティパスである。
path-inverse	逆パスは、`G` 内のちょうど1つのトリプルの主語である空白ノードである。このトリプルは `sh:inversePath` を述語として持ち、目的語 `v` は正形式の SHACL プロパティパスである。
path-zero-or-more	ゼロ回以上パスは、`G` 内のちょうど1つのトリプルの主語である空白ノードである。このトリプルは `sh:zeroOrMorePath` を述語として持ち、目的語 `v` は正形式の SHACL プロパティパスである。
path-one-or-more	1回以上パスは、`G` 内のちょうど1つのトリプルの主語である空白ノードである。このトリプルは `sh:oneOrMorePath` を述語として持ち、目的語 `v` は正形式の SHACL プロパティパスである。
path-zero-or-one	ゼロ回または1回パスは、`G` 内のちょうど1つのトリプルの主語である空白ノードである。このトリプルは `sh:zeroOrOnePath` を述語として持ち、目的語 `v` は正形式の SHACL プロパティパスである。
IRIExpression-syntax	RDF グラフ内のノードは、それが IRIである場合、正形式の IRI 式である。
LiteralExpression-syntax	RDF グラフ内のノードは、それがリテラルである場合、正形式のリテラル式である。
ShapesGraph	`sh:ShapesGraph`クラスは、通常シェイプグラフの役割を果たすグラフのIRIの `rdf:type`として使用してもよい。
DataGraph	`sh:DataGraph`クラスは、通常データグラフとして使用されるグラフのIRIの`rdf:type` として使用してもよい。
shapesGraph-nodeKind	`sh:shapesGraph`のすべての値はIRIである
class-nodeKind	シェイプ内の`sh:class`の値は、IRI または、すべてのメンバーがIRIである整形式のSHACLリストである空白ノードのいずれかである。
datatype-maxCount	シェイプは`sh:datatype`について最大で1つの値を持つ。
datatype-nodeKind	シェイプ内の`sh:datatype`の値は、IRI または、すべてのメンバーがIRIである整形式のSHACLリストである空白ノードのいずれかである。
nodeKind-maxCount	シェイプは`sh:nodeKind`について最大で1つの値を持つ。
nodeKind-in	`sh:nodeKind`の値がIRIである場合、シェイプ内の`sh:nodeKind`の値は、クラス`sh:NodeKind`の次の7つのインスタンスのいずれかである： `sh:BlankNode`、`sh:IRI`、`sh:Literal` `sh:BlankNodeOrIRI`、`sh:BlankNodeOrLiteral`、`sh:IRIOrLiteral`、および`sh:TripleTerm`。 `sh:nodeKind`の値が整形式のSHACLリストである場合、シェイプ内のそれらのリストのメンバーは、クラス`sh:NodeKind`の次の4つのインスタンスのいずれかである： `sh:BlankNode`、`sh:IRI`、`sh:Literal`、および `sh:TripleTerm`。
minCount-scope	ノードシェイプは、 `sh:minCount`の値を持つことができない。
minCount-maxCount	プロパティシェイプは、 `sh:minCount`について最大で1つの値を持つ。
minCount-datatype	プロパティシェイプ内の`sh:minCount`の値は、データ型 `xsd:integer`を持つリテラルである。
maxCount-scope	ノードシェイプは、 `sh:maxCount`の値を持つことができない。
maxCount-maxCount	プロパティシェイプは、 `sh:maxCount`について最大で1つの値を持つ。
maxCount-datatype	プロパティシェイプ内の`sh:maxCount`の値は、データ型 `xsd:integer`を持つリテラルである。
minExclusive-nodeKind	シェイプ内の`sh:minExclusive`の値はリテラルである。
minExclusive-maxCount	シェイプは`sh:minExclusive`について最大で1つの値を持つ。
minInclusive-nodeKind	シェイプ内の`sh:minInclusive`の値はリテラルである。
minInclusive-maxCount	シェイプは`sh:minInclusive`について最大で1つの値を持つ。
maxExclusive-nodeKind	シェイプ内の`sh:maxExclusive`の値はリテラルである。
maxExclusive-maxCount	シェイプは`sh:maxExclusive`について最大で1つの値を持つ。
maxInclusive-nodeKind	シェイプ内の`sh:maxInclusive`の値はリテラルである。
maxInclusive-maxCount	シェイプは`sh:maxInclusive`について最大で1つの値を持つ。
minLength-datatype	シェイプ内の`sh:minLength`の値は、データ型 `xsd:integer`を持つリテラルである。
minLength-maxCount	シェイプは`sh:minLength`について最大で1つの値を持つ。
maxLength-datatype	シェイプ内の`sh:maxLength`の値は、データ型 `xsd:integer`を持つリテラルである。
maxLength-maxCount	シェイプは`sh:maxLength`について最大で1つの値を持つ。
pattern-datatype	シェイプ内の`sh:pattern`の値は、データ型`xsd:string`を持つリテラルである。
pattern-regex	シェイプ内の`sh:pattern`の値は、SPARQL REGEX関数の有効なパターン引数である。
flags-datatype	シェイプ内の`sh:flags`の値は、データ型`xsd:string`を持つリテラルである。
singleLine-datatype	シェイプ内の`sh:singleLine`の値は、データ型 `xsd:boolean`を持つリテラルである。
singleLine-maxCount	シェイプは`sh:singleLine`について最大で1つの値を持つ。
languageIn-node	シェイプ内の`sh:languageIn`の各値はSHACLリストである。
languageIn-members-datatype	そのようなリストの各メンバーは、データ型 `xsd:string`を持つリテラルである。
languageIn-maxCount	シェイプは`sh:languageIn`について最大で1つの値を持つ。
uniqueLang-datatype	シェイプ内の`sh:uniqueLang`の値は、データ型 `xsd:boolean`を持つリテラルである。
uniqueLang-maxCount	プロパティシェイプは`sh:uniqueLang`について最大で1つの値を持つ。
uniqueLang-scope	ノードシェイプは、 `sh:uniqueLang`の値を持つことができない。
memberShape-node	`sh:memberShape`の値は、整形式のノードシェイプでなければならない。
minListLength-datatype	シェイプ内の`sh:minListLength`の値は、データ型 `xsd:integer`を持つリテラルである。
minListLength-minInclusive	シェイプ内の`sh:minListLength`の値は、0以上の整数である。
maxListLength-datatype	シェイプ内の`sh:maxListLength`の値は、データ型 `xsd:integer`を持つリテラルである。
maxListLength-minInclusive	シェイプ内の`sh:maxListLength`の値は、0以上の整数である。
uniqueMembers-datatype	シェイプ内の`sh:uniqueMembers`の値は、データ型 `xsd:boolean`を持つリテラルである。
equals-nodeKind	シェイプ内の`sh:equals`の値は、整形式のSHACLプロパティパスである。
disjoint-nodeKind	シェイプ内の`sh:disjoint`の値は、整形式のSHACLプロパティパスである。
subsetOf-nodeKind	シェイプ内の`sh:subsetOf`の値は、整形式のSHACLプロパティパスである。
lessThan-nodeKind	シェイプ内の`sh:lessThan`の値は、整形式のSHACLプロパティパスである。
lessThan-scope	ノードシェイプは、 `sh:lessThan`の値を持つことができない。
lessThanOrEquals-nodeKind	シェイプ内の`sh:lessThanOrEquals`の値は、整形式のSHACLプロパティパスである。
lessThanOrEquals-scope	ノードシェイプは、 `sh:lessThanOrEquals`の値を持つことができない。
not-node	シェイプ内の`sh:not`の値は、整形式のシェイプでなければならない。
and-node	シェイプ内の`sh:and`の各値はSHACLリストである。
and-members-node	そのようなリストの各メンバーは、整形式のシェイプでなければならない。
or-node	シェイプ内の`sh:or`の各値はSHACLリストである。
or-members-node	そのようなリストの各メンバーは、整形式のシェイプでなければならない。
xone-node	シェイプ内の`sh:xone`の各値はSHACLリストである。
xone-members-node	そのようなリストの各メンバーは、整形式のシェイプでなければならない。
xone-minListLength	そのような各リストは、少なくとも1つのメンバーを持つことが望ましい。
node-node	シェイプ内の`sh:node`の値は、整形式のノードシェイプでなければならない。
property-node	シェイプ内の`sh:property`の各値は、整形式のプロパティシェイプでなければならない。
someValue-shape	シェイプ内の`sh:someValue`の値は、整形式のシェイプでなければならない。
qualifiedValueShape-node	シェイプ内の`sh:qualifiedValueShape`の値は、整形式のシェイプでなければならない。
qualifiedValueShape-scope	ノードシェイプは、 `sh:qualifiedValueShape`の値を持つことができない。
qualifiedValueShapesDisjoint-datatype	シェイプ内の`sh:qualifiedValueShapesDisjoint`の値は、データ型 `xsd:boolean`を持つリテラルである。
qualifiedMinCount-datatype	シェイプ内の`sh:qualifiedMinCount`の値は、データ型 `xsd:integer`を持つリテラルである。
qualifiedMaxCount-datatype	シェイプ内の`sh:qualifiedMaxCount`の値は、データ型 `xsd:integer`を持つリテラルである。
reifierShape-node	`sh:reifierShape`の値は、整形式のノードシェイプでなければならない。 `sh:reifierShape`の値が指定された場合、`sh:path`の値はIRIに制約される。
reificationRequired-datatype	シェイプ内の`sh:reificationRequired`の値は、データ型 `xsd:boolean`を持つリテラルである。
closed-datatype	シェイプ内の`sh:closed`の値は、データ型`xsd:boolean`を持つリテラルまたはIRI `sh:ByTypes`である。
ignoredProperties-node	シェイプ内の`sh:ignoredProperties`の値は、SHACLリストでなければならない。
ignoredProperties-members-nodeKind	そのようなリストの各メンバーはIRIでなければならない。
in-node	シェイプ内の`sh:in`の各値はSHACLリストである。
in-maxCount	シェイプは`sh:in`について最大で1つの値を持つ。
in-minListLength	そのような各リストは、少なくとも1つのメンバーを持つことが望ましい。
rootClass-nodeKind	シェイプ内の`sh:rootClass`の値は、IRI または、すべてのメンバーがIRIである整形式のSHACLリストである空白ノードのいずれかである。
uniqueValuesFor-node	プロパティのIRI、または各メンバーがプロパティのIRIであるSHACLリスト。

この節は、SHACL Core のすべての規範的なバリデーターを列挙する。この節は、この仕様の他の部分から自動的に生成されており、バリデーターの文脈が不明確な場合に本文へ戻るハイパーリンクが提供されている。

制約コンポーネント別のバリデーター
sh:ClassConstraintComponent: `$class`を、`sh:class`のパラメーター値とする。 `classes`をIRIの集合とし、 `$class`がIRIである場合、その集合はそのIRIのみを正確に含み、 `$class`が空白ノードのSHACLリストである場合、その集合はリストのメンバーのみを正確に含むものとする。リテラルであるか、またはデータグラフ内の`classes`のいずれのSHACLインスタンスでもない非リテラルである各値ノードについて、その値ノードを `sh:value`とする検証結果が存在する。
sh:DatatypeConstraintComponent: `$datatype`を、`sh:datatype`のパラメーター値とする。 `datatypes`をIRIの集合とし、 `$datatype`がIRIである場合、その集合はそのIRIのみを正確に含み、 `$datatype`が空白ノードのSHACLリストである場合、その集合はリストのメンバーのみを正確に含むものとする。値ノードがリテラルではないか、またはいずれの `datatypes`にも一致しないデータ型を持つリテラルである場合、その値ノードを `sh:value`とする検証結果が存在する。リテラルのデータ型は、SPARQL 1.2のデータ型関数に従って決定される。リテラルは、そのリテラルのデータ型が同じIRIを持ち、かつ、SPARQL 1.2でサポートされるデータ型については、型が不正なリテラルでない場合、そのデータ型と一致する。
sh:NodeKindConstraintComponent: `$nodeKind`を、`sh:nodeKind`のパラメーター値とする。 `$nodeKinds`をIRIの集合とし、 `$nodeKind`がIRIである場合、その集合はそのIRIのみを正確に含み、 `$nodeKind`が空白ノードのSHACLリストである場合、その集合はリストのメンバーのみを正確に含むものとする。いずれの`$nodeKinds`にも一致しない各値ノードについて、その値ノードを `sh:value`とする検証結果が存在する。すべてのIRIは、`sh:IRI`、 `sh:BlankNodeOrIRI`および`sh:IRIOrLiteral`にのみ一致する。すべての空白ノードは、`sh:BlankNode`、 `sh:BlankNodeOrIRI`および`sh:BlankNodeOrLiteral`にのみ一致する。すべてのリテラルは、`sh:Literal`、 `sh:BlankNodeOrLiteral`および`sh:IRIOrLiteral`にのみ一致する。すべてのトリプル項は、`sh:TripleTerm`にのみ一致する。
sh:MinCountConstraintComponent: `$minCount`を、`sh:minCount`のパラメーター値とする。値ノードの数が`$minCount`未満である場合、検証結果が存在する。
sh:MaxCountConstraintComponent: `$maxCount`を、`sh:maxCount`のパラメーター値とする。値ノードの数が`$maxCount`を超える場合、検証結果が存在する。
sh:MinExclusiveConstraintComponent: `$minExclusive`を、`sh:minExclusive`のパラメーター値とする。 SPARQL式`$minExclusive < v`が`true`を返さない各値ノード`v`について、 `v`を`sh:value`とする検証結果が存在する。
sh:MinInclusiveConstraintComponent: `$minInclusive`を、`sh:minInclusive`のパラメーター値とする。 SPARQL式`$minInclusive <= v`が`true`を返さない各値ノード`v`について、 `v`を`sh:value`とする検証結果が存在する。
sh:MaxExclusiveConstraintComponent: `$maxExclusive`を、`sh:maxExclusive`のパラメーター値とする。 SPARQL式`$maxExclusive > v`が`true`を返さない各値ノード`v`について、 `v`を`sh:value`とする検証結果が存在する。
sh:MaxInclusiveConstraintComponent: `$maxInclusive`を、`sh:maxInclusive`のパラメーター値とする。 SPARQL式`$maxInclusive >= v`が`true`を返さない各値ノード`v`について、 `v`を`sh:value`とする検証結果が存在する。
sh:MinLengthConstraintComponent: `$minLength`を、`sh:minLength`のパラメーター値とする。 `v`の文字列表現（SPARQL str関数で定義される）の長さ（SPARQL STRLEN関数で定義される）が `$minLength`未満であるか、または`v`が空白ノードである各値ノード`v`について、 `v`を`sh:value`とする検証結果が存在する。
sh:MaxLengthConstraintComponent: `$maxLength`を、`sh:maxLength`のパラメーター値とする。 `v`の文字列表現（SPARQL str関数で定義される）の長さ（SPARQL STRLEN関数で定義される）が `$maxLength`を超えるか、または`v`が空白ノードである各値ノード`v`について、 `v`を`sh:value`とする検証結果が存在する。
sh:PatternConstraintComponent: `$pattern`を、`sh:pattern`のパラメーター値とする。 `$flags`を、`sh:flags`のパラメーター値とする。空白ノードであるか、または文字列表現（SPARQL str関数で定義される）が正規表現`$pattern`（SPARQL REGEX関数で定義される）に一致しない各値ノードについて、その値ノードを `sh:value`とする検証結果が存在する。 `$flags`が値を持つ場合、照合は`$flags`を第3引数として使用し、 SPARQL REGEX関数の3引数版の定義に従わなければならない。
sh:SingleLineConstraintComponent: `$singleLine`を、`sh:singleLine`のパラメーター値とする。 `$singleLine`が`true`である場合、字句形式が正規表現（SPARQL REGEX関数で定義される） `[\f\r\n\v]`に一致するリテラルである各値ノードについて、検証結果が存在する。
sh:LanguageInConstraintComponent: `$languageIn`を、`sh:languageIn`の値とする。リテラルではないか、またはSPARQL langMatches関数によって定義されるフィルタリング方式に従い、`$languageIn`のメンバーであるいずれの基本言語範囲にも一致する言語タグを持たない各値ノードについて、その値ノードを `sh:value`とする検証結果が存在する。
sh:UniqueLangConstraintComponent: `$uniqueLang`を、`sh:uniqueLang`のパラメーター値とする。 `$uniqueLang`が`true`である場合、少なくとも2つの値ノードによって使用される空でない各言語タグについて、検証結果が存在する。データ型`rdf:dirLangString`の値ノードでは、基本方向が一意性条件に含まれる。たとえば、`"1"@ar--rtl`と`"1"@ar-ltr`は異なり、 `"1"@ar--rtl`と`"1"@ar`の組も同様に異なる。
sh:MemberShapeConstraintComponent: `$memberShape`を、`sh:memberShape`のパラメーター値とする。各値ノード`v`はSHACLリストでなければならない。`v`がSHACLリストでない場合、検証結果が存在する。 SHACLリスト`v`のいずれかのメンバー`m`が `$memberShape`に適合しない場合、検証結果が存在する。
sh:MinListLengthConstraintComponent: `$minListLength`を、`sh:minListLength`のパラメーター値とする。各値ノード`v`はSHACLリストでなければならない。`v`がSHACLリストでない場合、検証結果が存在する。リスト`v`のメンバー数が`$minListLength`未満である場合、検証結果が存在する。
sh:MaxListLengthConstraintComponent: `$maxListLength`を、`sh:maxListLength`のパラメーター値とする。各値ノード`v`はSHACLリストでなければならない。`v`がSHACLリストでない場合、検証結果が存在する。リスト`v`のメンバー数が`$maxListLength`を超える場合、検証結果が存在する。
sh:UniqueMembersConstraintComponent: `$uniqueMembers`を、`sh:uniqueMembers`のパラメーター値とする。各値ノード`v`はSHACLリストでなければならない。`v`がSHACLリストでない場合、検証結果が存在する。 `$uniqueMembers`が`true`で、リスト`v`に重複するメンバーがある場合、検証結果が存在する。
sh:EqualsConstraintComponent: `$equals`を`sh:equals`の値とし、`$path`をシェイプグラフ内で`$equals`によって表されるSHACLプロパティパスとする。 `$otherNodes`を、フォーカスノードから `$path`を介して到達できるノードの集合とする。 `$otherNodes`に存在しない各値ノードについて、その値ノードを `sh:value`とする検証結果が存在する。 `$otherNodes`内にあり、値ノードのいずれでもない各ノードについて、その値を `sh:value`とする検証結果が存在する。
sh:DisjointConstraintComponent: `$disjoint`を`sh:disjoint`のパラメーター値とし、 `$path`をシェイプグラフ内で `$disjoint`によって表されるSHACLプロパティパスとする。 `$otherNodes`を、フォーカスノードから `$path`を介して到達できるノードの集合とする。 `$otherNodes`にも含まれる各値ノードについて、その値ノードを `sh:value`とする検証結果が存在する。
sh:SubsetOfConstraintComponent: `$subsetOf`を`sh:subsetOf`の値とし、`$path`をシェイプグラフ内で`$subsetOf`によって表されるSHACLプロパティパスとする。 `$otherNodes`を、フォーカスノードから `$path`を介して到達できるノードの集合とする。 `$otherNodes`に存在しない各値ノードについて、その値ノードを `sh:value`とする検証結果が存在する。
sh:LessThanConstraintComponent: `$lessThan`を`sh:lessThan`の値とし、`$path`をシェイプグラフ内で`$lessThan`によって表されるSHACLプロパティパスとする。 `$otherNodes`を、フォーカスノードから `$path`を介して到達できるノードの集合とする。値ノードと`$otherNodes`のメンバーの各組について、最初の値が2番目の値未満でない場合（SPARQLの`<`演算子に基づく）、または2つの値を比較できない場合、その値ノードを `sh:value`とする検証結果が存在する。
sh:LessThanOrEqualsConstraintComponent: `$lessThanOrEquals`を`sh:lessThanOrEquals`の値とし、 `$path`をシェイプグラフ内で `$lessThanOrEquals`によって表されるSHACLプロパティパスとする。 `$otherNodes`を、フォーカスノードから `$path`を介して到達できるノードの集合とする。値ノードと`$otherNodes`のメンバーの各組について、最初の値が2番目の値以下でない場合（SPARQLの`<=`演算子に基づく）、または2つの値を比較できない場合、その値ノードを `sh:value`とする検証結果が存在する。
sh:NotConstraintComponent: `$not`を`sh:not`の値とする。各値ノード`v`について、シェイプ`$not`に対する`v`の適合性検査が失敗を生成した場合、失敗を報告しなければならない。それ以外の場合、`v`がシェイプ`$not`に適合するならば、 `v`を`sh:value`とする検証結果が存在する。
sh:AndConstraintComponent: `$and`を`sh:and`の値とする。各値ノード`v`について、 `$and`のいずれかのメンバーに対する`v`の適合性検査が失敗を生成した場合、失敗を生成しなければならない。それ以外の場合、`v`が`$and`の各メンバーに適合しないならば、 `v`を`sh:value`とする検証結果が存在する。
sh:OrConstraintComponent: `$or`を`sh:or`の値とする。各値ノード`v`について、いずれかのメンバーに対する`v`の適合性検査が失敗を生成した場合、失敗を生成しなければならない。それ以外の場合、`v`が`$or`のいずれのメンバーにも適合しないならば、 `v`を`sh:value`とする検証結果が存在する。
sh:XoneConstraintComponent: `$xone`を`sh:xone`の値とする。各値ノード`v`について、 `N`を、`$xone`のメンバーであり、 `v`がそのシェイプに適合するシェイプの数とする。いずれかのメンバーに対する`v`の適合性検査が失敗を生成した場合、失敗を生成しなければならない。それ以外の場合、`N`が正確に`1`でなければ、 `v`を`sh:value`とする検証結果が存在する。
sh:NodeConstraintComponent: `$node`を`sh:node`の値とする。各値ノード`v`について、 `$node`に対する`v`の適合性検査が失敗を生成した場合、失敗を生成しなければならない。それ以外の場合、`v`が`$node`に適合しないならば、 `v`を`sh:value`とする検証結果が存在する。
sh:PropertyConstraintComponent: `$property`を`sh:property`の値とする。各値ノード`v`について、プロパティシェイプ`$property`に対し、`v`をフォーカスノードとして検証した結果、失敗が生成された場合、失敗を生成しなければならない。それ以外の場合、検証結果は、プロパティシェイプ`$property`に対し、 `v`をフォーカスノードとして検証する結果である。
sh:SomeValueConstraintComponent: `$someValue`を`sh:someValue`の値とする。少なくとも1つの値ノードが `$someValue`に適合する場合を除き、いずれかの値ノードに対する `$someValue`の適合性検査が失敗を生成した場合、失敗を生成しなければならない。それ以外の場合、いずれの値ノードも`$someValue`に適合しないならば、検証結果が存在する。
sh:QualifiedMinCountConstraintComponent: `$qualifiedValueShape`を `sh:qualifiedValueShape`の値とする。 `$qualifiedMinCount`を、`sh:qualifiedMinCount`のパラメーター値とする。 `C`を、`$qualifiedValueShape`に適合し、かつ現在のシェイプのいずれの兄弟シェイプにも適合しない値ノード`v`の数とする。ここで現在のシェイプとは、`v`の検証対象であり、 `sh:qualifiedValueShape`の値として`$qualifiedValueShape`を持つシェイプである。前述の適合性検査のいずれかが失敗を生成した場合、失敗を生成しなければならない。それ以外の場合、`C`が`$qualifiedMinCount`未満であれば、検証結果が存在する。 `sh:qualifiedMinCount`の制約コンポーネントは、 `sh:QualifiedMinCountConstraintComponent`である。
sh:QualifiedMaxCountConstraintComponent: `$qualifiedMaxCount`を、`sh:qualifiedMaxCount`のパラメーター値とする。 `C`を、上記の`sh:qualifiedMinCount`について定義されたものとする。前述の適合性検査のいずれかが失敗を生成した場合、失敗を生成しなければならない。それ以外の場合、`C`が`$qualifiedMaxCount`を超えるならば、検証結果が存在する。 `sh:qualifiedMaxCount`の制約コンポーネントは、 `sh:QualifiedMaxCountConstraintComponent`である。
sh:ReifierShapeConstraintComponent: `t`をトリプル項（フォーカスノード、 `$path`、値ノード）とする。各具体化子について、それがトリプル項`t`のものである場合、失敗を生成しなければならないのは、具体化子をノードシェイプ `$reifierShape`に対して検証し、その具体化子をフォーカスノードとした結果、失敗が生成される場合である。各具体化子`t`について、それが `$reifierShape`に適合しない場合、`t`を `sh:value`とする検証結果が存在する。
sh:ReificationRequiredConstraintComponent: `$reificationRequired`が`true`に設定され、データグラフ内のトリプル項`t`について具体化されたステートメントが存在しない場合、 `t`を`sh:value`とする検証結果が存在する。
sh:ClosedConstraintComponent: `$closed`を、`sh:closed`のパラメーター値とする。 `$ignoredProperties`を、`sh:ignoredProperties`の値とする。 `$closed`が`true`または`sh:ByTypes`であり、`P`が以下で定義されるプロパティの集合である場合、値ノードを主語とし、`P`に含まれない述語を持つ各トリプルについて、検証結果が存在する。 `$ignoredProperties`が値を持つ場合、このSHACLリストのメンバーとして列挙されるプロパティも、値ノードに対して許可される。検証結果は、トリプルの述語を`sh:resultPath`として持ち、トリプルの目的語を`sh:value`として持たなければならない。 `$closed`が`true`である場合、`P`は、 SPARQLパス`sh:property/sh:path`を介して現在のシェイプから到達できるIRIプロパティの集合である。 `$closed`が`sh:ByTypes`である場合、`P`は、次のアルゴリズムを介して値ノードから到達できるIRIプロパティに`rdf:type`を加えた集合である。 function collectProperties(S) add all IRI properties that can be reached from S via the SPARQL path sh:property/sh:path if S is a SHACL instance of rdfs:Class in the shapes graph { for each triple in the shapes graph matching (S rdfs:subClassOf ?o) collectProperties(?o) for each triple in the shapes graph matching (?s sh:targetClass S) collectProperties(?s) } if S is a SHACL instance of sh:NodeShape in the shapes graph for each triple in the shapes graph matching (S sh:node ?o) collectProperties(?o) for each rdf:type T of the value node in the data graph collectProperties(T) 実装は、上記のアルゴリズムが同じ`S`を2回訪問しないようにすることで、無限ループを回避する必要があることに注意されたい。
sh:HasValueConstraintComponent: `$hasValue`を、`sh:hasValue`のパラメーター値とする。 RDF項`$hasValue`が値ノードに含まれない場合、検証結果が存在する。
sh:InConstraintComponent: `$in`を`sh:in`の値とする。 `$in`のメンバーではない各値ノードについて、その値ノードを `sh:value`とする検証結果が存在する。
sh:RootClassConstraintComponent: `$rootClass`を、`sh:rootClass`のパラメーター値とする。 `classes`をIRIの集合とし、 `$rootClass`がIRIである場合、その集合はそのIRIのみを正確に含み、 `$rootClass`が空白ノードのSHACLリストである場合、その集合はリストのメンバーのみを正確に含むものとする。値ノードがIRIではないか、またはIRIであり、かつ`classes`内に、データグラフが `valueNode rdfs:subClassOf* class`を伴意するような`class`が存在しない場合、その値ノードを `sh:value`とする検証結果が存在する。
sh:UniqueValuesForConstraintComponent: `$uniqueValuesFor`をシェイプ`S`内の `sh:uniqueValuesFor`の値とする。 `$properties`を次の集合とする。 `$uniqueValuesFor`が`IRI`である場合、 `$properties = { uniqueValuesFor }`とする。 `$uniqueValuesFor`がSHACLリストである場合、 `$properties`はそのリストのメンバーの集合である。 `$targetNodes`を`S`のターゲットノードとする。 `$targetNodes`内に、`$properties`のすべてのプロパティについて `V`と正確に同じ値を持つ別のノードが存在する各値ノード`V`について、検証結果が存在する。 `V`が`$properties`内のいずれのプロパティについても値を持たない場合、結果は生成されない。

first name:	John
last name:	Doe

street address:	123 Silverado Ave
locality:	Cupertino
zip code:	54321

SHACL 1.2 コア

要約

この文書のステータス

SHACL 仕様

文書の概略

1. はじめに

1.1 用語

1.2 文書の表記規則

1.3 適合性

1.4 SHACL と RDFS 推論の関係

2. SHACL Core 入門

2.1 ユースケース

2.2 サンプルデータ（データグラフ）

2.3 形状と クラスを書く（形状グラフ）

2.4 検証の 実行（検証レポート）

2.5 形状とクラスの 構文上のバリエーション

2.6 いくつかの SHACL 用語の導入

3. 形状と制約

3.1 形状

3.1.1 制約、パラメーター、および制約コンポーネント

3.1.2 フォーカスノード

3.1.3 ターゲット

3.1.3.1 ノードターゲット （sh:targetNode）

3.1.3.2 クラスベースのターゲット（sh:targetClass）

3.1.3.3 暗黙のクラスターゲットと sh:ShapeClass

3.1.3.4 subjects-of ターゲット（sh:targetSubjectsOf）

3.1.3.5 objects-of ターゲット（sh:targetObjectsOf）

3.1.3.6 Where ターゲット （sh:targetWhere）

3.1.3.7 明示的な 形状ターゲット（sh:shape）

3.1.4 形状または制約の重大度の宣言

3.1.5 形状または制約のメッセージの宣言

3.1.6 形状と制約の 無効化

3.2 ノード形状

3.3 プロパティ形状

4. SHACL プロパティパス

4.1 述語パス

4.2 シーケンスパス

4.3 代替パス

4.4 逆パス

4.5 ゼロ回以上のパス

4.6 1回以上のパス

4.7 ゼロ回または1回のパス

5. ノード式

5.1 IRI 式

5.2 リテラル式

6. 検証とグラフ

6.1 形状グラフ

6.2 データグラフ

6.3 rdfs:subClassOf トリプルのためのグラフ

6.4 データ グラフを形状グラフにリンクする（sh:shapesGraph）

6.5 検証

6.5.1 失敗

6.5.2 不正形式の 形状グラフの扱い

6.5.3 再帰的な 形状の扱い

6.6 適合性検査

6.6.1 シェイプグラフへの適合 (sh:conformsToShapesGraph)

6.7 検証レポート

6.7.1 検証 レポート (sh:ValidationReport)

6.7.1.1 適合 (sh:conforms)

6.7.1.2 適合性不許可集合 (sh:conformanceDisallows)

6.7.1.3 結果 (sh:result)

6.7.1.4 シェイプグラフの構文検査 (sh:shapesGraphWellFormed)

6.7.1.5 使用されたデータ グラフ (sh:usedDataGraph)

6.7.1.6 使用された シェイプグラフ (sh:usedShapesGraph)

6.7.1.7 使用された 構成 (sh:usedConfiguration)

6.7.1.8 プロセッサー構成 (sh:ProcessorConfiguration)

6.7.2 検証 結果 (sh:ValidationResult)

6.7.2.1 フォーカスノード (sh:focusNode)

6.7.2.2 パス (sh:resultPath)

6.7.2.3 値 (sh:value)

6.7.2.4 ソース (sh:sourceShape)

6.7.2.5 制約コンポーネント (sh:sourceConstraintComponent)

6.7.2.6 詳細 (sh:detail)

6.7.2.7 メッセージ (sh:resultMessage)

6.7.2.8 重大度 (sh:resultSeverity)

6.8 値ノード

6.8.1 ノード形状の値ノード

6.8.2 プロパティ形状の 値ノード

7. コア制約コンポーネント

7.1 値型制約 コンポーネント

2.3 形状とクラスを書く（形状グラフ）

2.4 検証の実行（検証レポート）

2.5 形状とクラスの構文上のバリエーション

3.1.3.1 ノードターゲット（sh:targetNode）

3.1.3.6 Where ターゲット（sh:targetWhere）

3.1.3.7 明示的な形状ターゲット（sh:shape）

3.1.6 形状と制約の無効化

6.4 データグラフを形状グラフにリンクする（sh:shapesGraph）

6.5.2 不正形式の形状グラフの扱い

6.5.3 再帰的な形状の扱い

6.7.1 検証レポート (sh:ValidationReport)

6.7.1.2 適合性不許可集合 (`sh:conformanceDisallows`)

6.7.1.5 使用されたデータグラフ (sh:usedDataGraph)

6.7.1.6 使用されたシェイプグラフ (sh:usedShapesGraph)

6.7.1.7 使用された構成 (sh:usedConfiguration)

6.7.2 検証結果 (sh:ValidationResult)

6.8.2 プロパティ形状の値ノード

7.1 値型制約コンポーネント

7.2 カーディナリティ制約コンポーネント

7.3 値範囲制約コンポーネント

7.4 文字列ベース制約コンポーネント

7.6 プロパティ対制約コンポーネント

7.8 形状ベース制約コンポーネント

8. 検証を行わない形状特性

D. セキュリティとプライバシーの考慮事項

E.1 この仕様で定義される用語