Terminology

The following specifications provide fundamental terminology used in this document:

• [[[RDF12-CONCEPTS]]] [[RDF12-CONCEPTS]]
• [[[SPARQL12-QUERY]]] [[SPARQL12-QUERY]]

Document Conventions

Examples of RDF data in this document use [[[RDF12-TURTLE]]] [[RDF12-TURTLE]].

Within this document, the following namespace prefix bindings are used:

Throughout the document, color-coded boxes contain rules in SPARQL-RL syntax or contain RDF graphs in Turtle syntax.

        # This box represents rules

        # This box represents input data

        # This box represents inferred data

Elements of the Abstract Syntax

Variable

A [=variable=] represents a possible [=RDF term=] in a triple pattern. Variables are also used in expressions.

Expression

An [=expression=] is an [=RDF term=], a [=variable=], or the application of a function or a functional form to arguments, where each argument is itself an [=expression=]. An expression is evaluated with respect to a [=solution mapping=], giving an [=RDF term=] as the result, or evaluation results in an error. Expressions are compatible with SPARQL expressions.

Data block

A [=data block=] is a set of triples. These triples are added to the inference graph as additional facts and are included in the inference process.

Triple pattern

A [=triple pattern=] is a 3-tuple where each element is a [=variable=], an [=RDF term=], or a pattern for a [=triple term=] with [=variables=]. The second element of the tuple must be an [=IRI=] or a [=variable=]. [=Triple patterns=] appear in the [=body=] of a [=rule=] and are used to match [=RDF triples=].

Triple template

A [=triple template=] is a 3-tuple where each element is a [=variable=], an [=RDF term=], or a template for a [=triple term=] with [=variables=]. The second element of the tuple must be an [=IRI=] or a [=variable=]. [=Triple templates=] appear in the [=head=] of a [=rule=] and are used to generate [=RDF triples=].

A pattern or template for a [=triple term=] in which no [=variable=] occurs is a [=triple term=], and therefore also an [=RDF term=].

Filter element

A [=filter element=] is an [=expression=] that appears as a [=rule element=]. It is used to restrict the values of variables in pattern matching.

Triple pattern element

A [=triple pattern element=] is a [=triple pattern=] that appears as a [=rule element=].

Negation element

A [=negation element=] is a [=rule element=]. It has a negation element body composed of a sequence of [=triple pattern elements=] and [=filter elements=]. A [=negation element=] has a flag, .evaldata, to indicate which graph to use for matching the [=negation element body=].

Assignment element

An [=assignment element=] is a [=rule element=] that is a pair consisting of a variable, called the assignment variable, and an expression, called the assignment expression.

Rule element

A [=rule element=] is any one of [=triple pattern element=], [=filter element=], [=negation element=], or [=assignment element=].

Rule head

A [=rule head=] is a sequence of [=triple templates=].

Rule body

A [=rule body=] is a sequence of [=rule elements=]; that is, each sequence element is one of a [=triple pattern element=], a [=filter element=], a [=negation element=], or an [=assignment element=].

Rule set imports

[=Rule set imports=] (often just "imports") are the collection of URLs from the `IMPORTS` statements for other rule sets that will be included during evaluation.

Rule

A [=rule=] contains a [=rule head=] (often just "head"), a [=rule body=] (often just "body"), and a flag .evaldata to indicate which graph to use for matching [=triple patterns=] in the body. A rule can be given a URI or a blank node to help identify it.

Run-once rule

A [=run-once rule=] is a rule that is run exactly once at a particular point in the evaluation of a rule set. A [=rule=] is a [=run-once rule=] if any of the following hold:

• the [=rule body=] has an [=assignment element=];
• a [=triple template=] of the [=rule head=] has a [=blank node=];
• a [=triple template=] of the [=rule head=] has a template for a [=triple term=] in which a [=variable=] occurs.

General rule

A [=general rule=] is a rule that is not a [=run-once rule=]. General rules may run more than once during rule set evaluation.

Rule set

A [=rule set=] is a collection of zero or more [=rules=], a collection of zero or more [=data blocks=], and a collection of zero or more [=rule set imports=]. A resolved rule set is a [=rule set=] that has no imports. A [=resolved rule set=] is created from another [=rule set=] by applying the imports process.

Base graph

A [=base graph=] is the [=RDF graph=] given as input to the evaluation process.

Inference graph

An [=inference graph=] is an [=RDF graph=] produced by a rule set evaluation. It contains all inferred triples not present in the [=base graph=] that are inferred by applying the [=rule set=] to the [=base graph=].

Rule set evaluation

A [=rule set evaluation=] is the process of applying a [=rule set=] to a [=base graph=] to produce an [=inference graph=]. A rule evaluation is the process of evaluating a rule once. Evaluating a rule produces all the triples given by the [=rule head=] by the evaluation of the [=rule body=], regardless of whether a triple is in the [=base graph=], already inferred during [=rule set evaluation=], or is a new inferred triple. During [=rule set evaluation=], a rule may be evaluated more than once.

SPARQL-RL provides two operations, [=infer=] and [=query=].

Infer

[=Infer=] is the operation that applies a [=rule set=] to a given [=base graph=] and produces an [=inference graph=] containing inferred triples. It applies the full [=rule set evaluation=].

Query

[=Query=] is the operation that determines whether a given pattern can be derived from a [=base graph=] using the [=rule set=] and returns a [=solution sequence=] in which each [=solution mapping=] gives RDF terms for variables.

[=Query=] has the effect of performing an [=infer=] operation, followed by matching the goal pattern to the combined [=base graph=] and [=inference graph=].

The [=query=] operation may not evaluate all rules; instead, it may only evaluate rules that are necessary to answer the query goal.

SPARQL-RL processor

A [=SPARQL-RL processor=] is a system that implements the SPARQL-RL specification, can evaluate [=rule sets=], and provides one or both of the operations [=infer=] and [=query=].

In a [=triple pattern=] or a [=triple template=], position 1 of the tuple is informally called the subject, position 2 is informally called the predicate, and position 3 is informally called the object.

The elements of a sequence of [=rule elements=] are labeled starting at 1.

The following notation is used for the various components of rule sets and rules.

Well-formedness Conditions

Well-formedness is a set of conditions on the abstract syntax of a [=rule set=]. Together, these conditions ensure that a [=variable=] in the [=head=] of a rule has a value defined in the [=body=] of the rule; that each variable in a [=filter element=] or [=assignment expression=] has a value at the point of evaluation; and that each assignment in a rule introduces a new variable, one that has not been used earlier in the rule body.

Define well-formedness for a sequence of [=rule elements=] given an initial set of variables.

Let elt_i be the i-th element of a sequence of [=rule elements=].

Let vars_i be the set of variables defined by elt_i as follows:

Let V₀ be the initial variables of the sequence.

Let V_i be the union of V₀ and all vars_j, for j from 1 to i.

Let V_all be the value of V_N, where N is the length of the sequence.

A well-formed sequence is a sequence of [=rule elements=], given a set of variables V₀, if the following conditions are met for each i, from 1 to N:

A [=rule=] is a well-formed rule if the sequence of [=rule elements=] of the [=rule body=] is a [=well-formed sequence=], starting with V₀ being the empty set, and if each variable in a [=triple template=] of the [=rule head=] is an element of V_all.

A [=rule set=] is a well-formed rule set if and only if all rules of the rule set are [=well-formed rules=].

Rule Dependency

A rule `R1` depends on a rule `R2` if the output of the second rule affects the evaluation of the body of the first rule. That is, the head of `R2` has a [=triple template=] that can generate a triple that matches a [=triple pattern=] in the body of `R1`, either as a [=triple pattern element=] or inside a [=negation element=].

There are two kinds of dependency: [=closed dependencies=] and [=open dependencies=]. A closed dependency ensures that rule `R2` has generated all its possible output before rule `R1` is executed. If a rule dependency is not closed, it is an open dependency which allows the first rule `R1` to be executed while the rule `R2` might be run again to generate further triples which can then cause `R1` to be reevaluated with the new triples from `R2`.

A rule with flag `.evaldata` set to `false` matches using the [=base graph=] and the rule has no dependencies.

In this first example, the first rule has an open dependency on the second rule.

In this second example, the first rule has a closed dependency on the second rule: the triple pattern `?x :status :criticallyExposed` occurs inside a [=negation element=] of the first rule and matches the [=triple template=] in the head of the second rule. The first rule cannot be evaluated until the second rule has generated all its possible output.

Triple pattern matching

A [=triple pattern=] matches a [=triple template=] if the triple template can [=generate=] a triple that [=matches=] the triple pattern.

Triple pattern dependency

A [=triple pattern=] depends on a [=triple template=] if the [=triple pattern=] can match the [=triple template=].

Rule dependency

Rule `R1` depends on rule `R2` if `R1.evaldata` is `true` and any [=triple pattern=] in the body of `R1`, whether as a [=triple pattern element=] or inside a [=negation element=] `neg` where `neg.evaldata` is `true`, depends on a triple template in the head of `R2`.

Closed dependency

A [=rule dependency=] of rule `R1` on rule `R2` is a [=closed dependency=] if any of the following conditions hold:

• A [=triple pattern=] occurring inside a [=negation element=] of `R1` where the [=negation element=] flag `.evaldata` is `true` matches a [=triple template=] in the [=rule head=] of `R2`.
• Rule `R1` depends on rule `R2` and `R1` is a [=run-once rule=].

Open dependency

A [=rule dependency=] of rule `R1` on rule `R2` is an [=open dependency=] if the dependency is not a [=closed dependency=].

define mergeLabel(oldLabel, newLabel):
    # Closed dependency overrides open dependency.
    if oldLabel == "open" and newLabel == "open":
        the result is "open"
    else:
        the result is "closed"
    endif
enddefine

# output -- Dependency graph with rule vertices and labeled edges.
define buildDependencyGraph(ruleSet):
    # edgeLabelMap maps (R1, R2) to "open" or "closed"
    let edgeLabelMap be a map from pair (rule, rule) to label

    foreach rule R1 in ruleSet.rules:
        let bodyDependencies = {}

        if R1.evaldata then:
            # Classify each triple pattern TP in the rule as requiring "open" or "closed"
            # depending on whether it is in a negation element or not.
            foreach rule element RBE in R1.body:
                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 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:
                    # Do nothing
                else if RBE is an assignment element:
                    # Do nothing
                endif
            endfor
        endif

        foreach pair (triple pattern TP, depLabel) in bodyDependencies:
            if R1 is a run-once rule:
              set depLabel to "closed"
            endif
            # Find dependencies for this triple pattern element or negation element.
            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
            

Stratification

[=Stratification=] is the process of partitioning a [=rule set=] into an ordered sequence of [=stratification layers=] (also known as "strata", singular "stratum"). Rules in lower [=strata=] are evaluated before rules in higher [=strata=].

[=Stratification=] imposes constraints on dependencies between [=rules=] to ensure that [=negation elements=] and [=run-once rules=] depend only on results computed using earlier (lower) [=strata=] and the [=base graph=]. This guarantees a single, well-defined, and finite outcome from the evaluation of a [=rule set=] over a given [=base graph=].

Stratification layer

A [=stratification layer=] `SL` is a pair of disjoint sets of rules (`SL.once`, `SL.general`). `SL.once` is exactly the [=run-once rules=] of the layer; these rules are each evaluated exactly once at the start of evaluation of the [=stratification layer=]. `SL.general` is the set of remaining rules of the layer, which are evaluated repeatedly until no new triples are inferred.

Stratification

A [=stratification=] of a [=rule set=] is a sequence of [=stratification layers=]. Each rule in a [=rule set=] appears in exactly one of the sets of one of the [=stratification layers=].

The [=stratification layers=] of a [=stratification=] are numbered from zero. The stratum number of a [=rule=] is the number of the [=stratification layer=] that contains the rule. A rule with a smaller [=stratum number=] is in a lower stratum; one with a larger [=stratum number=] is in a higher stratum.

For every edge from rule `R1` to rule `R2` in the [=dependency graph=] of the [=rule set=]:

• if the edge is labeled closed, the [=stratum number=] of `R1` is strictly greater than the [=stratum number=] of `R2`.
• if the edge is labeled open, the [=stratum number=] of `R1` is greater than or equal to the [=stratum number=] of `R2`.

A [=rule set=] can have more than one [=stratification=]. An implementation can use any [=stratification=] of the [=rule set=].

define stratification(ruleSet):

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

    # The dependency graph should satisfy the stratification condition.
    # The check for unbounded stratification is a guard
    # due to a violation of the stratification condition.
    let limit = num rules + 1
    let maxStratum = 0

    # initialize stratumMap
    foreach rule in ruleSet.rules:
        stratumMap.set(rule, 0)
    endfor

    boolean changed = true
    while changed:
        changed = false
        foreach edge E in DP:
            # Edge from pRule to qRule with a label
            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:
                        # Stratification requirement violated
                        error "Stratification error"
                    endif
                    stratumMap.set(pRule, xStratum)
                    maxStratum = max(maxStratum, xStratum)
                    changed = true
                endif
            endif
        endfor
    endwhile

    # Initialize the result map.
    let stratumRules be a map from integer to rules.
    foreach i = 0 to maxStratum
        stratumRules.set(i, {})
    endfor

    # Gather rules in stratumMap with the same level number
    foreach rule R in map stratumMap:
        let stratumNum = stratumMap.get(R)
        add R to stratumRules.get(stratumNum)
    endfor

    # Partition each level into once and 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
            

Processing Imports

Reading documents from the web has security implications. Support for importing rule sets is optional for [=SPARQL-RL processors=]. Further, implementations MAY provide partial support, such as supporting imports of certain rule sets and not others, and possibly from a verified copy.

The following conditions apply to imports processing:

• Implementations that do not support importing rule sets MUST reject a [=rule set=] that contains `IMPORTS` statements and signal an error.
• An implementation that provides partial support MUST signal an error if it encounters an import that it does not support.
• An implementation MUST signal an error if it cannot resolve the import document, or if the document is not syntactically valid.
• Processors MUST only import a rule set once to avoid infinite loops when processing `IMPORTS` statements.

A [=resolved rule set=] is produced from another rule set by recursively reading all rule sets mentioned in the imports of that other [=rule set=].

An example algorithm is provided in .

Evaluation Definitions

Solution mapping

A [=solution mapping=], μ, is a partial function μ : V → T, where V is the set of all variables and T is the set of all [=RDF terms=]. The domain of μ is denoted by dom(μ), and it is the subset of V for which μ is defined. The term [=solution=] can be used when it is clear that a [=solution mapping=] is meant. Write μ₀ for the solution mapping, such that dom(μ0) is the empty set.

Substitution function

The substitution function, or just a substitution, is a function subst(μ, [=triple pattern=]) that returns a [=triple pattern=] where each occurrence in the [=triple pattern=] of a variable var that is in the dom(μ) is replaced by the [=RDF term=] given by the [=solution mapping=] for var. If the triple pattern result has no variables, then it is an [=RDF triple=].

The function subst(μ, [=triple template=]) is similarly defined. Each occurrence of a variable in the [=triple template=] is replaced by the [=RDF term=] given by the [=solution mapping=] for var.

Template instance function

The template instance function is a function replaceBlankNodes(list of [=triple templates=]) that returns a list of [=triple templates=] where each [=blank node=] in the argument is replaced by a fresh blank node. Multiple occurrences of the same blank node are replaced by the same fresh blank node.

Evaluation graph

An [=evaluation graph=] is an [=RDF graph=] that combines the [=base graph=] and all triples produced during the evaluation of a rule set.

Graph match

A [=graph match=] finds the ways to map a triple pattern onto triples in an [=RDF graph=].

Let G be an [=RDF graph=] and TP be a [=triple pattern=]. The function `graphMatch(G, TP)` returns a set of all possible solutions that, when applied to the triple pattern, produce a triple that is in graph `G`.

Let G be an [=RDF graph=], TP be a [=triple pattern=], and V be the set of variables occurring in TP.

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

Solution compatible

Two solutions S1 and S2 are [=compatible=] if they agree on the variables in common.

Let S1 and S2 be solutions.

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

Solution sequence

A [=solution sequence=] is a multi-set of solutions. There is no defined order to the sequence. It is equivalent to an unordered list and it can contain duplicates.

Solution merge

If two solutions are compatible, the merge of two solutions is the solution that maps variables of each solution to the [=RDF term=] from one or other of the solutions.

Let μ₁, μ₂ be solution mappings, and S1 and S2 be solution sequences.

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) }

The domain of merge(μ1, μ2) is domain(μ1) ∪ domain(μ2).

If the two solutions have no variables in common, then they are compatible, and the merge of the two solutions is the union of the μ₁ and μ₂.

Effective boolean value

The function `EBV(x)` returns the effective boolean value for an [=RDF term=].

Preparation for Evaluation

Evaluation of a rule set involves collecting all imported rule sets, building a single, combined rule set as described in .

Next, the combined rule set is prepared for evaluation with the following steps.

1. Check that each rule is a [=well-formed rule=], as described in .
2. Calculate the [=dependency graph=], as described in .
3. Calculate a [=stratification=] of the combined rule set, as described in . gives one way to calculate a [=stratification=].

Evaluation of an Expression

An expression, whether used in a [=filter element=] or an [=assignment element=], is evaluated with respect to a [=solution mapping=]. The solution mapping provides the RDF term values for each variable in the expression. The well-formedness requirements of ensure that all variables in the expression appear in the solution mapping.

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.
    # μ is a solution mapping
    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 op(evalFunction(expr1, μ), ..., evalFunction(exprN, μ))
enddefine

Evaluation of a Rule

A [=rule=] is evaluated by calculating a [=solution sequence=] from the [=rule body=] and then using each [=solution mapping=] of the [=solution sequence=] to generate triples using the [=rule head=].

Blank nodes within [=triple patterns=] behave like variables. This is compatible with SPARQL graph pattern matching.

# 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

    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 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 A:
            SEQ1 = {}
            foreach solution μ in SEQ:
                let x = evalFunction(A.expr, μ)
                if x is not an error:
                    # Add mapping A.var -> 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.evaldata:
        let SEQ = evalRuleElements(B, SEQ0, G, GD)
    else:
        let SEQ = evalRuleElements(B, SEQ0, GD, GD)
    endif

    # Evaluate rule head
    let OUT = empty set
    foreach μ in SEQ:
        let S = {}
        # Rule head with each blank node replaced by a fresh blank node
        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

`OUT` may contain triples that are also in the [=base graph=].

Evaluation of a Rule Set

Evaluation of a [=rule set=] is defined as the execution of each [=stratum=] of a [=stratification=] of the rule set, where each stratum is executed completely and in order before moving on to the next [=stratum=]. A [=stratum=] is evaluated by first evaluating each of the [=run-once rules=] of that stratum, and then evaluating [=general rules=] of the stratum repeatedly until no new triples are produced.

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 }

# Evaluation graph and data blocks
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

Version Announcement

A version label is a string that identifies the syntax and semantics conformance for SPARQL-RL.

The version announcement SHOULD be made early in the document.

Multiple VERSION directives may appear in a [=SPARQL-RL document=]. Each directive applies to the part of the document following the directive, until another directive is encountered or the end of the document is reached.

[=Version labels=] can also be given by the `version` parameter of the Media Type. In the absence of a current VERSION directive, the version specified as part of the Media Type is considered.

White Space

White space (production WS) is used to separate two terminals that would otherwise be (mis-)recognized as one terminal. Rule names below in capitals indicate where white space is significant; these form a possible choice of terminals for constructing a SPARQL-RL parser.

White space is significant in the production String.

Comments

Comments start with a # outside an IRIREF, STRING_LITERAL1, STRING_LITERAL2, STRING_LITERAL_LONG1, or STRING_LITERAL_LONG2, and continue to the end of line (marked by LF, or CR), or end of file if there is no end of line after the comment marker. Comments are treated as white space.

IRI References

Relative IRI references are resolved with base IRIs as per [[[RFC3986]]] [[RFC3986]] using only the basic algorithm in section 5.2. Neither Syntax-Based Normalization nor Scheme-Based Normalization (described in sections 6.2.2 and 6.2.3 of RFC3986) is performed. Characters additionally allowed in IRI references are treated in the same way that unreserved characters are treated in URI references, per section 6.5 of [[[RFC3987]]] [[RFC3987]].

The BASE directive defines the Base IRI used to resolve relative IRI references per [[RFC3986]] section 5.1.1, "Base URI Embedded in Content". section 5.1.2, "Base URI from the Encapsulating Entity" defines how the In-Scope Base IRI may come from an encapsulating document, such as a SOAP envelope with an `xml:base` directive or a MIME multipart document with a `Content-Location` header. The "Retrieval URI" identified in 5.1.3, Base "URI from the Retrieval URI", is the URL from which a particular [=SPARQL-RL document=] was retrieved. If none of the above specifies the Base URI, the default Base URI (section 5.1.4, "Default Base URI") is used. Each BASE directive sets a new In-Scope Base URI, relative to the previous one.

Escape Sequences

There are three forms of escapes used in [=SPARQL-RL documents=]:

• A numeric escape sequence represents the value of a Unicode code point.

  A [=numeric escape sequence=] MUST NOT produce a code point value in the range U+D800 to U+DFFF, which is the range for Unicode surrogates.

  Escape sequence	Unicode code point
  \u hex hex hex hex	A Unicode code point in the ranges U+0000 to U+D7FF and U+E000 to U+FFFF, corresponding to the value encoded by the four hexadecimal digits interpreted from most significant to least significant digit.
  \U hex hex hex hex hex hex hex hex	A Unicode code point in the ranges U+0000 to U+D7FF and U+E000 to U+10FFFF, corresponding to the value encoded by the eight hexadecimal digits interpreted from most significant to least significant digit.

  where hex is a hexadecimal character

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

• A string escape sequence represents a character traditionally escaped in string literals:

  Escape sequence	Unicode code point
  \t	U+0009
  \b	U+0008
  \n	U+000A
  \r	U+000D
  \f	U+000C
  \"	U+0022
  \'	U+0027
  \\	U+005C

• A reserved character escape sequence consists of a \ followed by one of these characters ~.-!$&'()*+,;=/?#@%_, and represents the character to the right of the \.

%-encoded sequences are in the character range for IRIs and are explicitly allowed in local names. These appear as a % followed by two hex characters and represent that same sequence of three characters. These sequences are not decoded during processing. A term written as <http://a.example/%66oo-bar> designates the IRI http://a.example/%66oo-bar and not IRI http://a.example/foo-bar. A term written as ex:%66oo-bar with a prefix PREFIX ex: <http://a.example/> also designates the IRI http://a.example/%66oo-bar.

Grammar

The EBNF used here is defined in XML 1.0 [[!EBNF-NOTATION]].

A text version of this grammar is available here.

Selected Terminal Literal Strings

This document uses some specific terminal literal strings [[EBNF-NOTATION]]. To clarify the Unicode code points used for these terminal literal strings, the following table describes specific characters used in this section.