[Paper Review] The Problem of Correlation and Substitution in SPARQL -- Extended Version

Daniel Hernández, Claudio Gutiérrez+1 more|arXiv (Cornell University)|Jan 13, 2018

Semantic Web and Ontologies11 references3 citations

TL;DR

This paper identifies and formalizes the core problem of variable substitution in SPARQL subqueries, particularly in correlated and nested queries with incomplete data. Using a novel formalism—Nested Datalog and Modal Datalog—it reveals that differing evaluation strategies across SPARQL engines (Fuseki, Virtuoso, Blazegraph, rdf4j) stem from ambiguous substitution semantics, and demonstrates that logical vs. syntactic substitution lead to inconsistent results, especially when nulls or optional patterns are involved.

ABSTRACT

Implementations of a standard language are expected to give same outputs to identical queries. In this paper we study why different implementations of SPARQL (Fuseki, Virtuoso, Blazegraph and rdf4j) behave differently when evaluating queries with correlated variables. We show that at the core of this problem lies the historically troubling notion of logical substitution. We present a formal framework to study this issue based on Datalog that besides clarifying the problem, gives a solid base to define and implement nesting.

Motivation & Objective

• To identify the root cause of inconsistent SPARQL subquery evaluation across major implementations (Fuseki, Virtuoso, Blazegraph, rdf4j).
• To analyze how the notion of substitution—especially in correlated and nested subqueries—leads to divergent results, particularly when incomplete data (e.g., nulls) is involved.
• To formalize the problem using Nested Datalog and Modal Datalog, distinguishing between syntactic and logical substitution strategies.
• To clarify the semantic ambiguity in the SPARQL specification regarding variable binding and substitution in FILTER EXISTS subqueries.
• To provide a logical framework that exposes the subtleties of substitution order and incompleteness, enabling consistent implementation.

Proposed method

• Introduce Nested Datalog as an extension of classical Datalog to model nested SPARQL subqueries with variable substitution.
• Use Modal Datalog to formalize incomplete information, particularly null values, by introducing modal operators to represent uncertainty in variable binding.
• Model SPARQL subqueries as logical expressions with distinct substitution strategies: top-down, bottom-up, or intermediate substitution levels.
• Construct dependency graphs to visualize substitution order and variable propagation across nested query levels.
• Define three substitution interpretations: (1) logical substitution at the top, (2) substitution after variable binding, and (3) improper substitution in the middle of evaluation.
• Map SPARQL queries to Modal Datalog rules and evaluate them under different substitution semantics to compare system behaviors.

Experimental results

Research questions

• RQ1 Why do major SPARQL engines produce inconsistent results for the same correlated subquery with OPTIONAL and FILTER EXISTS patterns?
• RQ2 What are the distinct substitution strategies (syntactic vs. logical) that lead to divergent query outcomes in nested SPARQL queries?
• RQ3 How does the presence of incomplete data (e.g., nulls or unbound variables) affect the correctness and consistency of variable substitution in SPARQL?
• RQ4 In what ways does the current SPARQL specification fail to define substitution clearly, leading to implementation discrepancies?
• RQ5 How can a formal logical framework like Nested and Modal Datalog be used to model and distinguish between different substitution semantics in nested queries?

Key findings

• Fuseki and Blazegraph return (1, *.com), (3, *.com), and (5, -) for the example query, while Virtuoso returns only (1, *.com) and (3, *.com), and rdf4j returns (3, *.com) and (5, -), showing no consensus across engines.
• The discrepancy arises from different substitution strategies: some systems substitute variables before evaluating the inner query, others after, and some apply substitutions in the middle of evaluation.
• Syntactic substitution (binding variables before evaluation) leads to only person 1 being returned in one interpretation, while logical substitution allows multiple answers.
• When substitution is applied at Level 2 (after variable instantiation but before filtering), persons 3 and 5 succeed—only rdf4j agrees with this interpretation.
• Substitution at Level 3 (just after variable instantiation) leads to answers including person 1, 3, and 5, which is consistent with Blazegraph and Fuseki’s behavior, though this approach is logically flawed due to improper substitution chains.
• No system correctly implements the top-down substitution strategy, which would yield only person 5 as the correct answer under logical substitution, indicating a systemic lack of standardization.