SHACL 1.2 SPARQL 관련 기능

개요

이 문서는 SHACL Shapes Constraint Language의 SPARQL 관련 기능을 정의합니다. SHACL의 Core 부분은 shape의 기본 구문과 SHACL에서 지원하는 가장 일반적인 constraint component를 정의하는 반면, SPARQL 관련 기능은 SPARQL을 통해 Core의 표현력을 확장합니다. 특히 이 문서는 SPARQL을 사용하여 constraint와 constraint component를 정의하는 방법을 정의합니다. 또한 이 문서는 node 목록을 도출하는 데 사용할 수 있는 SPARQL 기반 node expression을 소개합니다. 마지막으로 이 문서는 SHACL node expression을 기반으로 새로운 SPARQL 함수를 정의하기 위한 선언적 메커니즘을 정의합니다.

이 문서는 Shapes Constraint Language(SHACL)의 SPARQL 관련 기능을 명세합니다.

이 문서 전체에서 다음 용어가 사용됩니다.

이 문서에서 정의하는 SHACL의 SPARQL 관련 기능은 때때로 SHACL-SPARQL이라고 합니다.

RDF 1.2 Concepts and Abstract Syntax의 일부에 링크된 용어는 해당 문서에서 정의된 대로 SHACL-SPARQL에서 사용됩니다. SPARQL 1.2 Query Language의 일부에 링크된 용어는 해당 문서에서 정의된 대로 SHACL-SPARQL에서 사용됩니다. SHACL 1.2 Core의 일부에 링크된 용어는 해당 문서에서 정의된 대로 SHACL-SPARQL에서 사용됩니다. 하나의 링크만으로도 이 문서에서 특정 용어가 나타나는 모든 경우에 대한 정의를 제공하기에 충분합니다.

정의는 이 문서 안에서 완결됩니다. 즉, 이 문서 안에서 어떤 상황을 참으로 만드는 규칙이 없다면 그 상황은 거짓입니다.

기본 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 코어 명세 [shacl12-core]에 정의되어 있습니다.

Binding, Solution

binding은 (variable, RDF term)의 쌍이며, [sparql12-query]에서의 용어 사용과 일치합니다. solution은 각 variable이 고유해야 하는 bindings의 집합입니다. 비공식적으로, solution은 흔히 SPARQL query의 결과 테이블 본문에서 한 행으로 이해됩니다.

SHACL의 구문은 RDF입니다. 이 문서의 예제는 Turtle [rdf12-turtle]을 사용합니다. RDF/XML과 같은 다른 RDF 직렬화도 실제로 사용될 수 있습니다. 독자는 triples와 같은 기본 RDF 개념 [rdf12-concepts] 및 SPARQL [sparql12-query]에 익숙해야 합니다.

이 문서에서는 다음 namespace prefix bindings가 사용됩니다.

접두사	네임스페이스
`owl:`	`http://www.w3.org/2002/07/owl#`
`rdf:`	`http://www.w3.org/1999/02/22-rdf-syntax-ns#`
`rdfs:`	`http://www.w3.org/2000/01/rdf-schema#`
`sh:`	`http://www.w3.org/ns/shacl#`
`xsd:`	`http://www.w3.org/2001/XMLSchema#`
`ex:`	`http://example.com/ns#`
`shnex:`	`http://www.w3.org/ns/shacl-node-expr#`
`sparql:`	`http://www.w3.org/ns/sparql#`

이 문서에서는 다음 JSON-LD context가 사용됩니다.

{
  "@context": {
    "owl": "http://www.w3.org/2002/07/owl#",
    "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
    "rdfs": "http://www.w3.org/2000/01/rdf-schema#",
    "sh": "http://www.w3.org/ns/shacl#",
    "xsd": "http://www.w3.org/2001/XMLSchema#",
    "ex": "http://example.com/ns#",
    "shnex": "http://www.w3.org/ns/shacl-node-expr#",
    "sparql": "http://www.w3.org/ns/sparql#"
  }
}

SHACL vocabulary 자체를 정의하는 graph의 URI는 위 namespace와 동일합니다. 즉, #를 포함합니다. 예를 들어 owl:imports를 통한 SHACL vocabulary 참조는 #를 포함해야 합니다.

문서 전체에서 Turtle의 RDF graphs를 포함하는 색상 구분 상자가 나타납니다. 이러한 Turtle 문서 조각은 위에 제시된 prefix bindings를 사용합니다.

# This box represents an input shapes graph <s> ex:p <o> .

// This box represents an input shapes graph

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

# 이 상자는 입력 데이터 그래프를 나타냅니다.

{
	"@graph": [
	]
}

# This box represents an output results graph

// This box represents an output results graph

{}

SHACL Definitions는 파란색 상자에 나타납니다.

SPARQL 또는 TEXTUAL DEFINITIONS

# This box contains SPARQL or textual definitions.

이와 같은 회색 상자는 shapes graph에 적용되는 구문 규칙을 포함합니다.

$ 표시를 사용하는 SPARQL 변수는 실행 전에 미리 바인딩되는 외부 사전 바인딩 또는 $PATH의 경우 SPARQL 쿼리에서 치환되는 외부 바인딩을 나타냅니다(자세한 내용은 3.3 SPARQL 기반 제약 조건을 사용한 검증에 설명되어 있습니다).

true는 RDF term "true"^^xsd:boolean을 나타냅니다. false는 RDF term "false"^^xsd:boolean을 나타냅니다.

비규범적으로 표시된 절뿐만 아니라 이 명세의 모든 작성 지침, 다이어그램, 예제 및 참고 사항도 비규범적입니다. 이 명세의 나머지 모든 내용은 규범적입니다.

이 문서에서 사용하는 핵심 단어 MAY, MUST, MUST NOT, OPTIONAL 및 SHOULD는 여기에 표시된 것처럼 모두 대문자로 작성된 경우에만 BCP 14 [RFC2119] [RFC8174]에 설명된 대로 해석해야 합니다.

이 문서는 SHACL Core를 확장하는 SHACL-SPARQL 언어를 정의합니다. 이 명세는 다음에 대한 적합성 기준을 설명합니다.

SHACL-SPARQL 검증 처리기는 3. SPARQL 기반 제약 조건 및 4. SPARQL 기반 제약 조건 구성 요소를 사용한 SHACL 검증을 지원하는 처리기입니다(테스트 모음에서는 SPARQLValidation으로 식별됩니다). 이러한 처리기는 추가로 5. 주석 속성을 지원해도 MAY 됩니다. 이를 지원하는 처리기는 해당 절의 규칙을 반드시 MUST 따라야 합니다.
SPARQL 노드 표현식 처리기는 6. SPARQL 기반 노드 표현식을 평가할 수 있는 처리기입니다(테스트 모음에서는 SPARQLNodeExpr로 식별됩니다).
SPARQL 사용자 정의 함수 처리기는 7. 노드 표현식을 기반으로 하는 SPARQL 함수 선언을 평가할 수 있는 처리기입니다(테스트 모음에서는 SPARQLCustomFunctions로 식별됩니다).

올바른 형식에 관한 논의는 SHACL Core의 적합성 절도 참조하세요.

참고

SHACL 1.2 추론 규칙 명세 [shacl12-inference-rules]는 SHACL을 위한 추가적인 SPARQL 기반 기능을 정의합니다.

이 절에서는 SPARQL 쿼리의 네임스페이스 접두사를 선언하기 위해 이 문서 전체에서 사용되는 메커니즘을 소개합니다.

도형 그래프는 네임스페이스 접두사 선언을 포함할 수 있으며, 이를 통해 동일한 도형 그래프에서 파생된 SPARQL 쿼리를 이러한 접두사로 축약할 수 있습니다. 이러한 접두사 선언의 구문은 다음 예시에 나와 있습니다.

예제 1: 셰이프 그래프의 접두사 선언

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

{
	"@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 속성에 대해 정확히 하나의 값을 갖습니다. sh:prefix의 값은 데이터 유형이 xsd:string인 리터럴입니다. 접두사 선언은 sh:namespace 속성에 대해 정확히 하나의 값을 갖습니다. sh:namespace의 값은 데이터 유형이 xsd:anyURI 또는 xsd:string인 리터럴입니다. 이러한 값의 쌍은 접두사에서 네임스페이스로의 단일 매핑을 지정합니다. sh:declare 속성의 값은 접두사 선언입니다.

sh:declare 값에 권장되는 주어는 해당 접두사를 사용하는 도형을 포함하는 명명된 그래프의 IRI입니다. 이러한 IRI는 흔히 sh:ShapesGraph 또는 owl:Ontology의 인스턴스로 선언되지만, 반드시 그래야 하는 것은 아닙니다.

특히 접두사 선언은 SPARQL 기반 제약 조건, SPARQL 기반 제약 조건 구성 요소의 검증기, SPARQL 기반 노드 표현식 및 SPARQL 기반 추론 규칙 등에서 사용할 수 있습니다. 이러한 노드는 sh:prefixes 속성을 사용하여 접두사 매핑 집합을 지정할 수 있습니다. sh:prefixes 속성의 사용 예시는 다음 예제에서 확인할 수 있습니다.

sh:prefixes의 값은 IRI 또는 빈 노드입니다. SHACL 처리기는 값으로 사용되는 모든 개별 접두사 매핑의 합집합으로 접두사 매핑 집합을 수집합니다. 이러한 매핑은 SPARQL 속성 경로 sh:prefixes/(^owl:versionIRI)?/(owl:imports/(^owl:versionIRI)?)*/sh:declare의 SPARQL 기반 제약 조건, 검증기 또는 SPARQL 기반 노드 표현식에 해당합니다. (^owl:versionIRI)? 요소는 owl:versionIRI로 참조되는 그래프를 지원합니다. 이는 sh:prefixes의 값으로 직접 참조하거나 owl:imports를 통해 참조하는 경우 모두 해당합니다. 접두사 선언을 수집하고 추가 owl:imports를 따라가기 전에 버전 IRI에서 셰이프 그래프 IRI로 이동합니다. 이렇게 수집된 접두사 선언에 동일한 sh:prefix의 값에 대해 서로 다른 네임스페이스가 여러 개 포함되어 있다면, 셰이프 그래프는 형식이 올바르지 않습니다. (SHACL 처리기는 도달하지 않는 접두사 선언을 무시해도 MAY 됩니다.)

SPARQL 기반 제약 조건, 검증기 또는 SPARQL 기반 노드 표현식에 sh:prefixes의 값이 없다면 SHACL 처리기는 접두사 선언을 사용합니다. 이는 셰이프 그래프에서 값으로 사용되는 sh:declare의 선언으로, SHACL 인스턴스인 owl:Ontology, sh:DataGraph, sh:ShapesGraph, 또는 sh:RulesGraph(sh:ShapesGraph의 하위 클래스)에 지정되어 있습니다.

SHACL 처리기는 sh:select의 값(및 sh:ask, sh:construct와 같은 유사한 속성의 값)을 SPARQL로 변환할 때 모든 접두사 매핑에 대한 PREFIX 선언을 앞에 추가합니다. 각 sh:prefix 값은 PNAME_NS로 변환되며, 각 sh:namespace 값은 PREFIX 선언의 IRIREF로 변환됩니다. 위의 셰이프 그래프 예제에서 SHACL-SPARQL 처리기는 PREFIX ex: <http://example.com/ns#>와 같은 행을 생성합니다. 결과 쿼리 문자열을 유효한 SPARQL 1.2 쿼리로 파싱할 수 없다면 SHACL-SPARQL 처리기는 반드시 MUST 실패를 발생시켜야 합니다.

이 문서의 나머지 부분에서는 간결성을 위해 sh:prefixes 문을 생략했을 수 있습니다.

SHACL-SPARQL은 SPARQL SELECT 쿼리를 기반으로 제한을 표현하는 데 사용할 수 있는 제약 조건 구성 요소를 지원합니다.

제약 조건 구성 요소 IRI: sh:SPARQLConstraintComponent

매개변수:

속성	요약
`sh:sparql`	평가할 SPARQL 쿼리를 선언하는 SPARQL 기반 제약 조건.

SPARQL 기반 제약 조건의 구문 규칙과 유효성 검사 절차는 이 절의 나머지 부분에서 정의합니다.

이 절은 비규범적입니다.

다음 예시는 SPARQL 기반 제약 조건의 구문을 보여 줍니다.

예시 2: SPARQL 기반 제약 조건

ex:LanguageExampleShape a sh:NodeShape ; sh:targetClass ex:Country ; sh:sparql [ a sh:SPARQLConstraint ; # 이 트리플은 선택 사항입니다 sh:message "값은 독일어 언어 태그가 있는 리터럴입니다." ; 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 [] . # 접두사 선언 참조

{
	"@graph": [
		{
			"@id": "ex:LanguageExampleShape",
			"@type": "sh:NodeShape",
			"sh:sparql": {
				"@type": "sh:SPARQLConstraint",
				"sh:message": "값은 독일어 언어 태그가 있는 리터럴입니다.",
				"sh:prefixes": {
					"@id": "http://example.com/ns#"
				},
				"sh:select": "\n\t\t\tSELECT $this (ex:germanLabel AS ?path) ?value\n\t\t\tWHERE {\n\t\t\t\t$this ex:germanLabel ?value .\n\t\t\t\tFILTER (!isLiteral(?value) || !langMatches(lang(?value), \"de\"))\n\t\t\t}\n\t\t\t"
			},
			"sh:targetClass": {
				"@id": "ex:Country"
			}
		},
		{
			"@id": "http://example.com/ns#",
			"sh:declare": {
				"@id": "_:b1"
			}
		}
	]
}

위 도형의 대상에는 ex:Country의 모든 SHACL 인스턴스가 포함됩니다. 이러한 노드(this 변수로 나타냄)에 대해 SPARQL 쿼리는 ex:germanLabel의 값을 순회하고 해당 값이 독일어 언어 코드를 가진 리터럴인지 확인합니다.

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 변수의 모든 바인딩에 대해 결과 집합의 솔루션을 반환합니다. 해당 결과 집합의 각 솔루션에는 나중에 설명하는 매핑 규칙을 적용한 하나의 유효성 검사 결과가 있습니다. 이 예시에서 각 유효성 검사 결과는 this 변수의 바인딩을 sh:focusNode로, ex:germanLabel을 sh:resultPath로, 위반 값을 sh:value로 갖습니다.

다음 예시는 위와 유사하지만 속성 도형을 사용하는 시나리오를 보여 줍니다.

예제 3: 속성 셰이프의 SPARQL 기반 제약 조건

ex:LanguageExamplePropertyShape a sh:PropertyShape ; sh:targetClass ex:Country ; sh:path ex:germanLabel ; sh:sparql [ a sh:SPARQLConstraint ; # 이 트리플은 선택 사항입니다 sh:message "값은 독일어 언어 태그가 있는 리터럴입니다." ; sh:prefixes ex: ; sh:select """ SELECT $this ?value WHERE { $this $PATH ?value . FILTER (!isLiteral(?value) || !langMatches(lang(?value), "de")) } """ ; ] . ex: sh:declare [] . # 접두사 선언 참조

{
	"@graph": [
		{
			"@id": "ex:LanguageExamplePropertyShape",
			"@type": "sh:PropertyShape",
			"sh:path": {
				"@id": "ex:germanLabel"
			},
			"sh:sparql": {
				"@type": "sh:SPARQLConstraint",
				"sh:message": "값은 독일어 언어 태그가 있는 리터럴입니다.",
				"sh:prefixes": {
					"@id": "http://example.com/ns#"
				},
				"sh:select": "\n\t\t\tSELECT $this ?value\n\t\t\tWHERE {\n\t\t\t\t$this $PATH ?value .\n\t\t\t\tFILTER (!isLiteral(?value) || !langMatches(lang(?value), \"de\"))\n\t\t\t}\n\t\t\t"
			},
			"sh:targetClass": {
				"@id": "ex:Country"
			}
		},
		{
			"@id": "http://example.com/ns#",
			"sh:declare": {
				"@id": "_:b1"
			}
		}
	]
}

도형은 sh:sparql 속성에 대한 값을 가질 수 있으며, 이러한 값은 IRI 또는 공백 노드입니다. 이러한 값을 SPARQL 기반 제약 조건이라고 합니다.

SPARQL 기반 제약 조건은 sh:select 속성에 대해 정확히 하나의 값을 갖습니다. sh:select의 값은 데이터 유형이 xsd:string인 리터럴입니다. sh:SPARQLConstraint 클래스는 SHACL 어휘에 정의되어 있으며 이러한 제약 조건의 유형으로 사용할 수 있습니다(유형이 요구되지는 않음). 접두사 처리 규칙을 사용할 때 sh:select의 값은 유효한 SPARQL 1.2 SELECT 쿼리입니다. sh:select의 값에서 파생된 SPARQL 쿼리는 SELECT 절에서 this 변수를 프로젝션합니다.

다음 두 속성은 도형에서의 사용 방식과 유사합니다.

SPARQL 기반 제약 조건은 sh:message 속성의 값을 가질 수 있으며, 이러한 값은 리터럴이고 데이터 유형은 xsd:string, rdf:dirLangString, rdf:langString 또는 rdf:HTML입니다. 동일한 언어 태그를 가진 sh:message 값이 둘 이상 있어서는 안 되며, 데이터 유형이 xsd:string인 값도 여러 개 있어서는 안 됩니다. SPARQL 기반 제약 조건은 sh:deactivated 속성의 값을 최대 하나 가질 수 있습니다. 이 값은 노드 표현식이며, 셰이프의 경우와 마찬가지로 유일한 출력 노드가 true 또는 false여야 합니다. SPARQL 기반 제약 조건은 sh:severity 속성의 값을 최대 하나 가질 수 있으며, 이 값은 IRI입니다.

속성 셰이프의 맥락에서 사용되는 SELECT 쿼리는 셰이프에서 사용하는 경로의 자리표시자로 PATH라는 특수 변수를 사용합니다.

SPARQL 기반 제약 조건과 SELECT 기반 검증기의 SPARQL 쿼리에서 PATH 변수를 합법적으로 사용할 수 있는 유일한 위치는 술어 위치이며, 이는 트리플 패턴 내의 위치입니다. PATH 변수를 다른 위치에서 사용하는 쿼리는 형식이 올바르지 않습니다.

PATH 변수는 속성 셰이프에 대해서만 치환됩니다. 노드 셰이프의 SPARQL 쿼리에서는 바인딩되지 않은 변수로 남습니다.

이 절에서는 sh:SPARQLConstraintComponent의 검증기를 설명합니다. 이 검증기는 가능한 구현 전략 중 하나만 설명하며, SHACL 처리기는 결과가 동등하다면 다른 접근 방식을 선택할 수 있습니다.

텍스트 정의

$sparql을 sh:sparql의 값이라고 하겠습니다. $sparql이 sh:deactivated 속성에 대해 expr이라는 값을 가지고 있으며, evalExpr(expr, 데이터 그래프, 포커스 노드, {})가 유일한 출력 노드로 true를 생성한다면, 해당 제약 조건은 비활성화되며 검증 결과는 없습니다. 그렇지 않으면 SPARQL 기반 제약 조건 $sparql이 지정한 SPARQL 쿼리를 실행하면서 3.3.1 SPARQL 제약 조건의 사전 바인딩된 변수 $this에 설명된 대로 this 변수를 사전 바인딩합니다. 셰이프가 속성 셰이프라면 실행 전에 술어 위치에 나타나는 PATH 변수를 치환합니다. 이 위치는 트리플 패턴의 술어 위치이며, 치환에는 속성 셰이프에서 sh:path를 통해 지정한 SHACL 속성 경로의 유효한 SPARQL 표면 구문 문자열을 사용합니다. failure 변수의 바인딩이 true가 아닌 각 해에 대해 하나의 검증 결과가 있습니다. 이러한 검증 결과는 MUST 3.3.2 해의 바인딩을 결과 속성에 매핑하기에 설명된 속성 값을 반드시 가져야 합니다. $sparql에 sh:severity의 값이 있다면 검증 결과는 MUST 해당 값을 유일한 sh:resultSeverity 값으로 반드시 가져야 합니다. 해 중 하나에서 failure의 바인딩이 true인 경우에만, 그리고 반드시 그 경우에 실패를 MUST 생성해야 합니다.

SPARQL 기반 제약 조건의 SPARQL 쿼리와 SPARQL 기반 제약 조건 구성 요소의 검증기가 처리될 때, SHACL-SPARQL 프로세서는 $this 변수의 값을 현재 포커스 노드로 사전 바인딩합니다.

유효성 검사 결과 노드의 속성 값은 결과 솔루션과 제약 조건 자체의 값을 조합하여 다음 규칙에 따라 파생됩니다. 규칙은 위에서 아래로 실행되며, 처음 바인딩된 값을 사용합니다.

속성	생성 규칙
`sh:focusNode`	`this` 변수의 바인딩
`sh:resultPath`	`path` 변수의 바인딩이 IRI인 경우 해당 바인딩 속성 도형에서 생성된 결과의 경우, 해당 도형의 `sh:path` 값과 동등한 SHACL 속성 경로
`sh:value`	`value` 변수의 바인딩 값 노드
`sh:resultMessage`	`message` 변수의 바인딩 SPARQL 기반 제약 조건의 경우: SPARQL 기반 제약 조건의 `sh:message` 값. SPARQL 기반 제약 조건 구성 요소의 경우: SPARQL 기반 제약 조건 구성 요소의 검증기에 있는 `sh:message` 값. SPARQL 기반 제약 조건 구성 요소의 경우: SPARQL 기반 제약 조건 구성 요소의 `sh:message` 값. 그렇지 않으면 도형 또는 제약 조건에서 메시지를 선언하는 기본 메커니즘이 적용됩니다. 이러한 메시지 리터럴에는 `{?varName}` 또는 `{$varName}`을 통해 모든 SELECT 결과 변수의 이름이 포함될 수 있습니다. 제약 조건이 SPARQL 기반 제약 조건 구성 요소를 기반으로 하면 구성 요소의 매개변수 이름도 사용할 수 있습니다. 이러한 `{?varName}` 및 `{$varName}` 블록은 해당 변수 값의 적절한 문자열 표현으로 대체하는 것이 좋습니다.
`sh:sourceConstraint`	SPARQL 기반 제약 조건, 즉 `sh:sparql`의 값

failure 변수는 예약되어 있으며 결과 속성에 매핑되지 않습니다. 위에서 정의한 대로, failure의 해가 true를 바인딩 값으로 가지면 실패를 생성하며, 검증 결과는 생성하지 않습니다.

SPARQL 기반 제약 조건은 높은 유연성을 제공하지만 일부 사람에게는 이해하기 어렵거나 반복을 유발할 수 있습니다. 이 절에서는 SPARQL의 복잡성을 추상화하고 Core 제약 조건 구성 요소와 유사한 고수준의 재사용 가능한 구성 요소를 선언하기 위한 방법으로 SPARQL 기반 제약 조건 구성 요소를 소개합니다. 이러한 제약 조건 구성 요소는 SHACL RDF 어휘를 사용하여 선언할 수 있으므로 공유하고 재사용할 수 있습니다.

이 절은 비규범적입니다.

다음 예시는 SHACL-SPARQL 언어를 사용하여 SPARQL로 새로운 제약 조건 구성 요소를 지정하는 방법을 보여 줍니다. 이 예시는 각 값 노드가 주어진 정규식과 일치하는지 검증하기 위해 sh:pattern과 sh:flags를 SPARQL ASK 쿼리로 구현합니다. 이는 예시 구현일 뿐이며 규범적인 것으로 간주해서는 안 됩니다.

예시 4: SPARQL 기반 제약 조건 구성 요소

sh:PatternConstraintComponent a sh:ConstraintComponent ; sh:parameter [ sh:path sh:pattern ; ] ; sh:parameter [ sh:path sh:flags ; sh:optional true ; ] ; sh:validator ex:hasPattern . ex:hasPattern a sh:SPARQLAskValidator ; sh:message "값이 패턴 {$pattern}과 일치하지 않습니다" ; sh:ask """ ASK { FILTER (!isBlank($value) && IF(bound($flags), regex(str($value), $pattern, $flags), regex(str($value), $pattern))) }""" .

{
	"@graph": [
		{
			"@id": "ex:hasPattern",
			"@type": "sh:SPARQLAskValidator",
			"sh:ask": "\n\t\tASK {\n\t\t\tFILTER (!isBlank($value) &&\n\t\t\t\tIF(bound($flags), regex(str($value), $pattern, $flags), regex(str($value), $pattern)))\n\t\t}",
			"sh:message": "값이 패턴 {$pattern}과 일치하지 않습니다"
		},
		{
			"@id": "sh:PatternConstraintComponent",
			"@type": "sh:ConstraintComponent",
			"sh:parameter": [
				{
					"sh:path": {
						"@id": "sh:pattern"
					}
				},
				{
					"sh:optional": {
						"@type": "xsd:boolean",
						"@value": "true"
					},
					"sh:path": {
						"@id": "sh:flags"
					}
				}
			],
			"sh:validator": {
				"@id": "ex:hasPattern"
			}
		}
	]
}

제약 조건 컴포넌트가 선언되면 다음 예에 설명된 것처럼 해당 매개변수를 도형에서 사용할 수 있습니다.

예 5: SPARQL을 기반으로 하는 제약 조건 컴포넌트

ex:CaseInsensitiveSearch a sh:NodeShape ; sh:property [ sh:path ex:code ; sh:pattern "^[A-Z]{3}[0-9]{2}$" ; sh:flags "i" ; # 대소문자를 구분하지 않는 일치 ] .

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

제약 조건 구성 요소는 도형 내에서 제약 조건을 식별하고 검증하는 방법에 관한 지침을 유효성 검사 엔진에 제공합니다. 일반적으로 도형 S가 속성 p에 대한 값을 가지며, p를 매개변수로 지정하는 제약 조건 구성 요소 C가 있고, S가 C의 모든 필수 매개변수에 대한 값을 가지면, 이러한 매개변수 값 집합(선택적 매개변수 포함)은 제약 조건을 선언하며 유효성 검사 엔진은 이 제약 조건을 검증하기 위해 C에서 적절한 검증기를 사용합니다. 위 예시에서 sh:PatternConstraintComponent는 필수 매개변수 sh:pattern, 선택적 매개변수 sh:flags, 그리고 노드 도형 또는 속성 도형을 검증하는 데 사용할 수 있는 검증기를 선언합니다.

SPARQL 기반 제약 조건 구성 요소는 도형 그래프에서 SHACL 유형 sh:ConstraintComponent를 갖는 IRI입니다.

이 문서에서 새로운 제약 조건 구성 요소를 선언하는 메커니즘은 SPARQL 기반 구성 요소로 제한됩니다. 그러나 매개변수와 검증기를 선언하는 일반 구문은 JavaScript와 같은 다른 확장 언어에서도 작동하도록 설계되었습니다.

제약 조건 구성 요소의 매개변수는 sh:parameter 속성을 통해 선언됩니다. sh:parameter의 값을 매개변수 선언이라고 합니다. sh:Parameter 클래스는 매개변수 선언의 유형으로 사용할 수 있지만 이러한 트리플이 요구되지는 않습니다. 각 매개변수 선언은 sh:path 속성에 대해 정확히 하나의 값을 갖습니다. 매개변수 선언에서 sh:path의 값은 IRI입니다.

IRI의 로컬 이름은 IRI 끝에 있는 가장 긴 NCNAME으로 정의되며, IRI의 첫 번째 콜론 바로 뒤에 오는 것은 제외됩니다. 매개변수 선언의 매개변수 이름은 sh:path 값의 로컬 이름으로 정의됩니다. 매개변수에서 SPARQL 변수로 올바르게 매핑할 수 있도록 다음 구문 규칙이 적용됩니다.

모든 매개변수 이름은 유효한 SPARQL VARNAME입니다. 매개변수 이름은 다음 중 하나여서는 안 됩니다. this, path, PATH, value, message, failure. 둘 이상의 매개변수 선언에서 동일한 매개변수 이름을 사용하는 제약 조건 구성 요소는 형식이 올바르지 않습니다.

sh:optional의 값은 데이터 유형이 xsd:boolean인 리터럴이어야 합니다. 매개변수 선언은 sh:optional 속성에 대해 최대 하나의 값을 가질 수 있습니다. true로 설정하면 매개변수 선언은 선택적 매개변수를 선언합니다. 모든 제약 조건 구성 요소에는 선택 사항이 아닌 매개변수가 하나 이상 있습니다.

sh:Parameter 클래스는 sh:PropertyShape의 SHACL 하위 클래스로 정의되며, 속성 도형에 적용할 수 있는 모든 속성은 매개변수에도 사용할 수 있습니다. 여기에는 sh:name 및 sh:description과 같은 설명 속성뿐 아니라 sh:class와 같은 제약 조건 매개변수도 포함됩니다. 매개변수에 선언된 제약 조건을 준수하지 않는 도형은 잘못된 형식입니다. 일부 구현은 잘못된 매개변수 값을 가진 제약 조건 구성 요소가 실행되지 않도록 이러한 제약 조건 매개변수를 사용할 수 있습니다.

sh:labelTemplate 속성은 모든 제약 조건 구성 요소에서 제약 조건을 사람이 이해할 수 있도록 표시하는 방법을 제안하는 데 사용할 수 있습니다. sh:labelTemplate의 값은 리터럴이며, 데이터 유형은 xsd:string, rdf:langString 또는 rdf:dirLangString입니다. 이러한 값은 레이블 템플릿이라고 합니다.

이 절의 나머지 부분은 비규범적입니다.

레이블 템플릿은 {?varName} 또는 {$varName} 구문을 사용하여 제약 조건 구성 요소에 선언된 매개변수의 이름을 포함할 수 있으며, 여기서 varName은 매개변수 이름입니다. 표시할 때 이러한 {?varName} 및 {$varName} 블록은 실제 매개변수 값으로 대체해야 합니다. 동일한 주어에 대해 여러 레이블 템플릿이 있을 수 있지만 동일한 언어 태그를 가져서는 안 되며, 데이터 유형이 xsd:string인 템플릿은 둘 이상이어서는 안 됩니다.

지원되는 각 도형 유형, 즉 속성 도형 또는 노드 도형에 대해 제약 조건 구성 요소는 적절한 검증기를 선언합니다. 주어진 제약 조건에 대해 다음 규칙을 순서대로 사용하여 제약 조건 구성 요소에서 검증기를 선택합니다.

노드 도형의 경우 sh:nodeValidator 값이 있으면 그중 하나를 사용합니다.
속성 도형의 경우 sh:propertyValidator 값이 있으면 그중 하나를 사용합니다.
그렇지 않으면 sh:validator 값 중 하나를 사용합니다.

적절한 검증기를 찾을 수 없으면 SHACL-SPARQL 프로세서는 해당 제약 조건을 무시합니다.

SHACL-SPARQL에는 SPARQL SELECT 쿼리 (sh:nodeValidator 및 sh:propertyValidator용) 또는 SPARQL ASK 쿼리(sh:validator용)를 기반으로 하는 두 유형의 검증기가 포함됩니다.

검증기 중 SHACL 유형이 sh:SPARQLSelectValidator인 검증기를 SELECT 기반 검증기라고 합니다. sh:nodeValidator의 값은 반드시 SELECT 기반 검증기여야 합니다. sh:propertyValidator의 값은 반드시 SELECT 기반 검증기여야 합니다. SELECT 기반 검증기는 sh:select 속성에 대해 정확히 하나의 값을 가져야 합니다. sh:select의 값은 데이터 유형이 xsd:string인 리터럴입니다. 접두사 처리 규칙을 적용하면 sh:select의 값은 유효한 SPARQL 1.2 SELECT 쿼리입니다. sh:select의 값에서 파생된 SPARQL 쿼리는 SELECT 절에서 this 변수를 투영합니다.

이 절의 나머지 부분은 비규범적입니다.

다음 예는 SPARQL SELECT 쿼리를 기반으로 하는 제약 조건 구성 요소의 선언을 보여준다. 이는 3.1 SPARQL 기반 제약 조건의 예에 나온 예를 일반화한 변형이다. 해당 SPARQL 쿼리에는 두 개의 상수, 즉 특정 속성 ex:germanLabel과 언어 태그 de가 포함되어 있었지만, 이 예에서는 모든 속성을 언어 태그와 함께 정의할 수 있도록 제약 조건을 일반화한다. 실제로 제약 조건 구성 요소는 매개변수 술어를 셰이프에 추가하여(예: ex:lang "de") 적용되며, SHACL-SPARQL 프로세서는 SELECT 검증기를 실행하기 전에 이를 해당 SPARQL 변수(예: $lang)에 사전 바인딩한다. 제약 조건 구성 요소를 사용하면 이러한 시나리오를 일반화하여 상수가 사전 바인딩된 매개변수가 되도록 할 수 있다. 이를 통해 새로운 SPARQL을 작성하지 않고도 여러 위치에서 쿼리 논리를 재사용할 수 있다.

예 6: SPARQL을 기반으로 하는 제약 조건 컴포넌트

ex:LanguageConstraintComponentUsingSELECT a sh:ConstraintComponent ; rdfs:label "언어 제약 조건 컴포넌트" ; sh:parameter [ sh:path ex:lang ; sh:datatype xsd:string ; sh:minLength 2 ; sh:name "언어" ; sh:description "언어 태그(예: \"de\")." ; ] ; sh:labelTemplate "값은 언어가 \"{$lang}\"인 리터럴입니다" ; sh:propertyValidator [ a sh:SPARQLSelectValidator ; sh:message "값은 언어가 \"{?lang}\"인 리터럴입니다" ; sh:select """ SELECT DISTINCT $this ?value WHERE { $this $PATH ?value . FILTER (!isLiteral(?value) || !langMatches(lang(?value), $lang)) } """ ] .

{
	"@id": "ex:LanguageConstraintComponentUsingSELECT",
	"@type": "sh:ConstraintComponent",
	"rdfs:label": "언어 제약 조건 컴포넌트",
	"sh:labelTemplate": "값은 언어가 \"{$lang}\"인 리터럴입니다",
	"sh:parameter": {
		"sh:datatype": {
			"@id": "xsd:string"
		},
		"sh:description": "언어 태그(예: \"de\").",
		"sh:minLength": {
			"@type": "xsd:integer",
			"@value": "2"
		},
		"sh:name": "언어",
		"sh:path": {
			"@id": "ex:lang"
		}
	},
	"sh:propertyValidator": {
		"@type": "sh:SPARQLSelectValidator",
		"sh:message": "값은 언어가 \"{?lang}\"인 리터럴입니다",
		"sh:select": "\n\t\t\tSELECT DISTINCT $this ?value\n\t\t\tWHERE {\n\t\t\t\t$this $PATH ?value .\n\t\t\t\tFILTER (!isLiteral(?value) || !langMatches(lang(?value), $lang))\n\t\t\t}\n\t\t\t"
	}
}

제약 조건 컴포넌트가 (도형 그래프에서) 선언되면 그 매개변수를 다음 예와 같이 사용할 수 있습니다. ex:lang을 포함하는 모든 속성 도형은 ex:LanguageConstraintComponentUsingSELECT을 사용하는 것으로 해석됩니다 ($lang을 해당 값에 바인딩함).

예제 7: ex:LanguageConstraintComponentUsingSELECT를 사용한 셰이프 선언

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

{
	"@id": "ex:LanguageExampleShape",
	"@type": "sh:NodeShape",
	"sh:property": [
		{
			"ex:lang": "de",
			"sh:path": {
				"@id": "ex:germanLabel"
			}
		},
		{
			"ex:lang": "en",
			"sh:path": {
				"@id": "ex:englishLabel"
			}
		}
	],
	"sh:targetClass": {
		"@id": "ex:Country"
	}
}

위의 예제 도형은 ex:germanLabel의 모든 값에 언어 태그 de가 지정되고 ex:englishLabel의 모든 값에는 언어로 en이 지정되어야 한다는 조건을 명시합니다. 이러한 세부 사항은 제약 조건 컴포넌트에 필요한 ex:lang 매개변수의 값을 갖는 두 속성 도형을 통해 명시됩니다.

많은 제약 조건 구성 요소는 모든 값 노드를 특정 불리언 조건에 대해 개별적으로 검사하는 형식입니다. 이러한 구성 요소에 SELECT 쿼리를 작성하는 작업은 특히 제약 조건 구성 요소를 속성 도형과 노드 도형 모두에 사용할 수 있는 경우 번거롭습니다. SHACL-SPARQL은 ASK 쿼리를 기반으로 하는 검증기를 위한 더 간결한 대체 구문을 제공합니다.

SHACL 유형 sh:SPARQLAskValidator를 갖는 검증기를 ASK 기반 검증기라고 합니다. sh:validator의 값은 ASK 기반 검증기여야 합니다. ASK 기반 검증기는 sh:ask 속성에 대해 정확히 하나의 값을 갖습니다. sh:ask의 값은 데이터 유형이 xsd:string인 리터럴이어야 합니다. sh:ask의 값은 앞서 설명한 접두사 처리 규칙을 사용하는 유효한 SPARQL ASK 쿼리여야 합니다.

이 절의 나머지 부분은 비규범적입니다.

ASK 쿼리는 주어진 값 노드 (사전 바인딩된 변수 value로 나타냄)가 제약 조건을 준수하는 경우에만 true를 반환합니다.

다음 예시는 ASK 쿼리를 사용하는 제약 조건 구성 요소를 선언합니다.

예 8: SPARQL을 기반으로 하는 제약 조건 컴포넌트

ex:LanguageConstraintComponentUsingASK 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:validator ex:hasLang . ex:hasLang a sh:SPARQLAskValidator ; sh:message "값은 언어 \"{$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": "값은 언어 \"{$lang}\"을 가진 리터럴입니다"
		},
		{
			"@id": "ex:LanguageConstraintComponentUsingASK",
			"@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:validator": {
				"@id": "ex:hasLang"
			}
		}
	]
}

ASK 쿼리가 구현하는 유효성 검사 조건은 대응하는 SELECT 쿼리와 비교하여 "반대 방향"이라는 점에 유의하십시오. ASK 쿼리는 제약 조건을 준수하는 값 노드에 대해 true를 반환하지만, SELECT 쿼리는 준수하지 않는 값 노드를 반환합니다.

이 절에서는 SPARQL 기반 제약 조건 구성 요소의 검증기를 정의합니다. 이 검증기는 가능한 구현 전략 중 하나만 설명하며, SHACL 처리기는 결과가 동등하다면 다른 접근 방식을 선택할 수 있습니다.

첫 번째 단계로, 4.2.3 검증기에 설명된 규칙에 따라 검증기를 반드시 MUST 선택해야 합니다. 그런 다음 다음 규칙을 적용하여 SPARQL 쿼리의 해 집합을 생성합니다.

ASK 기반 검증기의 경우: 변수 value에 v를 사전 바인딩했을 때 SPARQL ASK 쿼리가 false를 반환하는 각 값 노드 v에 대해 ($this, 포커스 노드) 및 ($value, v) 바인딩으로 구성된 하나의 해를 생성합니다. 이러한 해의 목록을 QS라고 하겠습니다.
SELECT 기반 검증기의 경우: 셰이프가 속성 셰이프라면 실행 전에 치환합니다. 이때 PATH 변수가 트리플 패턴의 술어 위치에 나타나면, 속성 셰이프에서 sh:path를 통해 지정한 SHACL 속성 경로의 유효한 SPARQL 표면 구문 문자열로 치환합니다. SPARQL 쿼리를 실행하여 생성된 해를 QS라고 하겠습니다.

위의 SPARQL 쿼리 실행에서는 3.3.1 SPARQL 제약 조건의 사전 바인딩된 변수 $this에 설명된 대로 this 변수를 반드시 MUST 사전 바인딩해야 합니다. 또한 제약 조건에 있는 제약 조건 구성 요소의 각 매개변수의 값은 매개변수 이름을 이름으로 사용하는 변수에 반드시 MUST 사전 바인딩되어야 합니다.

검증 결과의 생성 규칙은 위에서 생성한 해 QS를 사용하며, SPARQL 기반 제약 조건의 생성 규칙과 동일합니다.

이 절에서는 일반적인 메커니즘을 확장하여 SPARQL 기반 제약 조건 또는 제약 조건 구성 요소를 사용해 검증 결과를 생성하는 방법을 설명합니다.

이 기능의 지원은 SHACL-SPARQL 검증 처리기에서 선택 사항(OPTIONAL)입니다. 1.3 적합성을 참조하세요. 이 기능을 지원하는 처리기는 SPARQL 기반 제약 조건 또는 제약 조건 구성 요소의 SELECT 쿼리에서 생성된 각 해에 대해 만들어지는 검증 결과 노드에 주석 속성을 추가할 수 있습니다. 이러한 주석 속성은 모두 sh:select 또는 sh:ask 트리플의 주어에서 sh:resultAnnotation의 값을 통해 선언해야 합니다.

sh:resultAnnotation의 값은 결과 주석이라고 하며, IRI 또는 빈 노드입니다.

결과 주석에는 다음 속성이 있습니다.

속성	요약 및 구문 규칙
`sh:annotationProperty`	설정할 속성입니다. 각 결과 주석은 `sh:annotationProperty` 속성에 대해 정확히 하나의 값을 가지며, 이 값은 IRI입니다.
`sh:annotationVarName`	주석 값을 가져올 SPARQL 변수의 이름입니다. 각 결과 주석은 `sh:annotationVarName` 속성에 대해 최대 하나의 값을 가지며, 이 값은 데이터 유형이 `xsd:string`인 리터럴입니다.
`sh:annotationValue`	기본값으로 사용할 상수 RDF 용어입니다.

SELECT 결과 집합의 각 해에 대해 주석을 지원하는 SHACL 처리기는 선언된 결과 주석을 순회합니다. 결과 주석에서 SPARQL 변수로의 매핑에는 다음 규칙을 사용합니다.

sh:annotationVarName 속성의 값을 사용합니다.
이러한 값이 없다면 sh:annotationProperty의 값에 해당하는 로컬 이름을 변수 이름으로 사용합니다.

변수 이름을 결정할 수 있다면 SHACL 처리기는 해당 변수의 바인딩을 sh:annotationProperty로 지정된 속성의 값으로 복사하여 현재 해에 대해 생성 중인 검증 결과에 추가합니다. 결과 집합의 해에서 해당 변수에 바인딩이 없다면, sh:annotationValue의 값이 존재하는 경우 이를 사용합니다.

예제 9: 결과 주석 사용 예제

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

{
    "@id": "ex:AnnotationExample",
    "@type": "sh:NodeShape",
    "sh:sparql": {
        "sh:resultAnnotation": {
            "sh:annotationProperty": {
                "@id": "ex:time"
            },
            "sh:annotationVarName": "time"
        },
        "sh:select": "\n\t\t\tSELECT $this ?message ?time\n\t\t\tWHERE {\n\t\t\t\tBIND (CONCAT(\"The \", \"message.\") AS ?message) .\n\t\t\t\tBIND (NOW() AS ?time) .\n\t\t\t}\n\t\t\t"
    },
    "sh:targetNode": {
        "@id": "ex:ExampleResource"
    }
}

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

{
    "@type": "sh:ValidationReport",
    "sh:conforms": {
        "@type": "xsd:boolean",
        "@value": "false"
    },
    "sh:result": {
        "@type": "sh:ValidationResult",
        "ex:time": {
            "@type": "xsd:dateTime",
            "@value": "2015-03-27T10:58:00"
        },
        "sh:focusNode": {
            "@id": "ex:ExampleResource"
        },
        "sh:resultMessage": "The message.",
        "sh:resultSeverity": {
            "@id": "sh:Violation"
        },
        "sh:sourceConstraint": {
            "@id": "_:b1"
        },
        "sh:sourceConstraintComponent": {
            "@id": "sh:SPARQLConstraintComponent"
        },
        "sh:sourceShape": {
            "@id": "ex:AnnotationExample"
        }
    }
}

이 절에서는 SPARQL을 기반으로 하는 노드 표현식 함수를 소개합니다.

참고

이 절의 노드 표현식 함수에는 완전한 SPARQL 쿼리 또는 SPARQL 표현식이 포함됩니다. sparql:concat과 같은 개별 SPARQL 함수에 대한 노드 표현식 함수는 SPARQL 쿼리 없이 평가되며, SHACL 1.2 노드 표현식에서 정의합니다.

노드 표현식 중 핵심 매개변수 sh:select의 값을 가진 것은 함수 이름이 sh:SelectExpression인 SELECT 표현식이라고 합니다.

RDF 그래프의 노드가 빈 노드이고, 술어 sh:select에 대해 정확히 하나의 값을 가지며, 이 값이 데이터 유형 xsd:string을 가진 리터럴이라면, 해당 노드는 올바른 형식의 SELECT 표현식입니다. 올바른 형식의 SELECT 표현식은 sh:prefixes 속성에 대해 최대 하나의 값을 가질 수 있으며, 이 값은 IRI 또는 빈 노드여야 합니다.

접두사 처리 규칙을 적용하면 sh:select의 값은 유효한 SPARQL 1.2 SELECT 쿼리입니다. sh:select의 값에서 파생된 SPARQL 쿼리는 SELECT 절에서 정확히 하나의 변수를 투영합니다.

SELECT 표현식의 평가

SELECT 표현식의 출력 노드는 resultNodes 목록입니다. 이 목록은 쿼리를 포커스 그래프에 대해 평가할 때 SELECT 절에서 투영되는 유일한 변수의 바인딩만으로 구성됩니다. focusNode의 값은 SPARQL 변수 this의 값으로 사전 바인딩됩니다. 각 범위 변수의 값은 동일한 이름과 값을 가진 SPARQL 변수로 사전 바인딩됩니다. 범위 내 변수의 이름이 문자열 리터럴이 아니라면 "arg" + str(name)을 사용합니다. 예를 들어 변수 이름이 "0"^^xsd:integer라면 arg0을 사용합니다. 범위 변수 중 하나의 이름이 this이거나, 이러한 방식으로 파생된 변수 이름이 유효한 SPARQL VARNAME이 아니면 실패가 발생합니다.

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

이 절의 나머지 부분은 비규범적입니다.

예제 10: SPARQL 쿼리 기반 노드 표현식을 사용하여 동적으로 계산되는 속성

다음은 SELECT 표현식을 사용하여 속성 셰이프의 값을 계산하는 예제입니다. "전체 이름" 속성의 값은 ex:firstName, 공백 및 ex:lastName을 연결하여 계산합니다.

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

{
    "@graph": [
        {
            "@id": "ex:Person-fullName",
            "@type": "sh:PropertyShape",
            "sh:datatype": {
                "@id": "xsd:string"
            },
            "sh:name": "full name",
            "sh:path": {
                "@id": "ex:fullName"
            },
            "sh:values": {
                "sh:prefixes": {
                    "@id": "http://example.com/ns#"
                },
                "sh:select": "\n\t\t\tSELECT ?fullName\n\t\t\tWHERE {\n\t\t\t\t$this ex:firstName ?firstName .\n\t\t\t\t$this ex:lastName ?lastName .\n\t\t\t\tBIND (CONCAT(?firstName, \" \", ?lastName) AS ?fullName) .\n\t\t\t}\n\t\t"
            }
        },
        {
            "@id": "http://example.com/ns#",
            "@type": "owl:Ontology",
            "sh:declare": {
                "sh:namespace": {
                    "@type": "xsd:anyURI",
                    "@value": "http://example.com/ns#"
                },
                "sh:prefix": "ex"
            }
        }
    ]
}

이 예제는 파싱 전에 쿼리의 시작 부분에 PREFIX 선언을 삽입하기 위해 sh:prefixes를 사용하는 방법도 보여 줍니다. 쿼리는 현재 포커스 노드를 변수 this에 사전 바인딩한 상태로 실행됩니다.

예제 11: SPARQL 쿼리 기반 노드 표현식을 사용하여 동적으로 계산되는 대상 노드

다음은 SELECT 표현식을 사용하여 셰이프의 대상 노드를 계산하는 예제입니다. 대상 노드는 ex:age가 18보다 작은 모든 ex:Person 인스턴스로 구성됩니다.

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

{
    "@id": "ex:ChildShape",
    "@type": "sh:NodeShape",
    "rdfs:comment": "This shape applies to all persons under 18 years of age.",
    "rdfs:label": "Child shape",
    "sh:targetNode": {
        "sh:select": "\n\t\t\tPREFIX ex: <http://example.com/ns#>\n\t\t\tSELECT ?person\n\t\t\tWHERE {\n\t\t\t\t?person a/rdfs:subClassOf* ex:Person .\n\t\t\t\t?person ex:age ?age .\n\t\t\t\tFILTER (?age < 18) .\n\t\t\t}\n\t\t"
    }
}

다음 데이터 그래프에서는 ex:Benjamin만 대상 노드입니다.

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

{
    "@graph": [
        {
            "@id": "ex:Benjamin",
            "@type": "ex:Person",
            "ex:age": {
                "@type": "xsd:integer",
                "@value": "17"
            }
        },
        {
            "@id": "ex:Bernd",
            "@type": "ex:Person"
        },
        {
            "@id": "ex:Klaus",
            "@type": "ex:Person",
            "ex:age": {
                "@type": "xsd:integer",
                "@value": "48"
            }
        }
    ]
}

노드 표현식 중 핵심 매개변수 sh:sparqlExpr의 값을 가진 것은 함수 이름이 sh:SPARQLExprExpression인 SPARQL expr 표현식이라고 합니다.

RDF 그래프의 노드는 잘 구성된 SPARQL expr 표현식입니다. 이는 블랭크 노드이며 값을 술어 sh:sparqlExpr에 대해 정확히 하나 가지며 해당 값이 리터럴이고 데이터타입이 xsd:string인 경우입니다. 잘 구성된 SPARQL expr 표현식은 속성 sh:prefixes에 대해 최대 하나의 값을 가질 수 있으며 이 값은 IRI 또는 블랭크 노드입니다.

$EXPR$ 을 sh:sparqlExpr의 값으로 하고 $PREFIXES$ 를 sh:prefixes의 값을 사용하여 접두사 처리 규칙에서 생성된 SPARQL 접두사 블록으로 합니다. 그러면 select는 $EXPR$ 과 $PREFIXES$ 가 다음과 같이 삽입된 문자열로 정의됩니다.

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

select는 유효한 SPARQL 1.2 SELECT 쿼리입니다.

SPARQL EXPR 표현식의 평가

SPARQL expr 표현식의 출력 노드는 resultNodes 목록이며, 위에서 정의한 select 쿼리를 포커스 그래프에 대해 평가할 때 해당 쿼리의 SELECT 절에서 투영되는 유일한 변수의 바인딩만으로 구성됩니다. focusNode의 값은 SPARQL 변수 this의 값으로 사전 바인딩됩니다. 각 범위 변수의 값은 동일한 이름과 값을 가진 SPARQL 변수로 사전 바인딩됩니다. 범위 내 변수의 이름이 문자열 리터럴이 아니라면 "arg" + str(name)을 사용합니다. 예를 들어 변수 이름이 "0"^^xsd:integer라면 arg0을 사용합니다. 범위 변수 중 하나의 이름이 this이거나, 이러한 방식으로 파생된 변수 이름이 유효한 SPARQL VARNAME이 아니면 실패가 발생합니다.

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

이 절의 나머지는 비규범입니다.

예제 12: SPARQL expr expression을 사용하여 동적으로 계산되는 property

다음은 SPARQL expr expression 사용 예로, property "uri length"에 대한 property shape의 values를 focus node의 IRI 길이로 계산합니다.

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를 가진 focus node에 적용하면 결과는 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"
	}
}

query는 현재 focus node가 variable this에 pre-bound된 상태로 실행된다는 점에 유의하세요.

SHACL 1.2 노드 표현식은 새로운 노드 표현식 함수를 선언하는 메커니즘으로 사용자 정의 목록 매개변수 함수를 정의합니다. 이러한 함수는 다른 SHACL 노드 표현식의 일부로 평가할 수 있으며, 함수와 유사한 실행을 지원하는 다른 엔진에서도 유용할 수 있습니다.

SPARQL 명세는 특정 SPARQL 엔진이 추가 SPARQL 함수를 제공할 수 있도록 하는 확장 지점을 정의합니다. 이 절에서는 SPARQL 처리기가 해당 확장 지점을 사용하여 SHACL 목록 매개변수 함수를 SPARQL 함수로 사용할 수 있게 하는 선언적 메커니즘을 소개합니다.

예제 13: shnex: 노드 표현식을 사용하는 사용자 정의 함수 예제

이 함수는 클래스를 유일한 매개변수로 받아 해당 클래스의 인스턴스 수를 반환합니다.

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

{
    "@id": "ex:instanceCount",
    "@type": "sh:ListParameterExpressionFunction",
    "rdfs:label": {
        "@language": "en",
        "@value": "instance count"
    },
    "rdfs:subClassOf": {
        "@id": "sh:ListParameterExpression"
    },
    "sh:bodyExpression": {
        "shnex:count": {
            "shnex:instancesOf": {
                "shnex:arg": {
                    "@type": "xsd:integer",
                    "@value": "0"
                }
            }
        }
    },
    "sh:parameter": {
        "@type": "sh:Parameter",
        "sh:description": "The class to count the instances of.",
        "sh:name": "class",
        "sh:nodeKind": {
            "@id": "sh:IRI"
        },
        "sh:path": {
            "@id": "shnex:arg0"
        }
    }
}

노드 표현식 기반 SPARQL 함수를 지원하는 SPARQL 엔진은 다음과 같은 SPARQL 쿼리를 처리할 수 있습니다.

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

다음 사용자 정의 목록 매개변수 함수는 평가 시 "중첩된" SPARQL 쿼리를 사용합니다.

예제 14: sh:sparqlExpr을 사용하는 사용자 정의 함수 예제

이 함수는 두 개의 매개변수를 받고 SPARQL expr 표현식을 본문 표현식으로 사용합니다. 해당 SPARQL 표현식에서는 $arg0 및 $arg1 변수를 사용하여 목록 매개변수 값에 접근합니다. 이는 [shacl12-node-expr]의 ex:spacedConcat 예제를 변형한 것으로, SPARQL 표현식 대신 sparql:concat 노드 표현식 함수를 사용한 예제입니다.

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

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

노드 표현식 기반 SPARQL 함수를 지원하는 SPARQL 엔진은 다음과 같은 SPARQL 쿼리를 처리할 수 있습니다.

SELECT ?person ?fullName
WHERE {
    ?person a ex:Person .
    ?person ex:firstName ?firstName .
    ?person ex:lastName ?lastName .
    BIND (ex:spacedConcat(?firstName, ?lastName) AS ?fullName) .
}

다음 예제에서는 sh:select 노드 표현식을 본문으로 사용합니다.

예제 15: sh:select를 사용하는 사용자 정의 함수 예제

이 함수는 두 개의 매개변수를 받으며, 두 번째 매개변수는 선택 사항이고 SELECT 표현식을 본문 표현식으로 사용합니다. 해당 SPARQL 쿼리에서는 $arg0 및 $arg1 변수를 사용하여 목록 매개변수 값에 접근합니다.

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

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

이 함수는 sh:optional true 트리플로 선언된 것처럼 일치시킬 언어에 대한 선택적 매개변수를 받습니다. 다만 sh:parameter 선언의 SHACL 제약 조건은 자동으로 적용되지 않으며, 선언된 sh:defaultValue도 런타임에 사용되지 않습니다. 인수의 오류 처리 방식을 결정하는 sh:optional을 제외하면 (자세한 내용은 7.3 사용자 정의 SPARQL 함수의 평가 참조), 이러한 선언은 문서화 목적으로 사용됩니다.

ex:Cougar rdfs:label "Cougar"@en ; rdfs:label "Mountain Lion"@en-US ; rdfs:label "Puma"@de . # SPARQL 함수 호출 예제: # ex:langLabelCount(ex:Cougar, 'en') = 2 # ex:langLabelCount(ex:Cougar) = 2 # ex:langLabelCount(ex:Cougar, 'de') = 1 # ex:langLabelCount(?unbound, 'en') = SPARQL 오류

{
    "@id": "ex:Cougar",
    "rdfs:label": [
        {
            "@language": "en",
            "@value": "Cougar"
        },
        {
            "@language": "en-US",
            "@value": "Mountain Lion"
        },
        {
            "@language": "de",
            "@value": "Puma"
        }
    ]
}

이 문서는 이러한 사용자 정의 SPARQL 함수를 추가하는 방법과 시점에 대한 정확한 제약 조건을 정의하지 않습니다. SPARQL 엔진은 제공된 모든 셰이프 그래프에 있는 sh:ListParameterExpressionFunction의 모든 SHACL 인스턴스에 대해 함수를 등록하는 것이 좋습니다(SHOULD). 동일한 IRI를 가진 함수가 이미 내장 함수 또는 다른 비사용자 정의 함수로 등록되어 있다면, SPARQL 엔진은 이를 재정의하려는 시도를 반드시 MUST 무시해야 합니다. 등록된 함수 자체가 이전에 제공된 셰이프 그래프에서 온 사용자 정의 SPARQL 함수라면 새 선언이 이를 대체합니다. SPARQL 엔진은 SPARQL 쿼리를 실행하는 동안 등록된 SPARQL 함수를 수정해서는 절대 안 됩니다(MUST NOT).

사용자 정의 SPARQL 함수의 평가

f를 SPARQL 함수 호출의 iri라고 하고, args를 Expression 인수 목록이라고 하겠습니다. function은 해당 함수가 정의된 그래프에서 f를 IRI로 사용하는 해당 사용자 정의 목록 매개변수 함수라고 하겠습니다.

args의 각 SPARQL 표현식을 평가하여 노드의 새 목록 nodesList를 생성합니다. 평가 과정에서 오류가 발생했다면 해당 SPARQL 함수 호출의 결과도 오류가 됩니다. 단, 해당 인수의 sh:parameter에 sh:optional true가 지정되어 있으면 예외입니다. 이 경우 해당 인수는 범위 내에서 바인딩되지 않습니다. 빈 노드는 상수 노드 표현식이 아니므로 인수로 전달할 수 없습니다. 따라서 빈 노드로 평가되는 인수는 평가 실패를 일으키며, 결과적으로 오류가 발생합니다.

rs를 evalExpr(function, focusGraph, f, scope)의 출력 노드라고 하겠습니다. 여기서 focusGraph는 SPARQL 컨텍스트에서 현재 활성화된 쿼리 그래프이고, scope는 nodesList에서 평가된 인수들을 인수의 인덱스를 변수 이름(맵 키)으로 사용하여 매핑한 것입니다.

출력 노드 목록 rs에 구성원이 정확히 하나 있다면 해당 노드를 반환합니다. 그렇지 않거나 평가에서 평가 실패가 발생하면 SPARQL 함수 호출의 결과는 오류입니다.

참고

SPARQL 쿼리를 평가하는 동안에는 별도로 지정된 포커스 노드가 없습니다. 대신 노드 표현식 기반 사용자 정의 SPARQL 함수에 전달되는 focusNode는 함수 자체의 IRI입니다.

이 절에서는 이 문서의 모든 규범적 구문 규칙을 열거합니다. 이 절은 이 명세의 다른 부분에서 자동으로 생성되며, 규칙의 문맥이 불분명한 경우 본문으로 돌아가는 하이퍼링크가 제공됩니다. 셰이프 그래프에서 이러한 규칙을 위반하는 노드는 잘못 구성된 것입니다.

구문 규칙 ID	구문 규칙 내용
prefix-count	접두사 선언은 `sh:prefix` 속성에 대해 정확히 하나의 값을 가집니다.
prefix-datatype	`sh:prefix`의 값은 데이터 유형이 `xsd:string`인 리터럴입니다.
namespace-count	접두사 선언은 `sh:namespace` 속성에 대해 정확히 하나의 값을 가집니다.
namespace-datatype	`sh:namespace`의 값은 데이터 유형이 `xsd:anyURI` 또는 `xsd:string`인 리터럴입니다.
declare-nodeKind	`sh:declare` 속성의 값은 접두사 선언입니다.
prefixes-nodeKind	`sh:prefixes`의 값은 IRI 또는 빈 노드입니다.
prefixes-duplicates	이러한 접두사 선언 집합에 동일한 `sh:prefix`의 값에 대해 서로 다른 네임스페이스가 여러 개 포함되어 있다면, 셰이프 그래프는 형식이 올바르지 않습니다.
sparql-nodeKind	셰이프는 `sh:sparql` 속성의 값을 가질 수 있으며, 이 값은 IRI 또는 빈 노드입니다.
SPARQLConstraint-select-count	SPARQL 기반 제약 조건은 `sh:select` 속성에 대해 정확히 하나의 값을 가집니다.
SPARQLConstraint-select-datatype	`sh:select`의 값은 데이터 유형이 `xsd:string`인 리터럴입니다.
select-query-valid	접두사 처리 규칙을 적용하면 `sh:select`의 값은 유효한 SPARQL 1.2 SELECT 쿼리입니다.
select-query-this	`sh:select`의 값에서 파생된 SPARQL 쿼리는 SELECT 절에서 `this` 변수를 투영합니다.
SPARQLConstraint-message-datatype	SPARQL 기반 제약 조건은 `sh:message` 속성의 값을 가질 수 있으며, 이러한 값은 리터럴이고 데이터 유형은 `xsd:string`, `rdf:dirLangString`, `rdf:langString` 또는 `rdf:HTML`입니다. 동일한 언어 태그를 가진 `sh:message` 값이 둘 이상 있어서는 안 되며, 데이터 유형이 `xsd:string`인 값도 여러 개 있어서는 안 됩니다.
SPARQLConstraint-deactivated-maxCount	SPARQL 기반 제약 조건은 `sh:deactivated` 속성의 값을 최대 하나 가질 수 있습니다.
SPARQLConstraint-severity	SPARQL 기반 제약 조건은 `sh:severity` 속성의 값을 최대 하나 가질 수 있으며, 이 값은 IRI입니다.
PATH-position	SPARQL 기반 제약 조건과 SELECT 기반 검증기의 SPARQL 쿼리에서 `PATH` 변수를 합법적으로 사용할 수 있는 유일한 위치는 트리플 패턴의 술어 위치입니다.
ConstraintComponent	SPARQL 기반 제약 조건 구성 요소는 셰이프 그래프에서 SHACL 유형이 `sh:ConstraintComponent`인 IRI입니다.
Parameter-predicate-count	각 매개변수 선언은 `sh:path` 속성에 대해 정확히 하나의 값을 가집니다.
Parameter	매개변수 선언에서 `sh:path`의 값은 IRI입니다.
parameter-name-VARNAME	모든 매개변수 이름은 유효한 SPARQL VARNAME입니다.
parameter-name-not-in	매개변수 이름은 다음 중 하나여서는 안 됩니다. `this`, `path`, `PATH`, `value`, `message`, `failure`.
parameter-name-unique	둘 이상의 매개변수 선언에서 동일한 매개변수 이름을 사용하는 제약 조건 구성 요소는 형식이 올바르지 않습니다.
optional-datatype	`sh:optional`의 값은 데이터 유형이 `xsd:boolean`인 리터럴이어야 합니다.
optional-maxCount	매개변수 선언은 `sh:optional` 속성의 값을 최대 하나 가질 수 있습니다.
ConstraintComponent-parameter	모든 제약 조건 구성 요소에는 선택 사항이 아닌 매개변수가 하나 이상 있습니다.
Parameter-conformance	매개변수에 대해 선언된 제약 조건을 준수하지 않는 셰이프는 형식이 올바르지 않습니다.
labelTemplate-datatype	`sh:labelTemplate`의 값은 리터럴이며, 데이터 유형은 `xsd:string`, `rdf:langString` 또는 `rdf:dirLangString`입니다.
nodeValidator-class	`sh:nodeValidator`의 값은 SELECT 기반 검증기여야 합니다.
propertyValidator-class	`sh:propertyValidator`의 값은 SELECT 기반 검증기여야 합니다.
SPARQLSelectValidator-select-count	SELECT 기반 검증기는 `sh:select` 속성에 대해 정확히 하나의 값을 가집니다.
SPARQLSelectValidator-select-datatype	`sh:select`의 값은 데이터 유형이 `xsd:string`인 리터럴입니다.
SPARQLSelectValidator-select-query-valid	접두사 처리 규칙을 적용하면 `sh:select`의 값은 유효한 SPARQL 1.2 SELECT 쿼리입니다.
SPARQLSelectValidator-select-query-this	`sh:select`의 값에서 파생된 SPARQL 쿼리는 SELECT 절에서 `this` 변수를 투영합니다.
validator-class	`sh:validator`의 값은 ASK 기반 검증기여야 합니다.
ask-count	ASK 기반 검증기는 `sh:ask` 속성에 대해 정확히 하나의 값을 가집니다.
ask-datatype	`sh:ask`의 값은 데이터 유형이 `xsd:string`인 리터럴이어야 합니다.
ask-sparql	`sh:ask`의 값은 앞서 설명한 접두사 처리 규칙을 적용했을 때 유효한 SPARQL ASK 쿼리여야 합니다.
resultAnnotation-nodeKind	`sh:resultAnnotation`의 값은 결과 주석이라고 하며, IRI 또는 빈 노드입니다.
annotationProperty	각 결과 주석은 `sh:annotationProperty` 속성에 대해 정확히 하나의 값을 가지며, 이 값은 IRI입니다.
annotationVarName	각 결과 주석은 `sh:annotationVarName` 속성에 대해 최대 하나의 값을 가지며, 이 값은 데이터 유형이 `xsd:string`인 리터럴입니다.
SelectExpression-syntax	RDF 그래프의 노드가 빈 노드이고, 술어 `sh:select`에 대해 정확히 하나의 값을 가지며, 이 값이 데이터 유형이 `xsd:string`인 리터럴이라면, 해당 노드는 올바른 형식의 SELECT 표현식입니다.
SelectExpression-syntax-prefixes	올바른 형식의 SELECT 표현식은 `sh:prefixes` 속성에 대해 최대 하나의 값을 가질 수 있으며, 이 값은 IRI 또는 빈 노드여야 합니다.
SelectExpression-query-valid	접두사 처리 규칙을 적용하면 `sh:select`의 값은 유효한 SPARQL 1.2 SELECT 쿼리입니다.
SelectExpression-query-output-nodes	`sh:select`의 값에서 파생된 SPARQL 쿼리는 SELECT 절에서 정확히 하나의 변수를 투영합니다.
SPARQLExprExpression-syntax-eval	RDF 그래프의 노드가 빈 노드이고, 술어 `sh:sparqlExpr`에 대해 정확히 하나의 값을 가지며, 해당 값이 데이터 유형이 `xsd:string`인 리터럴이라면, 해당 노드는 올바른 형식의 SPARQL expr 표현식입니다.
SPARQLExprExpression-syntax-prefixes	올바른 형식의 SPARQL expr 표현식은 `sh:prefixes` 속성에 대해 최대 하나의 값을 가질 수 있으며, 이 값은 IRI 또는 빈 노드입니다.
SPARQLExprExpression-template	$EXPR$ 을 `sh:sparqlExpr`의 값으로, $PREFIXES$ 를 `sh:prefixes`의 값을 사용하여 접두사 처리 규칙을 적용한 결과인 SPARQL 접두사 블록으로 정의합니다. 그러면 `select`는 $EXPR$ 과 $PREFIXES$ 를 다음과 같이 삽입한 문자열로 정의됩니다. `$PREFIXES$ SELECT ($EXPR$ AS ?result) WHERE {}`
SPARQLExprExpression-query-valid	`select`는 유효한 SPARQL 1.2 SELECT 쿼리입니다.
pre-binding-limitations	SHACL에서 사용하는 사전 바인딩의 정의는 SPARQL 쿼리에 다음과 같은 제한을 요구합니다. SHACL-SPARQL 처리기는 사전 바인딩된 변수로 실행되며 다음 "MUST" 제한 중 하나라도 위반하는 SHACL-SPARQL 쿼리(`sh:ask`, `sh:construct`, `sh:select` 및 `sh:sparqlExpr`를 통해 지정됨)가 포함된 셰이프 그래프를 처리할 때 반드시 실패를 MUST 보고해야 합니다. 사전 바인딩될 가능성이 있는 변수라는 용어에는 `this`, `value`(ASK 쿼리의 경우), 쿼리를 사용하는 제약 조건 구성 요소의 매개변수를 나타내는 모든 변수와 SPARQL 기반 노드 표현식의 범위 변수를 나타내는 변수(`arg0` 등)가 포함됩니다. SPARQL 쿼리에는 `MINUS` 절이 포함되어서는 MUST 안 됩니다. SPARQL 쿼리에는 사전 바인딩될 가능성이 있는 변수를 언급하는 `VALUES` 절이 포함되어서는 MUST 안 됩니다. SPARQL 쿼리는 사전 바인딩될 가능성이 있는 변수에 대해 `AS ?var` 구문 형식을 사용해서는 MUST 안 됩니다. 또한 SPARQL 쿼리에는 연합 쿼리 (`SERVICE`)가 포함되지 않는 것이 SHOULD 좋습니다. `SERVICE`를 허용하지 않는 구현은 위에서 설명한 대로 반드시 실패를 MUST 보고해야 합니다. 그러나 일부 SPARQL 구현에서는 `SERVICE` 키워드를 특정 작업(일반적으로 로컬 작업)의 구문으로 사용하므로 이 키워드는 일반적으로 금지되지 않습니다.

이 절은 비규범적입니다.

이 부록에서는 제약 조건 구성 요소와 대상의 의미 체계에 대한 비규범적 대체 정의에 SPARQL 1.2의 일부를 사용합니다. 이러한 정의는 [shacl12-core]에서 가져온 것입니다. 이러한 정의는 일부 구현자에게 도움이 될 수 있지만, SHACL Core 언어를 구현하는 데 SPARQL이 필수는 아닙니다.

sh:targetClass와 sh:class의 정의는 rdfs:subClassOf 트리플을 데이터 그래프에서만 조회합니다. 처리기 매개변수 subClassOfInShapesGraph가 설정되어 있다면, 셰이프 그래프의 rdfs:subClassOf 트리플도 고려해야 합니다.

$ 표시를 사용하는 SPARQL 변수는 실행 전에 사전 바인딩되거나 $PATH의 경우 치환되는 외부 바인딩을 나타냅니다(자세한 내용은 3.3 SPARQL 기반 제약 조건을 사용한 검증에 설명되어 있습니다).

다음 쿼리는 SPARQL에서 클래스 대상에 대한 가능한 정의를 표현합니다. targetClass 변수는 주어진 sh:targetClass의 값에 사전 바인딩됩니다. 해에서 변수 this의 모든 바인딩은 포커스 노드가 됩니다.

SPARQL에서의 잠재적 정의

SELECT DISTINCT ?this    # ?this는 포커스 노드이다
WHERE {
	?this rdf:type/rdfs:subClassOf* $targetClass .
}

다음 쿼리는 SPARQL에서 주어 기반 대상에 대한 가능한 정의를 표현합니다. targetSubjectsOf 변수는 주어진 sh:targetSubjectsOf의 값에 사전 바인딩됩니다. 해에서 변수 this의 모든 바인딩은 포커스 노드가 됩니다.

SPARQL에서의 잠재적 정의

SELECT DISTINCT ?this    # ?this는 포커스 노드이다
WHERE {
	?this $targetSubjectsOf ?any .
}

다음 쿼리는 SPARQL에서 목적어 기반 대상에 대한 가능한 정의를 표현합니다. targetObjectsOf 변수는 주어진 sh:targetObjectsOf의 값에 사전 바인딩됩니다. 해에서 변수 this의 모든 바인딩은 포커스 노드가 됩니다.

SPARQL에서의 잠재적 정의

SELECT DISTINCT ?this    # ?this는 포커스 노드이다
WHERE {
	?any $targetObjectsOf ?this .
}

다음 질의는 sh:class에 대한 잠재적인 SPARQL 기반 검증기를 표현한다.