Using SPARQL for writing queries on OWL-DL ontologies can be complicated due to its RDF triple semantics. Translating OWL expressions to this semantics is a non-trivial problem. We present SPARQLDL Abstract Syntax (SPARQLAS), a proper subset of SPARQL, to solve this issue by employing the OWL Functional-Style Syntax to compose queries. We illustrate how the translation is made possible by a modelto-model transformation and how a query can be connected to an UML model. Finally, we evaluate SPARQLAS against SPARQL and show the e orts of SPARQLAS for queries on OWL-DL ontologies.
With the W3C recommendation for SPARQL [
Existing approaches, which do not rely on RDF triples to speci cally query
OWL-DL ontologies, are lacking in di erent aspects. Terp [
Therefore, we introduce SPARQL-DL Abstract Syntax (SPARQLAS) that combines employing SPARQL to query OWL-DL ontologies and using OWL Functional-Style Syntax to compose queries. With SPARQLAS, the user does not have to translate between two languages, but is still able to utilize any SPARQL processing engine that supports the OWL-DL entailment regime. The optional application of a shortened version of the OWL Functional-Style Syntax simpli es queries even more.
These advantages of SPARQLAS are accomplished by creating a new and more readable syntax out of SPARQL and the OWL Functional-Style Syntax and by transforming SPARQLAS to SPARQL. The transformation itself makes a special SPARQLAS processing engine needless and assures an easy embedding of SPARQLAS into running IDEs.
In the following, we rst present in Section 2 the implementation of SPARQLAS at the TwoUse Toolkit. There we elaborate the conceptual approach of how a SPARQLAS query is parsed, transformed and printed to a SPARQL query before discussing the realization of the textual syntax and the core transformation. In Section 3 we show a concrete application example and in Section 4 we evaluate the e orts of SPARQLAS against SPARQL. Finally in Section 5, we conclude and discuss some future work.
The example throughout this paper deals with the commonly known wine
ontology [
To get a SPARQLAS query translated to a SPARQL query, we rst need to de ne a meta model for each language so that a model transformation can be performed upon. For writing a SPARQLAS query and a subsequent use of a SPARQL query, those meta models have to be linked to a textual syntax. Fig. 1 illustrates the conceptual approach and shows what steps need to be realized for the complete translation.
Both textual syntaxes to SPARQLAS and SPARQL are created by using
the Eclipse plug-in EMFText1. EMFText is able to generate a textual syntax
derived from a meta model in Ecore [
query and the printer to compose a SPARQL query out of an EMF Resource. The actual translation between both EMF Resources is performed by an ATL2 model-to-model transformation.
The rst action for implementing SPARQLAS is developing its textual syntax
with EMFText, since a textual syntax for SPARQL is already available at the
EMFText Concrete Syntax Zoo [
(=<http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine#>) Select Where(EquivalentClasses(GermanWine And(Wine Has(locatedIn ?x))))
Prologue From (Named) SPARQL Pre x, Base yes SPARQLAS Namespace no Query Syntax
RDF Triple OWL-DL Expression SPARQL SPARQLAS
Optional yes no
Graph yes no
Union yes no
Filter Order Limit SPARQL yes yes yes SPARQLAS no no no Table 1. Di erences between SPARQL and SPARQLAS constructs 2.3
The ATL model-to-model transformation can be divided into two parts, the
prologue and the query itself. The prologue consists of the Namespace declaration
and will be transformed to the equivalent PREFIX notation. During the query
part, the query form will be identi ed rst and transformed to accordingly. If it
is a Select query, the option DISTINCT will be set additionally. Then the main
contribution of each transformation starts, translating an OWL expression to its
equivalent RDF triple(s). These translations are based on speci c OWL to RDF
mapping rules [
This way the expressiveness of SPARQLAS queries is equivalent to SPARQL queries using only RDF triples of the aforementioned mapping rules, which makes SPARQLAS a subset of SPARQL. Further, SPARQLAS is even a proper subset of SPARQL since not every SPARQL construct can be expressed by SPARQLAS, e.g. FILTER or OPTIONAL conditions. These constructs are omitted with regard to simplicity and readability. The complete list of di erences between SPARQLAS and SPARQL can be found in Table 1.
This speci c SPARQLAS to SPARQL transformation is implemented at the TwoUse Toolkit3 and can be executed by opening the context menu on a SPARQLAS le under the entry TwoUse ! Transform to SPARQL. 3
!
As a running application example, we present SPARQLAS for UML. Fig. 2
depicts a sample UML diagram according to the example query annotated with
stereotypes from the UML Pro le for RDF and UML Pro le for OWL [
We developed a context menu function on UML Operations via SPARQLAS for UML Add SPARQLAS Query, which creates an
empty SPARQLAS Select query with the given Namespace from the UML pro le. This query le will be named after the convention leName.className.operationName.sparqlas4uml, e.g. according to Fig. 2 it will be named Wine.uml.GermanWine.getRegion.sparqlas4uml. Strictly speaking this is a SPARQLAS4UML query, but it imports the whole SPARQLAS language and so shall indicate that a SPARQLAS query is linked to an actual UML le. Furthermore, this link between UML le and query will also be expressed at the UML le itself as the EMF Resource will be added to the model and so the query can be directly accessed through the UML model. This way it is possible to automatically generate SPARQLAS queries from UML diagrams. For this example the following empty Select query will be constructed: Namespace
( = <http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine#> ) Select Where ( ) 4
At this point we would like to evaluate SPARQLAS against SPARQL. For this purpose we examine 60 di erent test queries in two di erent ways with regard to complexity. First, we compare the underlying meta model of SPARQLAS and SPARQL. Due to EMFText every test query in textual syntax has an EMF Resource representation, therefore we can count each instantiation of a meta model class in these EMF Resources. To accelerate this counting process for a total of 120 queries, we make use of another plug-in of the TwoUse Toolkit called OWLizer, which can create ontologies out of Ecore based languages, e.g. EMF Resources. These ontologies consist of the desired individuals that we need to count and compare to achieve one indicator of complexity. After this procedure, we obtain a result that implies a substantial reduction in complexity of SPARQLAS queries against SPARQL queries. SPARQLAS queries reduce the count of individuals in average by 82% with a minimum of 71% and a maximum of 88% reduction with a standard deviation of 4%. The absolute numbers of individuals range from 5-32 for SPARQLAS queries and 31-178 for SPARQL queries.
The second evaluation kind deals with the length of each query, but instead of counting every single character, we compare the count of OWL expressions in each SPARQLAS query to the count of RDF triples an equivalent SPARQL query needs. This method ensures that the e ort of using OWL expressions rather than RDF triples can be evaluated. The results of this procedure suggest that the e orts may not be as predominant as with the other evaluation scenario, yet the average reduction is by 50% with a maximum of 82% but having a standard deviation of 31%. This high standard deviation is explained by the fact that there are actual queries with no e ort, i.e. one OWL expression is equivalent to one RDF triple, e.g. in case of ClassAssertion. However, there is only no e ort in simple cases, more complex queries, especially nested queries, are showing more and more reduction. The absolute numbers of OWL expressions resp. RDF triples of our test queries range from 1-5 resp. from 1-23. 5
In this paper we have presented the implementation of a novel query language for OWL-DL ontologies, called SPARQL-DL Abstract Syntax (SPARQLAS), that combines SPARQL and the OWL Functional-Style Syntax or a shortened version of it. The possible application of two di erent syntaxes with the same underlying meta model indicates that the speci c querying syntax is easily changeable. This language can be employed just like a SPARQL query after the execution of a model-to-model transformation from SPARQLAS to SPARQL. We have demonstrated in a running application example, SPARQLAS for UML, how SPARQLAS queries can be connected to UML models and performed on ontologies created from these models by applying the UML Pro le for RDF and UML Pro le for OWL. Further, we have shown by means of an evaluation that SPARQLAS is e ectively reducing the complexity of a query on an OWL-DL ontology, especially for nested queries.
In our future work, we will enhance SPARQLAS to support the Manchester Syntax and discuss the usage of other syntaxes as well. This way the user will be able to choose his preference among these syntaxes. Additionally, we will create a new application example to connect queries with Ecore models, SPARQLAS for Ecore, since the OWLizer plug-in is capable of generating ontologies from such Ecore models.
The work presented in this paper is supported by EU STReP-216691 MOST.