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 项，或者是一个模式，用于表示 三元组项，其中包含 变量。 该元组的第二个元素是一个 IRI 或一个 变量。 三元组模式 出现在 主体 中，该主体属于一个 规则 并用于匹配 RDF 三元组。

三元组模板

一个 三元组模板 是一个三元组，其中每个元素都是 一个 变量、一个 RDF 项，或者是一个模板，用于表示 三元组项，其中包含 变量。 该元组的第二个元素是一个 IRI 或一个 变量。 三元组模板 出现在 头部 中，该头部属于一个 规则，并 用于生成 RDF 三元组。

注

一个模式或模板，若用于表示 三元组项，且其中没有 变量 出现，则它就是一个 三元组项，因此也是 一个 RDF 项。

三元组模式元素

一个 三元组模式元素 是一个 三元组模式 其出现时的身份为一个 规则元素。

过滤元素

一个 过滤元素 是一个 表达式 其出现时的身份为一个 规则元素。 它用于限制变量的取值 在模式匹配过程中。

否定元素

一个 否定元素 是一个 规则元素。 它有一个 否定元素主体 由以下元素的序列组成：三元组模式元素 和 过滤元素。 一个 否定元素 有 一个 标志， .evaldata， 用于指示使用哪个图来匹配 该 否定元素主体。

赋值 元素

一个 赋值元素 是一个 规则元素，其形式是 一个有序对，组成项 为一个 变量，称为 赋值变量， 以及一个 表达式，称为 赋值表达式。

分组元素

一个 分组元素 是一个 规则元素 带有一组变量，称为 分组键， 一个 分组 模式，以及一组 聚合赋值。 每个 聚合赋值 是一个有序对，其组成项为 一个 变量，称为 聚合变量， 以及一个 聚合函数。 该 分组模式 的组成 是以下元素的序列：三元组模式元素、过滤元素和赋值元素。

规则元素

一个 规则元素 是以下任意一种： 三元组模式元素、 过滤元素、 否定元素、 赋值元素，或 分组元素。

规则头

一个 规则头 是一个序列，其元素为 三元组 模板。

规则体

一个 规则体 是一个序列，其元素为 规则元素； 也就是说，每个序列元素都是以下之一： 一个 三元组模式元素、 一个 过滤元素、 一个 否定元素、 一个 赋值元素，或 一个 分组元素。

规则集导入

规则集导入 (通常简称 "导入") 是 URL 的集合 这些 URL 来自 IMPORTS 语句 用于指定求值过程中将包含的其他规则集。

规则

一个 规则 包含一个 规则头 (通常简称 "头部")， 一个 规则体 (通常简称 "主体")， 以及 一个标志 .evaldata 用于指示使用哪个 图来匹配 三元组模式，这些模式位于主体中。 可以为规则指定一个 URI 或空白节点，以帮助标识它。

单次运行规则

一个 单次运行规则 是一个恰好运行一次的规则，运行于 规则集求值过程中的某个特定时刻。 一个 规则 属于 单次运行 规则，如果以下任一条件成立：

• 该 规则体 有一个 赋值元素；
• 该 规则体 有一个 分组 元素；
• 一个 三元组模板，属于该 规则头，有一个 空白节点；
• 一个 三元组模板，属于该 规则头，有一个模板，用于表示 三元组项，其中有一个 变量 出现。

一般规则

一个 一般规则 是一个不属于 单次运行规则 的规则。 一般规则在规则集求值过程中可能运行多次。

规则集

一个 规则集 包括一个集合，包含零个或多个 规则， 一个集合，包含零个或多个 数据块， 以及一个集合，包含零个或多个 规则集导入。 一个 已解析 规则集 是一个 规则集 其中没有导入。 一个 已解析规则集 从另一个 规则集 创建 通过应用 导入过程。

基础图

一个 基础图 是一个 RDF 图，作为输入提供给 求值过程。

推理 图

一个 推理图 是一个 RDF 图，生成于 一次 规则集求值。 它包含所有推导出的三元组，这些三元组不存在于 基础图 且通过应用以下规则集推导得出： 规则集，应用目标为 基础图。

规则集 求值

一次 规则集求值 是应用一个 规则集 的过程 应用目标为一个 基础图，以生成一个 推理 图。 一次 规则 求值 是对规则求值一次的过程。 对规则求值会生成所有由以下部分给出的三元组：规则头 其生成依据是对以下部分的求值：规则体，无论一个 三元组是位于 基础图 中、已在以下过程中推导得出：规则集求值， 还是新推导出的三元组。 在 规则集求值 过程中，一个规则的求值次数可能多于 一次。

SPARQL-RL 提供两个操作，推断 和 查询。

推断

推断 是将一个 规则集 应用于给定的 基础图 并生成一个 推断图 的操作，该图包含推断出的 三元组。它应用完整的 规则集求值。

查询

查询 是确定给定模式是否 可从一个 基础图 推导出的操作，使用该 规则集，并 返回一个 解序列，其中每个 解映射 为变量给出 RDF 术语。

查询 的效果相当于执行一次 推断 操作， 然后将目标模式与合并后的 基础图 和 推断 图 进行匹配。

该 查询 操作可以不对所有规则求值；而是，它 可以只对回答查询所必需的规则求值 ，以满足查询目标。

SPARQL-RL 处理器

一个 SPARQL-RL 处理器 是一个实现了 SPARQL-RL 规范的系统，能够对 规则集 求值，并提供一个或两个 操作，即 推断 和 查询。

在一个 三元组模式 或一个 三元组 模板 中， 元组的位置 1 非正式地称为主语， 位置 2 非正式地称为谓语，而 位置 3 非正式地称为宾语。

以下记法用于规则集和规则的各个组成部分。

良构性 是一组关于抽象语法的条件，适用于 一个 规则集。这些条件共同确保 一个 变量，若位于 头部（属于某个规则），则其值已定义在 主体（属于该规则）中； 每个变量，若位于一个 过滤元素 或 赋值表达式 中，则在求值时具有一个值； 并且每个 赋值变量 和 聚合变量 在规则中都是新的，且此前未在规则体中使用过。

令 S 为一个序列，其元素为 规则元素。

令 elt_i 为 S 的第 i 个元素， 并令 N 为该序列的长度。

令 V₀ 为一组变量，称为初始 变量，所属序列为 S。

将 vars(S, i, V₀) 定义为一个变量集合 这些变量在序列 S 的第 i 个元素之后处于作用域内， 给定初始变量 V₀。vars(S, i, V₀) 的定义采用 归纳方式：

将 vars(S, V₀)，即 S 中处于作用域内的变量集合，定义 为 vars(S, N, V₀)，即处于作用域内的变量集合 在该序列的最后一个元素之后。

一个序列，其元素为 规则元素，记为 S， 是一个 良构序列， 给定一组变量 V₀， 如果以下条件对每个 i 均成立， 其范围为 1 到 N：

一个 规则 是一个 良构 规则 如果以下元素组成的序列：规则元素，属于 规则体， 是一个 良构序列，且起始时 V₀ 为空集， 并且每个变量，若位于一个 三元组模板 中，该模板属于 规则头， 则是 vars(S, V₀) 的元素。

一个 规则集 是一个 良构规则集，当且仅当所有 规则（属于该规则集）都是 良构规则。

规则 R1 依赖于规则 R2，如果第二个规则的输出 影响第一个规则主体的求值。也就是说，R2 的头部 有一个 三元组模板，能够生成一个三元组，该三元组可匹配 一个 三元组模式，位于 R1 的主体中， 该模式可以作为一个 三元组模式元素，也可以位于一个 否定元素 或一个 分组模式 内。

依赖有两种： 封闭依赖 和 开放 依赖。 一个封闭依赖确保规则 R2 在规则 R1 执行之前已生成其所有可能的输出。 如果规则依赖不是封闭的，则它是一个开放依赖。 它允许第一条规则 R1 执行 ，同时规则 R2 仍可能再次运行以生成更多三元组 ，这些三元组随后可能使 R1 使用来自 R2 的新三元组重新求值。

标志 .evaldata 设置为 false 的规则使用 基础图 进行匹配，并且该规则没有依赖。

在第一个示例中，第一条规则具有一个开放依赖 ，依赖于第二条规则。

在第二个示例中，第一条规则具有一个封闭依赖 ，依赖于第二条规则：三元组模式 ?x :status :criticallyExposed 出现在一个 否定元素 内部，该元素属于第一条规则，并且该模式 匹配一个 三元组模板，该模板位于第二条规则的规则头中。 第一条规则不能求值，直到第二条规则 已生成其所有可能的输出。

三元组模式匹配

一个 三元组模式 匹配一个 三元组模板，如果 该三元组模板能够 生成 一个三元组，该三元组 匹配 该三元组模式。

三元组模式依赖

一个 三元组模式 依赖于 一个 三元组模板 ，如果该 三元组模式 能够 匹配 该 三元组模板。

规则依赖

规则 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 a group 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 是该层级中其余规则的集合， 这些规则会被反复求值，直到不再推导出新的三元组。

分层

一个 分层，属于一个 规则集，是一个序列，其元素为 分层层级。 每个规则，若位于一个 规则集 中，均恰好出现在某一个集合中，该集合属于某一个 分层层级。

这些 分层层级，属于一个 分层，其编号 从零开始。层号，对于一个 规则，指的是编号 该编号属于一个 分层层级，其中包含该规则。 规则若具有较小的 层号，则位于一个 较低 的层； 规则若具有较大的 层号，则位于一个 较高 的层。

对于每条从规则 R1 指向规则 R2 的边，它位于 依赖图 中，该图属于 规则集：

• 如果该边的标签为 封闭，则 层 号（所属规则为 R1）严格大于 层 号（所属规则为 R2）。
• 如果该边的标签为 开放，则 层 号（所属规则为 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

    let 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 "分层错误"
                    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
    foreach 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(列表，其元素为 三元组模板) 它 返回一个列表，其元素为 三元组模板，其中每个 空白节点 若位于实参中，则被替换为一个新的空白节点。 同一空白节点的多次出现 会被替换为同一个新的空白节点。

求值 图

一个 求值图 是一个 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 }

解兼容性

两个解 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) = μ 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)。

如果两个解没有共有变量，则它们兼容， 且这两个解的合并是以下两者的并集： μ₁ 和 μ₂。

有效布尔值

函数 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
    endif
    if F is an RDF term:
        return F
    endif
    if F is a variable:
        # 根据良构性，F ∈ dom(μ)。
        return μ(F)
    endif
    # 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 μ
    endif
    # op 是一个普通函数：先对所有实参求值。
    return op(evalFunction(expr1, μ), ..., evalFunction(exprN, μ))
enddefine

define evalAggregate(AGGF, SEQ):
@@
    # AGGF 是一个聚合函数，其实参包括一个变量
    # 和一个解序列。它返回一个 RDF 项值。

    # 注意，DISTINCT 仅允许用于 COUNT
    # 特殊情况 COUNT(*)。
enddefine

一条 规则 的求值方式是计算一个 解 序列，其来源为 规则体 然后使用每个 解映射，这些解映射属于该 解序列，以便 利用 规则头 生成三元组。

在规则体中，位于 三元组模式 中的空白节点的行为与变量相同。 这兼容于 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 a group element GRP:
            SEQ1 = {}
            foreach solution μ in SEQ:
                let μp be the restriction of μ to GRP.keys
                let SEQX = evalRuleElements(GRP.pattern, { μp }, G, GD)
                # 将解映射分配到各个分组。
                let KGRP = empty map of solution mappings to solution sequences
                foreach solution μx in SEQX:
                    let μk be the restriction of μx to GRP.keys
                    if KGRP[μk] is defined:
                        add μx to the solution sequence KGRP[μk]
                    else:
                        KGRP[μk] = solution sequence of one element μx
                    endif
                endfor
                # 对于每个分组，计算聚合函数，并扩展
                # 当前解映射 μ，使用分组键
                # 以及聚合赋值的结果。
                foreach key K of map KGRP:
                    let X be the solution sequence of KGRP[K]
                    let Z be an empty solution mapping
                    foreach aggregation function F in GRP.aggregations:
                        let V = calculate F.function(X)
                        add solution mapping (F.var, V) to Z
                    endfor
                    Z = merge(Z, K)
                    Z = merge(Z, μ)
                    add Z to SEQ1
                endfor
            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.

    # 仅包含一个不映射任何变量的解的解序列。
    let SEQ0 be the 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）用于 分隔两个原本会被错误地 识别为一个终结符的终结符。 下文以大写字母表示的规则名称指明空白字符在何处 具有重要意义；这些规则构成了用于构建 SPARQL-RL 解析器时可选用的一组终结符。

空白字符在产生式 String中具有重要意义。

注释以位于 IRIREF、 STRING_LITERAL1、 STRING_LITERAL2、 STRING_LITERAL_LONG1 或 STRING_LITERAL_LONG2 之外的 # 开始， 并持续到行尾（由 LF 或 CR 标记）， 如果注释标记之后没有行尾，则持续到文件末尾。 注释被视为空白字符。

相对 IRI 引用使用基 IRI 按照 统一资源标识符（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 信封或具有 Content-Location 标头的 MIME 多部分文档。 在 5.1.3，“来自检索 URI 的基 URI”中标识的“检索 URI”， 是从中检索特定SPARQL-RL 文档的 URL。 如果上述内容均未指定基 URI，则使用默认 基 URI（第 5.1.4 节，“默认基 URI”）。 每个 BASE 指令都会设置一个新的作用域内基 URI， 相对于前一个基 URI。

SPARQL-RL 文档中使用三种形式的转义：

• 一个 数字转义序列表示 一个 Unicode 代码点的值。

  一个数字转义序列不得产生 范围为 U+D800 到 U+DFFF 的代码点值， 这是 Unicode 代理的范围。

  转义序列	Unicode 代码点
  \u hex hex hex hex	一个 Unicode 代码点 位于 U+0000 到 U+D7FF 以及 U+E000 到 U+FFFF 的范围内， 对应于由四个十六进制数字编码的值，按 从最高有效位到最低有效位的顺序解释。
  \U hex hex hex hex hex hex hex hex	一个 Unicode 代码点 位于 U+0000 到 U+D7FF 以及 U+E000 到 U+10FFFF 的范围内， 对应于由八个十六进制数字编码的值， 按从最高有效位到最低有效位的顺序解释。

  其中 hex 是一个十六进制字符

  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 码点，下表列出了所使用的具体 字符。