SPARQL 1.2 RL

次の仕様は、この文書で使用される 基本的な用語を提供します。

• RDF 1.2 の概念と抽象データモデル [RDF12-CONCEPTS]
• SPARQL 1.2 クエリ言語 [SPARQL12-QUERY]

この文書における RDF データの例では、 RDF 1.2 Turtle [RDF12-TURTLE] を使用します。

この文書では、次の名前空間接頭辞バインディングを使用します。

文書全体を通して、色分けされたボックスには SPARQL-RL 構文のルール または Turtle 構文の RDF グラフが含まれます。

# このボックスはルールを表します

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

# このボックスは推論されたデータを表します

変数

変数は、トリプルパターン内で取り得るRDF 用語を表します。 変数は、式でも使用されます。

式

式は、RDF 用語、変数、 または引数への関数もしくは関数形式の適用であり、 各引数自体も式です。 式は、解写像に対して評価され、 RDF用語を結果として与えるか、評価の結果として エラーになります。 式は、 SPARQLの式と互換性があります。

データブロック

データブロックは、トリプルの集合です。 これらのトリプルは、追加の事実として推論グラフに追加され、 推論プロセスに含まれます。

トリプルパターン

トリプルパターンは、各要素が 変数、RDF 用語、または トリプル用語のパターンで、変数を含むものである3つ組です。 この組の第2要素は、IRIまたは 変数でなければなりません。 トリプルパターンが現れるのは、本体、すなわち規則の本体であり、 RDFトリプルの照合に使用されます。

トリプルテンプレート

トリプルテンプレートは、各要素が 変数、RDF用語、または トリプル用語のテンプレートで、変数を含むものである3つ組です。 この組の第2要素は、IRI または変数でなければなりません。 トリプルテンプレートが現れるのは、頭部、すなわち規則の頭部であり、 RDFトリプルの生成に使用されます。

注

トリプル用語のパターンまたはテンプレートで、 変数が現れないものは、トリプル用語であり、したがって、 RDF用語でもあります。

フィルター要素

フィルター要素は、式であり、 規則要素として現れます。 これは、変数の値を制限するために パターン照合で使用されます。

トリプルパターン要素

トリプルパターン要素は、トリプルパターンであり、 規則要素として現れます。

否定要素

否定要素は、規則要素です。 これは、否定要素の本体を持ち、 その構成は、トリプルパターン要素と フィルター要素の列です。 否定要素は、1つの フラグ、 .evaldataを持ち、 照合にどのグラフを使用するかを示します。 その照合対象は、否定要素の本体です。

代入 要素

代入要素は、規則要素であり、 次のものから構成される対です。 変数で、代入変数と呼ばれるもの、 および式で、代入式と呼ばれるものです。

集約要素

集約要素は、規則要素であり、 集約キー、 集約パターン、 および集約代入の集合を持ちます。 各集約代入は、次のものから構成される対です。 変数で、集約変数と呼ばれるもの、 および集約関数です。 集約パターンは、 トリプルパターン要素と フィルター要素の列から構成されます。

規則要素

規則要素は、次のいずれかです。 トリプルパターン要素、 フィルター要素、 否定要素、 代入要素、または 集約要素。

規則の頭部

規則の頭部は、トリプル テンプレートの列です。

規則の本体

規則の本体は、規則要素の列です。 すなわち、列の各要素は、次のいずれかです。 トリプルパターン要素、 フィルター要素、 否定要素、 代入要素、または 集約要素。

規則集合のインポート

規則集合のインポート（単に「インポート」と呼ぶことも多い）は、 URLのコレクションであり、 IMPORTS文に由来し、 評価中に組み込まれる他の規則集合を対象とします。

規則

規則は、規則の頭部（単に 「頭部」と呼ぶことも多い）、 規則の本体（単に「本体」と呼ぶことも多い）、 およびフラグ.evaldataを含みます。 このフラグは、どの グラフを照合に使用するかを示し、本体内のトリプルパターンを対象とします。 規則には、識別を助けるためにURIまたは空白ノードを付与できます。

単一実行規則

単一実行規則は、ちょうど一度だけ実行される規則であり、 規則集合の評価における特定の時点で実行されます。 規則は、単一実行 規則です。ただし、次のいずれかが成り立つ場合です。

• 規則の本体が代入要素を持つ場合。
• 規則の本体が集約要素を持つ場合。
• トリプルテンプレートで、規則の頭部にあるものが、空白ノードを持つ場合。
• トリプルテンプレートで、規則の頭部にあるものが、次のテンプレートを持つ場合。 トリプル用語のテンプレートで、変数が現れるもの。

一般規則

一般規則は、単一実行規則ではない規則です。 一般規則は、規則集合の評価中に複数回実行される場合があります。

規則集合

規則集合は、0個以上の規則のコレクション、 0個以上のデータブロックのコレクション、 および0個以上の規則集合のインポートのコレクションです。 解決済み 規則集合は、規則集合であり、 インポートを持ちません。 解決済み規則集合は、別の規則集合から、 インポート処理を適用することによって作成されます。

基本グラフ

基本グラフは、RDFグラフであり、 評価プロセスへの入力として与えられます。

推論 グラフ

推論グラフは、RDFグラフであり、 規則集合の評価によって生成されます。 これは、推論されたすべてのトリプルのうち、 基本グラフに存在しないものを含みます。 これらは、次の適用によって推論されます。 規則集合の、基本グラフへの適用です。

規則集合の 評価

規則集合の評価は、規則集合を 基本グラフに適用して、推論 グラフを生成するプロセスです。 規則の 評価は、規則を一度評価するプロセスです。 規則の評価は、規則の頭部が与えるすべてのトリプルを生成します。 これは、規則の本体の評価によって行われ、 トリプルが基本グラフにあるか、すでに規則集合の評価中に推論されたものか、 または新しく推論されたトリプルであるかは問いません。 規則集合の評価中に、規則は 複数回評価される場合があります。

SPARQL-RLは、2つの操作、推論と問合せを提供します。

推論

推論は、規則集合を、与えられた 基本グラフに適用し、推論グラフを生成する操作で、このグラフは推論された トリプルを含みます。これは、完全な規則集合の評価を適用します。

問合せ

問合せは、与えられたパターンについて、 その導出が基本グラフから、規則集合を使用して可能かどうかを判定し、 解列を返す操作であり、その各解写像は、 変数に対するRDF用語を与えます。

問合せは、推論操作を実行し、 続いて目標パターンを、結合された 基本グラフと推論 グラフに照合する効果を持ちます。

問合せ操作は、すべての規則を評価しない場合があります。代わりに、 問合せの目標に答えるために必要な規則のみを 評価してもかまいません。

SPARQL-RL処理系

SPARQL-RL処理系は、 SPARQL-RL 仕様を実装し、規則集合を評価でき、次の操作の一方または両方を 提供するシステムです。推論および問合せ。

トリプルパターンまたはトリプル テンプレートでは、 組の位置1を、非形式的に主語と呼び、 位置2を、非形式的に述語と呼び、 位置3を、非形式的に目的語と呼びます。

規則集合と規則のさまざまな構成要素には、次の表記を使用します。

整形式性は、抽象構文に対する条件の集合であり、 規則集合を対象とします。これらの条件は、全体として次のことを保証します。 変数で、 頭部にあるものは、その規則の本体で定義された値を持つこと、 各変数が、フィルター要素 または代入式内にある場合、 評価時点で値を持つこと、 および、各 代入変数 と集約変数が、 規則内で新しいものであり、規則の本体でそれ以前に使用されていないことです。

elt_iを、次の列のi番目の要素とします。 規則要素の列であり、Nをその列の 長さとします。

V₀を、その列の初期変数とします。

V_iを、iが 1からNまでの場合について、 変数の集合で、スコープ内にあるものとします。その時点は要素 elt_iの後です。

V_allを、次の値とします。 V_N。

V_iを帰納的に定義します。

規則要素の列は、 整形式の列です。 ただし、変数の集合V₀が与えられたとき、 次の条件が各iについて満たされる場合であり、 その範囲は1からNまでです。

規則は、整形式の 規則です。 ただし、規則要素の列で、規則の本体のものが、 整形式の列であり、その開始時に V₀が 空集合であり、 かつ各変数が、トリプルテンプレート内にあって、そのテンプレートが規則の頭部のものであるとき、 V_allの要素である場合です。

規則集合が整形式の規則集合であるための必要十分条件は、 その規則集合のすべての規則が整形式の規則であることです。

規則R1は、2番目の規則の出力が 最初の規則の本体の評価に影響する場合、規則R2に依存します。すなわち、R2の頭部は トリプルテンプレートを持ち、それは、次のものに一致するトリプルを生成できます。 トリプルパターンで、R1の本体内にあり、 トリプルパターン要素として、または否定要素内、 もしくは集約パターン内にあるものです。

依存関係には2種類あります。 閉じた依存関係と開いた 依存関係です。 閉じた依存関係は、規則R2が、 規則R1の実行前に、可能な出力をすべて生成済みであることを保証します。 規則の依存関係が閉じていない場合、それは開いた依存関係です。 これは、最初の規則R1の実行を許可します。 その一方で、規則R2は、さらにトリプルを生成するために再実行される可能性があり、 それによって、R2からの新しいトリプルを用いてR1が再評価されることがあります。

フラグ.evaldataがfalseに設定された規則は、 基本グラフを使用して照合を行い、その規則には依存関係がありません。

この最初の例では、最初の規則は開いた依存関係を持ちます。 その依存先は2番目の規則です。

この2番目の例では、最初の規則は閉じた依存関係を持ちます。 その依存先は2番目の規則です。トリプルパターン?x :status :criticallyExposedは、 最初の規則の否定要素内に現れ、 2番目の規則の頭部にあるトリプルテンプレートに一致します。 最初の規則は、2番目の規則が 可能な出力をすべて生成するまで評価できません。

トリプルパターンの照合

トリプルパターンがトリプルテンプレートに一致するのは、 そのトリプルテンプレートが生成できるトリプルが、一致する場合です。その一致先は当該トリプルパターンです。

トリプルパターンの依存関係

トリプルパターンは、 依存するといいます。その依存先が トリプルテンプレートであるのは、 そのトリプルパターンが、 一致できる場合です。 その一致先は、当該トリプルテンプレートです。

規則の依存関係

規則R1は、依存 するといいます。 その依存先が規則R2であるのは、 R1.evaldataがtrueであり、いずれかのトリプル パターンで、R1の本体内にあり、 トリプルパターン要素として現れるもの、 または 否定要素neg内にあって、 neg.evaldataがtrueであるもの、 または集約パターン内にあるものが、 依存する場合です。その依存先はトリプル テンプレートであり、 R2の頭部にあるものです。

閉じた依存関係

規則の依存関係で、規則R1から規則 R2へのものは、閉じた依存関係です。 ただし、次のいずれかの条件が成り立つ場合です。

• トリプルパターンで、否定要素内に現れ、その要素が R1のものであり、当該否定要素のフラグ .evaldataがtrueであるものが、 トリプルテンプレートに一致し、そのテンプレートが規則の頭部、すなわちR2の頭部にある場合。
• 規則R1が依存する先が規則R2であり、 かつR1が単一実行規則である場合。

開いた依存関係

規則の依存関係で、規則R1から規則 R2へのものは、 開いた依存関係です。ただし、その依存関係が 閉じた依存関係ではない場合です。

define mergeLabel(oldLabel, newLabel):
    # 閉じた依存関係は開いた依存関係に優先します。
    if oldLabel == "open" and newLabel == "open":
        the result is "open"
    else:
        the result is "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:
        let bodyDependencies = {}

        if R1.evaldata then:
            # 規則内の各トリプルパターンTPを、"open"または"closed"を必要とするものとして分類します
            # その分類は、否定要素内または集約
            # パターン内にあるかどうかによります。
            foreach rule element RBE in R1.body:
                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 filter element:
                    # 何もしません
                else if RBE is a negation element:
                    if RBE.evaldata then:
                        foreach triple pattern TP in RBE.inner:
                            let item be a pair (TP, "closed")
                            add item to bodyDependencies
                        endfor
                    endif
                else if RBE is an assignment element:
                    # 何もしません
                else if RBE is an aggregation element:
                    foreach triple pattern TP in RBE.pattern:
                        let item be a pair (TP, "closed")
                        add item to bodyDependencies
                    endfor
                endif
            endfor
        endif

        foreach pair (triple pattern TP, depLabel) in bodyDependencies:
            if R1 is a run-once rule:
              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 は、そのレイヤーの残りのルールの集合であり、 新しいトリプルが推論されなくなるまで繰り返し評価されます。

階層化

階層化は、ルール集合に対する、階層化レイヤーの列です。 ルール集合内の各ルールは、いずれか 1 つの集合にちょうど一度現れます。 その集合は、いずれか 1 つの階層化レイヤーに属します。

階層化レイヤーには、それらが属する階層化内で番号が付けられます。 番号はゼロから始まります。層番号は、ルールに対して、その番号を表します。 これは、階層化レイヤーのうち、そのルールを含むものの番号です。 より小さい層番号を持つルールは、 下位の層にあります。 より大きい層番号を持つルールは、 上位の層にあります。

ルール R1 からルール R2 へのすべての辺について、 依存グラフが属するルール集合では、次の条件が成り立ちます。

• 辺に closed というラベルが付いている場合、層 番号について、 R1 の値は、層 番号の R2 の値より厳密に大きくなります。
• 辺に open というラベルが付いている場合、層 番号について、 R1 の値は、層 番号の R2 の値以上になります。

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.
    foreach i = 0 to maxStratum
        stratumRules.set(i, {})
    endfor

    # stratumMap 内で同じレベル番号を持つルールを集めます
    foreach 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

Web から文書を読み込むことには、セキュリティ上の影響がある。 ルールセットのインポートへの対応は、SPARQL-RL プロセッサーでは任意である。 さらに、実装は 任意で部分的なサポートを提供してもよく、 例えば、特定のルールセットのインポートのみをサポートし、他はサポートしないことや、 検証済みのコピーからのみインポートすることなどがある。

インポートの処理には、次の条件が適用される。

• ルールセットのインポートをサポートしない実装は 必ず、 ルールセットに IMPORTS 文が含まれる場合、それを拒否し、 エラーを通知しなければならない。
• 部分的なサポートを提供する実装は、 必ず、サポート対象外のインポートに遭遇した場合、 エラーを通知しなければならない。
• 実装は 必ず、インポート対象の 文書を解決できない場合、 またはその文書が構文的に妥当でない場合に、エラーを通知しなければならない。
• プロセッサーは 必ず、無限ループを防ぐため、ルールセットを一度だけインポートしなければならない （IMPORTS 文を処理する際）。

解決済みルールセットは、別のルールセットのインポートを基に、 そこに記載されたすべてのルールセットを再帰的に読み込むことにより、 その元となる ルールセットから生成される。

アルゴリズムの例を B. インポートの例示 アルゴリズムに示す。

解写像

解写像 μ は、部分 関数 μ : V → Tです。 ここで、V はすべての変数の集合であり、 T はすべてのRDF 用語の集合です。 μ の定義域は、 dom(μ)で表され、 μ が定義されている V の部分集合です。 解という用語は、解写像を意味することが明らかな場合に使用できます。 μ₀ は、 dom(μ0)が空集合となる解写像を表すものとします。

置換関数

置換関数、または単に置換は、 次の関数です。 subst(μ, トリプルパターン) この関数は、トリプルパターンを返します。 ここで、トリプルパターンに出現する各変数 var のうち、 dom(μ) に含まれるものは、RDF 用語に置き換えられます。これは、 解写像が var に対して与えるものです。 結果のトリプルパターンに変数がない場合、それは RDF トリプルです。

関数 subst(μ, トリプルテンプレート) も同様に定義されます。各変数の出現箇所について、 トリプルテンプレート内の変数は、RDF 用語に置き換えられます。これは、 解写像が var に対して与えるものです。

テンプレートインスタンス関数

テンプレートインスタンス関数は、次の関数です。 replaceBlankNodes(list of トリプルテンプレート) この関数は、 トリプルテンプレートのリストを返し、各空白ノードは、 引数内で新しい空白ノードに置き換えられます。 同じ空白ノードの複数の出現箇所は、 同じ新しい空白ノードに置き換えられます。

評価 グラフ

評価グラフは、RDF グラフであり、基底グラフ と、ルール集合の評価中に生成されたすべてのトリプルを組み合わせたものです。

グラフマッチ

グラフマッチは、トリプルパターンを トリプルに写像する方法を見つけます。対象は、RDF グラフ内のトリプルです。

G をRDF グラフ、TP をトリプルパターンとします。 関数 graphMatch(G, TP) は、可能なすべての 解の集合を返します。これらの解は、 トリプルパターンに適用すると、 グラフ G 内にあるトリプルを生成します。

G をRDF グラフ、TP をトリプルパターン、 V を TP に出現する変数の集合とします。

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

解の互換性

2 つの解 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

解列

解列は、解の多重集合です。 この列には順序が定義されていません。 これは順序のないリストに相当し、重複を含むことができます。

解のマージ

2 つの解が互換である場合、2 つの解のマージは、 各解の変数をRDF 用語に写像する解です。 この RDF 用語は、いずれか一方の解に由来します。

μ₁、μ₂ を解写像、S1 と S2 を解列とします。

merge(μ1, μ2) = μ such that
                    μ(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)
                    μ = merge(μ1, μ2) }

注

merge(μ1, μ2)の定義域は、 domain(μ1) ∪ domain(μ2)です。

2 つの解に共通する変数がない場合、それらは互換であり、 2 つの解のマージは、 μ₁ と μ₂ の和集合です。

実効ブール値

関数 EBV(x) は、実効ブール値を返します。 対象は、RDF 用語です。

ルールセットの評価には、インポートされたすべてのルールセットを収集し、 4.5 インポートの 処理で説明されているように、単一の結合されたルールセットを構築することが含まれます。

次に、結合されたルールセットを 以下の手順で評価用に準備します。

1. 各ルールが整形式のルールであることを、 4.2 整形式 条件で説明されているように確認します。
2. 依存関係グラフを、 4.3.2 依存関係グラフのアルゴリズムで説明されているように計算します。
3. 結合されたルールセットの層別化を、 4.4 層別化で説明されているように計算します。 4.4.2 層別化アルゴリズムでは、 層別化を計算する方法の一例を示します。

式は、フィルター要素で使用される場合でも、 代入要素で使用される場合でも、 ソリューションマッピングに関して評価されます。 ソリューションマッピングは、式内の各変数に RDF 項の値を提供します。 4.2 整形式条件の要件により、 式内のすべての変数が ソリューションマッピングに現れることが保証されます。

define evalFunction(F, μ):
    # F は式であり、RDF 項、変数、または op(expr1, ..., exprN) である。
    #   ここで、op は関数または関数形式である。
    # μ は解マッピングである。

    # 評価中にエラーが発生すると、evalFunction はエラーを返す。
    if F is an error:
        return error
    if F is an RDF term:
        return F
    if F is a variable:
        # 整形式性により、F ∈ dom(μ) である。
        return μ(F)
    # F は F = op(expr1, ..., exprN) という形式である。
    if op is a functional form (e.g., IF, logical-or):
        # op に固有の方法で評価される。op は一部の引数のみを評価する場合がある。
        # 例えば、IF(c, t, f) は c を評価し、その後、必ず 
        # t または f の一方だけが評価される。
        return the value defined for op over expr1, ..., exprN under μ
    # op は通常の関数である。最初にすべての引数を評価する。
    return op(evalFunction(expr1, μ), ..., evalFunction(exprN, μ))
enddefine

define evalAggregate(AGGF, SEQ)
@@
    # AGGF は、引数として変数
    # と解列を取る集約関数です。RDF 用語の値を返します。

    # DISTINCT は COUNT にのみ許可されることに注意してください
    # COUNT(*) は特別なケースです。
endefine

ルールは、解 列をルール本体から計算し、 次に各解写像を、その解列から使用して、 トリプルを生成することで評価されます。これにはルールヘッドを使用します。

ルール本体内では、トリプルパターン内の空白ノードは変数のように振る舞います。 これは、 SPARQL のグラフパターンマッチングと互換性があります。

空白ノードを変数として扱う

空白ノードは、トリプル パターン内で変数として扱われます。これは、 ルール本体内の各空白ノードを、 そのルールで使用されていない変数に置き換えることで行います。 これには、トリプル用語内の空白ノードの置換も含まれます。 同じ変数が、各出現箇所に使用されます。 これは同じ空白ノードの出現箇所であり、異なる変数が、 異なる空白ノードごとに使用されます。

# ルール本体を評価する
# この関数は解の列を返す

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

    foreach rule element rElt in B:

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

        if rElt is a filter element F:
            SEQ1 = {}
            foreach solution μ in SEQ:
                let x = evalFunction(F.expr, μ)
                if x is not an error and EBV(x) is true:
                    add μ to SEQ1
                endif
            endfor
        endif

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

        if rElt is an assignment element A:
            SEQ1 = {}
            foreach solution μ in SEQ:
                let x = evalFunction(A.expr, μ)
                if x is not an error:
                    # 写像 A.var -> x を解 μ に追加する
                    let μ2 be a solution mapping μ ∪ { (A.var, x) }
                    add μ2 to SEQ1
                else:
                    # エラー: 解 μ を破棄する
                endif
            endfor
        endif

        ## COUNT(*) はどうするか？
        if rElt is an aggregation element AGG:
            let SEQX = evalRuleElements(AGG.pattern, SEQ, G, GD)
            let KGRP = empty map of solution mappings to solution sequences
            # 解写像をグループに割り当てる。
            foreach solution μx in SEQX:
                let μk be μx restricted to AGG.grouping
                if KGRP[μk] is defined:
                    Add μx to the solution sequence KGRP[μk]
                else:
                    KGRP[μk] = solution sequence of one element μx
                endif
            endfor
            # 各グループについて、集約関数を計算し、
            # グループキーと
            # 集約代入の結果を含む解写像を作成する。
            let SEQ1 be an empty solution sequence
            foreach key K of map KGRP:
                let X be solution sequence of KGRP[K]
                let Z be an empty solution mapping
                foreach aggregation function F in AGG.assignments:
                    let V = calculate F.function(X)
                    add solution mapping (F.var, V) to Z
                endfor
                Z = merge(Z, K)
                add Z to SEQ1
            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
        treating blank nodes as variables.

    # どの変数も写像しない 1 つの解からなる解列。
    let SEQ0: Solution sequence = { μ0 }

    if R.evaldata:
        let SEQ = evalRuleElements(B, SEQ0, G, GD)
    else:
        let SEQ = evalRuleElements(B, SEQ0, GD, GD)
    endif

    # ルールヘッドを評価する
    let OUT = empty set
    foreach μ in SEQ:
        let S = {}
        # 各空白ノードを新しい空白ノードに置き換えたルールヘッド
        let HT = replaceBlankNodes(R.head)
        foreach triple template TT in HT
            let triple = subst(μ, TT)
            Add triple to S
        endfor
        OUT = OUT ∪ 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

# 推論グラフ
let GI = { t ∈ D | t ∉ G0 }

# 評価グラフとデータブロック
let GE = G0 ∪ D

foreach stratum ST in LS:
    foreach 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
        foreach 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 の構文および意味論への 適合性を識別する文字列です。

バージョン宣言は、文書の早い段階で行うべきです。

複数の VERSION ディレクティブが SPARQL-RL 文書に現れる場合があります。 各ディレクティブは、そのディレクティブに続く文書の部分に適用され、 別のディレクティブが現れるか、文書の末尾に達するまで有効です。

バージョンラベルは、version パラメーターによっても指定できます。 メディアタイプの。現在有効な VERSION ディレクティブがない場合は、 メディアタイプの一部として指定されたバージョンが考慮されます。

空白文字 (生成規則 WS) は、 そうしなければ誤って1つの終端記号として認識される 2つの終端記号を分離するために使用される。 以下の大文字で表記された規則名は、空白文字が 重要となる箇所を示す。これらは、 SPARQL-RL パーサーを構築するための終端記号の選択肢の1つとなる。

次の生成規則では空白が意味を持ちます。 String。

コメントは、次の外側にある # で始まります。 IRIREF、 STRING_LITERAL1、 STRING_LITERAL2、 STRING_LITERAL_LONG1、または STRING_LITERAL_LONG2、 そして行末（次によって示される）まで続きます。 LF、または CR）、 または、コメントマーカーの後に行末がない場合はファイルの末尾まで続きます。 コメントは空白として扱われます。

相対 IRI 参照はベース IRI を使用し、Uniform Resource Identifier (URI): 汎用 構文 [RFC3986] に従い、 5.2 節の基本アルゴリズムのみを使用して解決されます。 構文ベースの正規化もスキームベースの正規化も （RFC3986 の 6.2.2 節および 6.2.3 節で説明されています）実行されません。 IRI 参照で追加で許可される文字は、 URI 参照における非予約文字と同じ方法で、国際化リソース識別子 (IRI) [RFC3987] の 6.5 節に従って扱われます。

BASE ディレクティブは、次を解決するために使用されるベース IRI を定義します。 相対 IRI 参照を、[RFC3986] の 5.1.1 節「ベース URI の コンテンツへの埋め込み」に従って解決します。 5.1.2 節「カプセル化する エンティティからのベース URI」 は、有効範囲内のベース IRI がカプセル化文書からどのように得られるかを定義します。 たとえば、xml:base ディレクティブを持つ SOAP エンベロープや、MIME マルチパート文書の Content-Location ヘッダーです。 5.1.3 節「取得 URI からのベース URI」で特定される「取得 URI」は、 特定のSPARQL-RL 文書が取得された URL です。 上記のいずれもベース URI を指定していない場合は、デフォルトの ベース URI（5.1.4 節「デフォルトのベース URI」）が 使用されます。 各 BASE ディレクティブは、新しい有効範囲内のベース URI を設定し、 直前のものを基準とします。

SPARQL-RL 文書では 3 種類のエスケープが使用されます。

• 数値エスケープシーケンスは、 Unicode コードポイントの値を表します。

  数値エスケープシーケンスは、 生成してはなりません。コードポイント値が U+D800 から U+DFFF の範囲にある場合、 これは Unicode のサロゲートの範囲です。

  エスケープシーケンス	Unicode コードポイント
  \u hex hex hex hex	Unicode コードポイント U+0000 から U+D7FF の範囲 および U+E000 から U+FFFF の範囲にあり、 4 桁の 16 進数字を解釈して符号化された値に対応し、 最上位桁から最下位桁の順に解釈されます。
  \U hex hex hex hex hex hex hex hex	Unicode コードポイント U+0000 から U+D7FF の範囲 および U+E000 から U+10FFFF の範囲にあり、 8 桁の 16 進数字で符号化された値に対応し、 最上位桁から最下位桁の順に解釈されます。

  ここで hex は 16 進文字です

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

• 文字列エスケープシーケンスは、文字列リテラルで従来 エスケープされている文字を表します。

  エスケープシーケンス	Unicode コードポイント
  \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]。

この文法のテキスト版は、 "sparql-rl-grammar.bnfで入手できる。

この文書では、いくつかの終端記号のリテラル文字列を使用する [EBNF-NOTATION]。使用される Unicode コードポイントを明確にするため、 これらの 終端記号のリテラル文字列について、次の表で使用される具体的な 文字を示す。