Optimizing SPARQL Query Answering over OWL Ontologies
The SPARQL query language is currently being extended by the World Wide Web Consortium (W3C) with so-called entailment regimes. An entailment regime defines how queries are evaluated under more expressive semantics than SPARQLs standard simple entailment, which is based on subgraph matching. The queries are very expressive since variables can occur within complex concepts and can also bind to concept or role names. In this paper, we describe a sound and complete algorithm for the OWL Direct Semantics entailment regime. We further propose several novel optimizations such as strategies for determining a good query execution order, query rewriting techniques, and show how specialized OWL reasoning tasks and the concept and role hierarchy can be used to reduce the query execution time. For determining a good execution order, we propose a cost-based model, where the costs are based on information about the instances of concepts and roles that are extracted from a model abstraction built by an OWL reasoner. We present two ordering strategies: a static and a dynamic one. For the dynamic case, we improve the performance by exploiting an individual clustering approach that allows for computing the cost functions based on one individual sample from a cluster. We provide a prototypical implementation and evaluate the efficiency of the proposed optimizations. Our experimental study shows that the static ordering usually outperforms the dynamic one when accurate statistics are available. This changes, however, when the statistics are less accurate, e.g., due to nondeterministic reasoning decisions. For queries that go beyond conjunctive instance queries we observe an improvement of up to three orders of magnitude due to the proposed optimizations.
💡 Research Summary
The paper addresses the challenge of answering SPARQL queries under the OWL Direct Semantics (DS) entailment regime, which goes far beyond the simple sub‑graph matching of standard SPARQL. In DS, query variables may be bound to class or property names, and complex class expressions can appear inside the query, making the evaluation problem substantially harder. To tackle this, the authors first present a sound and complete algorithm that leverages a model abstraction produced by an OWL reasoner. This abstraction supplies essential statistics such as the number of instances of each class, the subclass hierarchy, role (property) hierarchies, and role chain inferences.
The central contribution is a cost‑based framework for determining the order in which query atoms are evaluated. The cost model incorporates three main factors: (1) selectivity – the estimated size of the candidate set for a given atom, (2) connectivity – how many shared variables the atom has with the rest of the query, and (3) hierarchical depth – the position of the involved class or property in the ontology’s taxonomy. By ordering atoms from lowest to highest estimated cost, the engine can prune intermediate results early and dramatically shrink the search space.
Two ordering strategies are explored. The static strategy computes costs once before execution, using the statistics directly obtained from the reasoner. When these statistics are accurate (e.g., when the reasoner provides exact instance counts), the static plan consistently yields the best performance. However, OWL reasoning can be nondeterministic or only provide approximate counts, especially on very large or evolving ontologies, which can render static estimates misleading.
To mitigate this, the authors propose a dynamic strategy that re‑evaluates costs during query execution. The dynamic approach is enhanced by an individual clustering technique: individuals are grouped according to semantic similarity derived from the class and role hierarchies, and a single representative from each cluster is used to estimate costs for the whole cluster. This sampling drastically reduces the overhead of recomputing statistics while still adapting to the actual data observed at runtime. The dynamic planner can thus react to inaccurate or changing statistics, re‑ordering the remaining atoms on the fly.
Beyond ordering, the paper shows how specialized OWL reasoning tasks can be performed ahead of time. Pre‑computing subclass relationships, role chain inferences, and equivalence classes allows the query engine to replace complex class expressions with simpler, already‑materialized atoms, further shrinking the candidate space.
The authors implemented a prototype and evaluated it on several benchmark ontologies, including LUBM, DBpedia, and a custom ontology containing deep class expressions. Queries ranged from simple instance retrieval to highly expressive patterns involving nested class constructors and role chains. Results indicate that the static ordering outperforms the dynamic one when high‑quality statistics are available, achieving average speed‑ups of 2–5× and up to an order of magnitude in the best cases. Conversely, when statistics are noisy or reasoning decisions are nondeterministic, the dynamic planner with clustering recovers performance, often surpassing the static plan by a factor of 10 or more. For the most complex queries, the combined optimizations yield improvements of up to three orders of magnitude (≈1000×) compared with a naïve DS evaluation.
In summary, the paper delivers a comprehensive optimization suite for SPARQL under OWL Direct Semantics: a sound evaluation algorithm, a cost‑driven execution ordering, static and dynamic planning variants, a novel clustering‑based cost estimation, and pre‑materialization of ontology‑specific reasoning results. The experimental evidence demonstrates that these techniques make DS‑based query answering practical for large, expressive ontologies, and they provide a solid foundation for future SPARQL engines that aim to integrate tightly with OWL reasoning.