SPARQL 1.2 RL

다음의 다른 명세는 이 문서에서 사용하는 기본 용어를 제공한다:

• RDF 1.2 개념 및 추상 데이터 모델 [RDF12-CONCEPTS]
• SPARQL 1.2 쿼리 언어 [SPARQL12-QUERY]

이 문서의 RDF 데이터 예제에서는 RDF 1.2 Turtle [RDF12-TURTLE]을 사용한다.

이 문서에서는 다음 네임스페이스 접두사 바인딩을 사용한다:

문서 전체에 Turtle 형식의 RDF 그래프가 포함된 색상 구분 상자가 나타난다. 이러한 Turtle 문서 조각은 위에서 지정한 접두사 바인딩을 사용한다.

# 이 상자는 규칙을 나타낸다

# 이 상자는 입력 데이터를 나타낸다

# 이 상자는 추론된 데이터를 나타낸다

변수

변수는 트리플 패턴에서 가능한 RDF 항을 나타낸다. 변수는 표현식에서도 사용된다.

표현식

표현식은 함수 또는 함수형 형식이며, 인수는 RDF 항이다. 표현식은 솔루션 매핑에 관해 평가되며, 그 결과로 RDF 항을 제공한다. 표현식은 SPARQL 표현식 및 SHACL 목록 매개변수 함수와 호환된다.

데이터 블록

데이터 블록은 트리플의 집합이다. 이러한 트리플은 추가 사실로 추론 그래프에 추가되며 추론 과정에 포함된다.

트리플 템플릿

트리플 템플릿은 각 요소가 변수 또는 RDF 항(트리플 항일 수 있음)인 3-튜플이다. 튜플의 두 번째 요소는 IRI 또는 변수여야 한다. 트리플 템플릿은 규칙 헤드에 나타나는 규칙이다.

트리플 패턴

트리플 패턴은 각 요소가 변수 또는 RDF 항(트리플 항일 수 있음)인 3-튜플이다. 튜플의 두 번째 요소는 IRI 또는 변수여야 한다.

필터 요소

필터 요소는 표현식이며 규칙 요소로 나타난다 이는 패턴 일치에서 변수의 값을 제한하는 데 사용된다.

트리플 패턴 요소

트리플 패턴 요소는 트리플 패턴이며, 규칙 요소로 나타난다.

부정 요소

부정 요소는 규칙 요소이다. 여기에는 트리플 패턴 요소와 필터 요소의 시퀀스로 구성된 부정 요소 본문이 있다.

할당 요소

할당 요소는 규칙 요소이며, 할당 변수라고 하는 변수와 할당 표현식이라고 하는 표현식으로 구성된 쌍이다.

규칙 요소

규칙 요소는 트리플 패턴 요소, 필터 요소, 부정 요소 또는 할당 요소 중 하나이다.

규칙 헤드

규칙 헤드는 트리플 템플릿의 시퀀스이다.

규칙 본문

규칙 본문은 규칙 요소의 시퀀스이다. 즉, 각 시퀀스 요소는 트리플 패턴 요소, 필터 요소, 부정 요소 또는 할당 요소이다.

규칙 집합 가져오기

규칙 집합 가져오기(흔히 단순히 "가져오기"라고 함)는 평가 중에 포함할 다른 규칙 집합의 URL 모음이다.

규칙

규칙은 규칙 헤드(흔히 단순히 "헤드"라고 함)와 규칙 본문(흔히 단순히 "본문"이라고 함)의 쌍이다. 규칙에는 식별에 도움이 되는 URI를 지정할 수 있다.

일회 실행 규칙

일회 실행 규칙은 규칙 집합 평가의 특정 지점에서 정확히 한 번 실행되는 규칙이다.

일반 규칙

일반 규칙은 일회 실행 규칙이 아닌 규칙이다. 일반 규칙은 규칙 집합 평가 중에 두 번 이상 실행될 수 있다.

규칙 집합

규칙 집합은 0개 이상의 규칙 모음, 0개 이상의 데이터 블록 모음 및 0개 이상의 규칙 집합 가져오기 모음이다. 해석된 규칙 집합은 가져오기가 없는 규칙 집합이다. 해석된 규칙 집합은 다른 규칙 집합에 가져오기 과정을 적용하여 생성한다.

기본 그래프

기본 그래프는 평가 과정의 입력으로 제공되는 RDF 그래프이다.

추론 그래프

추론 그래프는 규칙 집합 평가에서 생성되는 RDF 그래프이다. 이는 규칙 집합을 기본 그래프에 적용하여 추론한 트리플 중 기본 그래프에 존재하지 않는 모든 트리플을 포함한다.

규칙 집합 평가

규칙 집합 평가는 규칙 집합을 기본 그래프에 적용하여 추론 그래프를 생성하는 과정이다. 규칙 평가는 규칙을 한 번 평가하는 과정이다. 규칙을 평가하면 규칙 본문의 평가 결과에 따라 규칙 헤드에서 지정하는 모든 트리플을 생성한다. 트리플이 기본 그래프에 있거나, 규칙 집합 평가 중에 이미 추론되었거나, 새롭게 추론된 트리플인지 여부는 관계없다. 규칙 집합 평가 중에는 규칙을 두 번 이상 평가할 수 있다.

SPARQL-RL은 infer와 query라는 두 가지 연산을 제공한다.

추론

추론은 규칙 세트를 주어진 기본 그래프에 적용하고 추론된 트리플을 포함하는 추론 그래프를 생성하는 연산이다. 이는 전체 규칙 세트 평가를 적용한다.

질의

질의는 주어진 목표 패턴이 기본 그래프에서 규칙 세트를 사용하여 도출될 수 있는지를 판정하는 연산이다. 모든 규칙을 평가하지 않을 수도 있으며, 대신 질의 목표에 답하는 데 필요한 규칙만 평가할 수 있다.

질의는 추론 연산을 수행한 다음 목표 패턴을 결합된 기본 그래프와 추론 그래프에 일치시키는 것과 동등하다.

SPARQL-RL 프로세서

SPARQL-RL 프로세서는 SPARQL-RL 명세를 구현하고, 규칙 세트를 평가할 수 있으며, 추론 및 질의 연산 중 하나 또는 둘 모두를 제공하는 시스템이다.

트리플 패턴 또는 트리플 템플릿에서, 튜플의 위치 1은 비공식적으로 주어라고 하고, 위치 2는 비공식적으로 술어라고 하며, 위치 3은 비공식적으로 목적어라고 한다.

규칙 세트와 규칙의 다양한 구성 요소에는 다음 표기법을 사용한다.

정형성은 규칙 집합의 추상 구문에 관한 조건의 집합이다. 이러한 조건들은 함께 규칙의 헤드에 있는 변수가 규칙의 본문에서 정의된 값을 갖도록 보장하고, 필터 요소 또는 할당 표현식의 각 변수가 평가 시점에 값을 갖도록 보장하며, 규칙의 각 할당이 규칙 본문 앞부분에서 사용되지 않은 새로운 변수를 도입하도록 보장한다.

초기 변수 집합이 주어질 때 규칙 요소 시퀀스의 정형성을 정의한다.

elt_i를 규칙 요소 시퀀스의 i번째 요소라고 하자.

vars_i를 elt_i에서 정의하는 변수의 집합이라고 하며, 그 정의는 다음과 같다:

V₀를 시퀀스의 초기 변수라고 하자.

V_i를 V₀와 모든 vars_j의 합집합이라고 하자. 여기서 j는 i보다 작다.

V_all을 V_N이라고 하자. 여기서 N은 시퀀스의 길이이다.

변수 집합 V₀가 주어질 때 다음 조건을 충족하는 규칙 요소 시퀀스를 정형 시퀀스라고 한다:

규칙은 V₀가 공집합으로 주어질 때 규칙 본문의 시퀀스가 정형 시퀀스이고, 규칙 헤드의 트리플 템플릿에 있는 각 변수가 V_all의 요소인 경우 정형 규칙이다.

규칙 집합의 모든 규칙이 정형 규칙인 경우에만 그 규칙 집합을 정형 규칙 집합이라고 한다.

두 번째 규칙의 출력이 첫 번째 규칙의 본문 평가에 영향을 주는 경우, 규칙 R1은 규칙 R2에 종속된다. 즉, R2의 헤드에는 R1 본문의 트리플 패턴과 일치하는 트리플을 생성할 수 있는 트리플 템플릿이 있다. 해당 트리플 패턴은 트리플 패턴 요소이거나 부정 요소 내부에 있을 수 있다.

종속성에는 닫힌 종속성과 열린 종속성이라는 두 종류가 있다. 닫힌 종속성은 규칙 R1이 실행되기 전에 규칙 R2가 가능한 모든 출력을 생성하도록 보장한다. 규칙 종속성이 닫혀 있지 않으면 열린 종속성이며, 규칙 R2가 추가 트리플을 생성하기 위해 다시 실행될 수 있는 동안 첫 번째 규칙 R1을 실행할 수 있다. 그러면 R2의 새로운 트리플을 사용하여 R1을 다시 평가할 수 있다.

이 첫 번째 예제에서는 첫 번째 규칙이 두 번째 규칙에 대해 열린 종속성을 갖는다.

이 두 번째 예제에서는 첫 번째 규칙이 두 번째 규칙에 대해 닫힌 종속성을 갖는다. 트리플 패턴 ?x :status :criticallyExposed은 첫 번째 규칙의 부정 요소 내부에 나타나며, 두 번째 규칙의 헤드에 있는 트리플 템플릿과 일치한다. 두 번째 규칙이 가능한 모든 출력을 생성할 때까지 첫 번째 규칙을 평가할 수 없다.

트리플 패턴 일치

트리플 템플릿이 트리플 패턴과 일치하는 트리플을 생성할 수 있으면, 트리플 패턴은 트리플 템플릿과 일치한다.

트리플 패턴 종속성

트리플 패턴이 트리플 템플릿과 일치할 가능성이 있으면, 그 트리플 패턴은 트리플 템플릿에 종속된다.

트리플 패턴이 규칙의 헤드에 있는 트리플 템플릿 중 하나에 종속되면, 그 트리플 패턴은 규칙에 종속된다.

규칙 종속성

R1 본문의 트리플 패턴 중 하나가 트리플 패턴 요소이거나 부정 요소 내부에 있는지와 관계없이 R2의 헤드에 있는 트리플 템플릿에 종속되면, 규칙 R1은 R2에 종속된다.

닫힌 종속성

규칙 R1의 규칙 R2에 대한 규칙 종속성은 다음 조건 중 하나라도 충족되면 닫힌 종속성이다:

• R1의 부정 요소 내부에 나타나는 트리플 패턴이 R2의 규칙 헤드에 있는 트리플 템플릿과 일치한다.
• 규칙 R1이 규칙 R2에 종속되고, R1에 할당 요소가 있다.
• 규칙 R1이 규칙 R2에 종속되고, R1의 규칙 헤드에 빈 노드가 있다.

열린 종속성

규칙 R1의 규칙 R2에 대한 규칙 종속성은 닫힌 종속성이 아니면 열린 종속성이다. 즉, R2에 종속되는 R1의 모든 트리플 패턴은 트리플 패턴 요소로만 나타난다.

define mergeLabel(oldLabel, newLabel):
    ## 닫힌 종속성은 열린 종속성보다 우선한다.
    if oldLabel == "open" and newLabel == "open":
        return "open"
    else:
        return "closed"
    endif
enddefine

## 출력 -- 규칙 정점과 레이블이 지정된 간선이 있는 종속성 그래프.
define buildDependencyGraph(ruleSet):
    ## edgeLabelMap은 (R1, R2)를 "open" 또는 "closed"에 매핑한다
    let edgeLabelMap be a map from pair (rule, rule) to label

    foreach rule R1 in ruleSet.rules:
        ## 규칙의 각 트리플 패턴 TP를 "open" 또는 "closed"가 필요한 것으로 분류한다
        ## 이는 부정 요소 내부에 있는지 여부에 따라 결정한다.
        let bodyDependencies = {}
        foreach rule element RBE in R1.body:
            if RBE is a negation element:
                foreach triple pattern TP in RBE.inner
                    let item be a pair (TP, "closed")
                    add item to bodyDependencies
                endfor
            else if RBE is a triple pattern element of triple pattern TP:
                let item be a pair (TP, "open")
                add item to bodyDependencies
            else if RBE is a condition element:
                ## 아무 작업도 하지 않는다
            else if RBE is an assignment element:
                ## 아무 작업도 하지 않는다
            endif
        endfor

        foreach pair (triple pattern TP, depLabel) in bodyDependencies:
            if R1.body has an assignment element:
              set depLabel to "closed"
            endif
            if R1.head has a triple template with a blank node:
              set depLabel to "closed"
            endif
            ## 이 트리플 패턴 요소 또는 부정 요소의 종속성을 찾는다.
            foreach rule R2 in ruleSet.rules:
                foreach triple template TT in R2.head:
                    if triple pattern TP matches triple template TT:
                        let key = (R1, R2)
                        if edgeLabelMap contains key:
                            let oldLabel = edgeLabelMap.get(key)
                            let merged = mergeLabel(oldLabel, depLabel)
                            edgeLabelMap.set(key, merged)
                        else:
                            edgeLabelMap.set(key, depLabel)
                        endif
                    endif
                endfor
            endfor
        endfor
    endfor

    let DP = { }
    foreach entry ((R1, R2), label) in edgeLabelMap:
        add an edge (R1 -> R2) labeled with label to DP
    endfor

    the result is DP
    enddefine

층화는 규칙 집합을 순서가 지정된 층화 계층의 시퀀스로 분할하는 과정이다("strata", 단수형 "stratum"이라고도 함). 더 낮은 층의 규칙은 더 높은 층의 규칙보다 먼저 평가한다.

층화는 부정 요소, 할당 요소 및 규칙 헤드에서 생성된 빈 노드가 이전의 더 낮은 층과 기본 그래프를 사용하여 계산된 결과에만 종속되도록 규칙 간 종속성에 제약을 부과한다. 이는 주어진 기본 그래프에 대한 규칙 집합 평가에서 하나의 명확하고 유한한 결과가 생성되도록 보장한다.

층화 계층

층화 계층 SL은 서로소인 규칙 집합의 쌍(SL.once, SL.general)이다. SL.once에는 일회 실행 규칙이 포함된다. 이 규칙들은 할당 요소를 사용하거나 규칙 헤드에서 빈 노드를 생성하며, 각각 층화 계층의 평가를 시작할 때 정확히 한 번 평가한다. SL.general에는 나머지 규칙이 포함되며, 새로운 트리플이 더 이상 추론되지 않을 때까지 반복해서 평가한다.

층화

규칙 집합의 층화는 층화 계층의 시퀀스이다. 규칙 집합의 각 규칙은 층화 계층 중 하나에 속한 집합 하나에만 나타난다.

## 출력 -- 맵: 정수 -> 규칙 집합.

define stratification(ruleSet):

    let DP = Dependency graph for the rule set.
    let stratumMap be a map from rule to integer

    ## 종속성 그래프는 층화 조건을 충족해야 한다.
    ## 무제한 층화 검사는 층화 조건 위반으로부터 
    ## 보호하기 위한 것이다.
    let limit = num rules + 1
    let maxStratum = 0

    ## stratumMap 초기화
    foreach rule in ruleSet.rules:
        stratumMap.set(rule, 0)
        endfor

    boolean changed = true;
    while changed:
        changed = false;
        foreach edge E in DP:
            ## 레이블이 있는 pRule에서 qRule로 향하는 간선
            let pRule = source of edge
            let qRule = destination of the edge
            let label = edge label

            if label == "open" :
                if stratumMap.get(pRule) < stratumMap.get(qRule) :
                    stratumMap.set(pRule, stratumMap.get(qRule))
                    changed = true;
                endif
            endif
            if label == "closed" :
                if stratumMap.get(pRule) <= stratumMap.get(qRule) :
                    let xStratum = 1 + stratumMap.get(qRule)
                    if ( xStratum > limit )
                        ## 층화 요구 사항 위반
                        error "Stratification error"
                        endif
                    stratumMap.set(pRule, xStratum)
                    maxStratum = max(maxStratum, xStratum)
                    changed = true;
                endif
            endif
        endfor
    endwhile

    ## 결과 맵을 초기화한다.
    let stratumRules be a map from integer to rules.
    for i = 0 to maxStratum
        stratumRules.set(i, {})
    endfor

    ## stratumMap에서 계층 번호가 같은 규칙을 모은다
    for rule R in map stratumMap:
        let stratumNum = stratumMap.get(R)
        add R to stratumRules.get(stratumNum)
    endfor

    ## 각 계층을 once와 general로 분할한다
    let stratumLevels be a sequence of pairs of sets of rules.
    for i = 0 to maxStratum:
        let rules = stratumRules.get(i)
        let once = { R in rules | R is a run-once rule }
        let general = rules \ once
        stratumLevels.set(i, pair(once, general))
    endfor

    the result is stratumLevels
enddefine

웹에서 문서를 읽는 작업은 보안에 영향을 미친다. 규칙 집합 가져오기 지원은 SRL 프로세서에서 선택 사항이다. 또한 구현은 특정 규칙 집합만 가져오고 다른 집합은 가져오지 않거나, 검증된 사본에서만 가져오는 방식으로 부분적으로 지원할 수 있다.

가져오기 처리에는 다음 조건이 적용된다:

• 규칙 집합 가져오기를 지원하지 않는 구현은 IMPORTS 문을 포함하는 규칙 집합을 거부해야 하며 오류를 알려야 한다.
• 부분적인 지원을 제공하는 구현은 지원하지 않는 가져오기를 발견하면 오류를 알려야 한다.
• 구현은 가져오기 문서를 해석할 수 없거나 문서가 구문적으로 유효하지 않으면 오류를 알려야 한다.
• 프로세서는 IMPORTS 문을 처리할 때 무한 루프가 발생하지 않도록 규칙 집합을 한 번만 가져와야 한다.

해석된 규칙 집합은 다른 규칙 집합의 가져오기에 언급된 모든 규칙 집합을 재귀적으로 읽어서 해당 규칙 집합으로부터 생성한다.

예제 알고리즘은 A. 가져오기 알고리즘 예제에서 제공한다.

솔루션 매핑

솔루션 매핑 μ는 부분 함수 μ : V → T이다. 여기서 V는 모든 변수의 집합이고, T는 모든 RDF 항의 집합이다. μ의 정의역은 dom(μ)으로 나타내며, 이는 μ가 정의된 V의 부분집합이다. 솔루션 매핑을 의미한다는 것이 명확한 경우 솔루션이라는 용어를 사용한다. dom(μ0)이 공집합인 솔루션 매핑을 μ₀으로 표기한다.

치환 함수

치환 함수 또는 간단히 치환은 함수 subst(μ, 트리플 패턴)이며, 트리플 패턴에서 dom(μ)에 속하는 변수가 나타날 때마다 해당 변수를 var에 대해 솔루션 매핑이 지정한 RDF 항으로 대체한 트리플 패턴을 반환한다. 트리플 패턴 결과에 변수가 없으면 이는 RDF 트리플이다.

평가 그래프

평가 그래프는 RDF 그래프로, 기본 그래프와 규칙 세트를 평가하는 동안 생성된 모든 트리플을 결합한다.

그래프 일치

그래프 일치는 트리플 패턴을 RDF 그래프의 트리플에 매핑하는 방법을 찾는다.

G를 RDF 그래프, TP를 트리플 패턴이라고 하자. 함수 graphMatch(G, TP)는 트리플 패턴에 적용했을 때 평가 그래프에 있는 트리플을 생성하는 가능한 모든 솔루션의 집합을 반환한다

G를 RDF 그래프, TP를 트리플 패턴, V를 TP에 나타나는 변수의 집합이라고 하자.

graphMatch(G, TP) = { μ | dom(μ) = V and subst(μ, TP) is a triple in G }

솔루션 호환성

두 솔루션 S1과 S2가 공통 변수에 대해 일치하면 호환된다.

S1과 S2를 솔루션이라고 하자.

compatible(μ1, μ2) = true
                      if forall v in dom(μ1) intersection dom(μ2)
                          μ1(v) = μ2(v)
compatible(μ1, μ2) = false otherwise

솔루션 시퀀스

솔루션 시퀀스는 솔루션의 다중 집합이다. 시퀀스에는 정의된 순서가 없다. 이는 순서가 없는 목록과 동일하며 중복 항목을 포함할 수 있다.

솔루션 병합

두 솔루션이 호환되면 두 솔루션의 병합은 각 솔루션의 변수를 두 솔루션 중 하나의 RDF 항에 매핑하는 솔루션이다.

μ₁, μ₂를 솔루션 매핑, S1과 S2를 솔루션 시퀀스라고 하자.

merge(μ1, μ2) = { μ |
                    μ(v) = μ1(v) if v in dom(μ1)
                    μ(v) = μ2(v) otherwise }

merge(S1, S2) = { μ |
                    μ1 in S1, μ2 in S2
                    and compatible(μ1, μ2)
                    μ(v) = merge(μ1, μ2) }

참고

merge(S1, S2)의 정의역은 domain(S1) ∪︀ domain(S2)이다

두 솔루션에 공통 변수가 없으면 서로 호환되며, 두 솔루션의 병합은 S1과 S2의 합집합이다.

유효 불리언 값

함수 EBV(x)는 RDF 항의 유효 불리언 값을 반환한다.

규칙 집합 평가에는 가져온 모든 규칙 집합을 수집하고, 4.5 가져오기 처리에 설명된 대로 하나의 결합된 규칙 집합을 구축하는 과정이 포함된다.

그런 다음 다음 단계에 따라 결합된 규칙 집합을 평가할 수 있도록 준비한다.

1. 4.2 올바른 형식 조건에 설명된 대로 각 규칙이 올바른 형식의 규칙인지 확인한다.
2. 4.3.2 의존성 그래프 알고리즘에 설명된 대로 의존성 그래프를 계산한다.
3. 4.4.2 계층화 알고리즘에 설명된 대로 결합된 규칙 집합의 계층화를 계산한다).

필터 요소 또는 할당 요소에서 사용되는 표현식은, 표현식 안의 각 변수에 대해 RDF 용어인 값을 제공하는 해 매핑과 관련하여 평가됩니다. 4.2 올바른 형식 조건의 올바른 형식 요구사항은 표현식 안의 모든 변수가 해 매핑에 나타나도록 보장합니다.

define evalFunction(F, μ):
    ## F is an expression: an RDF term, a variable, or op(expr1, ..., exprN)
    ## where op is a function or a functional form.
    if F is an RDF term:
        return F
    if F is a variable:
        ## By well-formedness, F ∈ dom(μ).
        return μ(F)
    ## F is of the form F= op(expr1, ..., exprN)
    if op is a functional form (e.g. IF, logical-or):
        ## Evaluated specifically for op; op may evaluate only some arguments.
        ## For example, IF(c, t, f) evaluates c, then exactly one of t or f.
        return the value defined for op over expr1, ..., exprN under μ
    ## op is an ordinary function: evaluate all arguments first.
    return F(evalFunction(expr1, row), ..., evalFunction(exprN, row))
enddefine

규칙은 규칙 본문에서 해답 시퀀스를 계산한 다음, 해답 시퀀스의 각 해답 매핑을 사용하여 규칙 헤드를 통해 트리플을 생성하는 방식으로 평가된다.

트리플 패턴 내의 빈 노드는 변수처럼 동작한다. 이는 SPARQL 그래프 패턴 매칭과 호환된다.

# Evaluate rule body
# This function returns a sequence of solutions

define evalRuleElements(B, SEQ, G, GD):
    where 
        B is a sequence of rule elements
        SEQ is a solution sequence 
        G and GD are RDF graphs

    for each rule element rElt in B:

        if rElt is a triple pattern TP:
            X = graphMatch(G, TP)
            SEQ1 = {}
            for each μ1 in X:
                for each μ2 in SEQ:
                    if compatible(μ1, μ2)
                      μ3 = merge(μ1, μ2)
                      add μ3 to SEQ1
                    endif
                endfor
            endfor
        endif

        if rElt is a condition element F:
            SEQ1 = {}
            for each solution μ in SEQ:
                let x = evalFunction(F.expr, μ)
                if EBV(x) is true:
                    add μ to SEQ1
                endif
            endfor
        endif

        if rElt is a negation expression N:
            SEQ1 = {}
            for each solution μ in SEQ:
                S = sequence{ μ }
                if rElt with DATA:
                    NEG = evalRuleElements(N.inner, S, GD, GD)
                else:
                    NEG = evalRuleElements(N.inner, S, G, GD)
                if NEG is empty
                    add μ to SEQ1
                endif
            endfor
        endif

        if rElt is an assignment A:
            SEQ1 = {}
            for each solution μ in SEQ:
                let x = evalFunction(A.expr, μ)
                if x is not an error:
                    ## Add mapping V -> x to solution μ
                    let μ2 be a solution mapping μ ∪︀ { (A.var, x) }
                    add μ2 to SEQ1
                else
                    # Error: drop solution μ
                endif
            endfor
        endif

        SEQ = SEQ1
    endfor

    return SEQ
enddefine

define evalRule(R, G, GD):
    where 
        R is a well-formed rule
        G and GD are RDF graphs
    let B be R.body 
        where each blank node in a triple pattern in R.body
        is replaced by a variable which is not used in the rule. 
        The same variable is used for each occurrence of the
        same blank node, and a different variable is used for 
       each different blank node.

    # Solution sequence of one solution that does not map any variables.
    let SEQ0: Solution sequence = { μ0 }

    if R.data:
        let SEQ = evalRuleElements(B, SEQ0, GD, GD)
    else
        let SEQ = evalRuleElements(B, SEQ0, G, GD)
    
    # Evaluate rule head
    let OUT = empty set
    for each μ in SEQ:
        let S = {}
        for each triple template TT in R.head:
            let triple = subst(μ, TT)
            Add triple to S
        endfor
        OUT = OUT union S
    endfor
    return OUT
enddefine

규칙 집합의 평가는 해당 규칙 집합의 계층화에 있는 각 계층을 실행하는 것으로 정의되며, 각 계층은 다음 계층으로 이동하기 전에 순서대로 완전히 실행된다. 계층은 먼저 해당 계층의 각 일회 실행 규칙을 평가한 다음, 새 트리플이 더 이상 생성되지 않을 때까지 해당 계층의 일반 규칙을 반복해서 평가하는 방식으로 평가된다.

let G0 be the input base graph
let RS be the rule set
let D be the graph of all DATA triples in RS

Apply stratification to RS

let LS be the sequence of layers after stratification

# Inference graph
let GI = { t ∈ D | t ∉ G0 }

let GD = G0 ∪︀ D

# Evaluation graph.
let GE = GD

for each stratum ST in LS:
    for each rule R in ST.once:
        let X = evalRule(R, GE, G0)
        let Y = { t ∈ X | t ∉ GE }
        GI = GI ∪︀ Y
        GE = GE ∪︀ Y
    endfor

    let finished = false
    while !finished:
        finished = true
        for each rule R in ST.general:
            let X = evalRule(R, GE, G0)
            let Y = { t ∈ X | t ∉ GE }
            if Y is not empty:
                finished = false
                GI = GI ∪︀ Y
                GE = GE ∪︀ Y
            endif
        endfor
    endwhile
endfor
the result is GI

버전 레이블은 SPARQL-RL의 구문 및 의미론 적합성을 식별하는 문자열이다.

버전 선언은 문서 앞부분에서 하는 것이 좋다.

하나의 SPARQL-RL 문서에 여러 VERSION 지시문이 나타날 수 있다. 각 지시문은 해당 지시문 뒤에 있는 문서 부분에 적용되며, 다른 지시문을 만나거나 문서 끝에 도달할 때까지 적용된다.

버전 레이블은 미디어 유형의 version 매개변수로 지정할 수도 있다. 현재 적용되는 VERSION 지시문이 없으면 미디어 유형의 일부로 지정된 버전을 고려한다.

공백 (생성 규칙 WS)은 공백이 없으면 하나의 종단 기호로 잘못 인식될 수 있는 두 종단 기호를 구분하는 데 사용된다. 아래에서 대문자로 표시된 규칙 이름은 공백이 중요한 위치를 나타내며, 이 규칙들은 SPARQL-RL 파서를 구성하는 데 사용할 수 있는 종단 기호의 한 가지 선택지를 형성한다.

생성 규칙 String에서는 공백이 중요하다.

주석은 IRIREF, STRING_LITERAL1, STRING_LITERAL2, STRING_LITERAL_LONG1 또는 STRING_LITERAL_LONG2 외부의 #로 시작하며, 줄 끝(LF 또는 CR로 표시됨)까지 계속된다. 주석 표시 뒤에 줄 끝이 없으면 파일 끝까지 계속된다. 주석은 공백으로 취급된다.

상대 IRI 참조는 통합 자원 식별자(URI): 일반 구문 [RFC3986]에 따라 기본 IRI를 사용하여 해석하며, 5.2절의 기본 알고리즘만 사용한다. 구문 기반 정규화와 스킴 기반 정규화 (RFC3986의 6.2.2절과 6.2.3절에서 설명됨)는 모두 수행하지 않는다. IRI 참조에서 추가로 허용되는 문자는 국제화 자원 식별자 (IRI) [RFC3987]의 6.5절에 따라 URI 참조의 예약되지 않은 문자와 같은 방식으로 처리한다.

BASE 지시문은 [RFC3986]에 따라 상대 IRI 참조를 해석하는 데 사용하는 기본 IRI를 정의한다. 5.1.1절, "콘텐츠에 포함된 기본 URI". 5.1.2절, "캡슐화 엔터티에서 가져온 기본 URI"에서는 범위 내 기본 IRI가 xml:base 지시문이 있는 SOAP 봉투나 Content-Location 헤더가 있는 MIME 멀티파트 문서와 같은 캡슐화 문서에서 제공될 수 있는 방법을 정의한다. 5.1.3절, "검색 URI에서 가져온 기본 URI"에서 식별하는 "검색 URI"는 특정 SPARQL-RL 문서를 검색한 URL이다. 위의 어느 항목도 기본 URI를 지정하지 않으면 기본 기본 URI(5.1.4절, "기본 기본 URI")를 사용한다. 각 BASE 지시문은 이전 URI를 기준으로 새로운 범위 내 기본 URI를 설정한다.

SRL 문서에는 다음 세 가지 형식의 이스케이프가 사용된다:

• 숫자 이스케이프 시퀀스는 유니코드 코드 포인트의 값을 나타낸다.

  숫자 이스케이프 시퀀스는 다음 범위의 코드 포인트 값을 생성해서는 안 된다: U+D800부터 U+DFFF까지. 이는 유니코드 서로게이트의 범위이다.

  이스케이프 시퀀스	유니코드 코드 포인트
  \u hex hex hex hex	가장 높은 자릿수부터 가장 낮은 자릿수까지 해석한 4개의 16진수가 인코딩하는 값에 해당하며, U+0000부터 U+D7FF까지 및 U+E000부터 U+FFFF까지의 범위에 속하는 유니코드 코드 포인트.
  \U hex hex hex hex hex hex hex hex	가장 높은 자릿수부터 가장 낮은 자릿수까지 해석한 8개의 16진수가 인코딩하는 값에 해당하며, U+0000부터 U+D7FF까지 및 U+E000부터 U+10FFFF까지의 범위에 속하는 유니코드 코드 포인트.

  여기서 hex는 16진수 문자이다

  HEX ::= [0-9] | [A-F] | [a-f]

• 문자열 이스케이프 시퀀스는 문자열 리터럴에서 전통적으로 이스케이프되는 문자를 나타낸다:

  이스케이프 시퀀스	유니코드 코드 포인트
  \t	U+0009
  \b	U+0008
  \n	U+000A
  \r	U+000D
  \f	U+000C
  \"	U+0022
  \'	U+0027
  \\	U+005C

• 예약 문자 이스케이프 시퀀스는 \ 뒤에 ~.-!$&'()*+,;=/?#@%_ 문자 중 하나가 이어지는 형식이며, \의 오른쪽에 있는 문자를 나타낸다.

여기서 사용하는 EBNF는 XML 1.0 [EBNF-NOTATION]에 정의되어 있다.

이 문법의 텍스트 버전은 여기에서 확인할 수 있습니다.

이 문서는 몇 가지 특정 터미널 리터럴 문자열을 사용합니다 [EBNF-NOTATION]. 이러한 터미널 리터럴 문자열에 사용되는 유니코드 코드 포인트를 명확히 하기 위해 다음 표에서는 이 섹션에서 사용되는 특정 문자를 설명합니다.