We present SQuaRE, the SPARQL Queries and R2RML mappings Environment which provides a visual approach for creating R2RML mappings which can be immediately tested by executing SPARQL queries. SQuaRE is a web-based tool with easy to use visual interface that can be applied in the ontology-based data access applications. We describe SQuaRE's main features, its architecture as well as implementation details. We present an example use case to indicate how SQuaRE can be useful in an OBDA-based scenario.
Ontologies, as a way of expressing knowledge, are becoming more and more
popular in various research and practical fields. They allow definition of a knowledge
base using abstract concepts, properties and relations between them. A properly
created ontology can be then automatically processed to obtain new inferences
and, as a result, a newer version of the knowledge base. Ontologies can be
expressed in the Web Ontology Language 2 (OWL 2) [
Nevertheless, ontologies and data need to follow the RDF-based representation. Since most of data are stored in different formats, any application of an OWL/OWL2 ontology rises the integration problem between an ontology and stored data. In this case we can transfer our current data format into RDF-based representation and change our software and architecture environment or we can create mappings between the ontology and our data and use an appropriate tool that handles such a solution. The first option is very cost-expensive and needs a lot of changes in the current software architecture. The second approach is easier and cheaper since minor changes in the software architecture are required. We need to create mappings and then query non-RDF data with SPARQL using ontology, mappings and a tool that enables on-the-fly transfer from non-RDF into RDF data. In this method the most important part is to create appropriate mappings. Currently, a very popular standard for expressing mappings from relational databases to RDF data is W3C’s R2RML3. The standard allows to use existing relational data in the RDF data model, and then use SPARQL to query such data.
In this paper we provide a detailed description of SQuaRE, the SPARQL Queries and R2RML mappings Environment, which provides a visual editor for creating and managing R2RML mappings as well as for creating and executing SPARQL queries. SQuaRE is a web-based application that simplifies the creation of mappings between a relational database and an ontology. It also enables to test created mappings by defining and executing SPARQL queries in a textual manner.
The remainder of this paper is organized as follows. Firstly, we provide preliminary information, then we describe main features of SQuaRE. Next, we present its architecture as well as implementation details. Then, we provide a simple instruction on how to use SQuaRE by presenting an example use case. Finally, we provide conclusions along with future development plans. 2
SQuaRE is an OBDA-oriented tool which helps an inexperienced user to create mappings between a relational database and an ontology, and then to test those mappings by creating SPARQL queries. Moreover, the tool can be used to write and execute SPARQL queries in a text-based form whereas results are presented in a graphical way. In this section we present the main overview of OBDA and R2RML.
Ontology-based Data Access (OBDA) is an approach [
The R2RML recommendation provides a language for expressing mappings from a relational database to RDF datasets. Those mappings allow to view the relational database as a virtual RDF graph. Then, the relational database can be queried using the SPARQL language. Each R2RML mapping is a triples map (an RDF graph) that contains: a logic table (which can be a base table, a view or a valid SQL query); a subject map which defines the subject of all RDF triples that will be generated for a particular logical table row; and a set
of predicate-object maps that define the predicates and objects of the generated RDF triples. In order to create R2RML mappings manually, one needs to know about ontologies (OWL/OWL2), RDF, R2RML and SQL at the same time.
SQuaRE overcomes the aforementioned issues. The main goal of the tool is to support creation of R2RML mappings and SPARQL queries in a graphical manner. However, at the current state of development SQuaRE supports a graphical editor for R2RML mappings and a text-based interface for creating and executing SPARQL queries. Nevertheless, results returned by a SPARQL query may be presented as a graph to a user. 3
3.1
The SQuaRE environment is aimed at providing easy-to-use functions that will support creation and execution of SPARQL queries as well as creation of R2RML mappings. Moreover, SQuaRE allows for management of queries and mappings. A user can save both: mappings and queries for future reference, execution and management. Currently, the tool supports a graphical interface for the creation of mappings and the text-based creation of SPARQL queries. Moreover, results returned by a SPARQL query can be presented in a graphical way (according to the query type). Currently, SPARQL results of queries DESCRIBE and CONSTRUCT are presented on a graph, ASK queries return ‘yes’ or ‘no’ while results of SELECT queries are presented in a table.
Nevertheless, SQuaRE provides the following useful features (appropriate figures are shown in Section 4): 1. Browsing a relational database – a user can choose a data source and browse its schema. In this view the user sees table names, column names as well as data types stored in each column. An example view of a relational database is shown in Figure 2. The figure contains two tables named emp and dept with four and three columns, respectively. 2. Browsing an OWL ontology – a user sees hierarchies of classes, object properties and datatype properties. The user can browse an ontology (Figure 3) and search for its elements. 3. Browsing mappings – a list of all created mappings is shown to a user. The user can choose a mapping and then edit it in the mapping creation view (shown in Figure 5). 4. Graphical creation of R2RML mappings – in a mapping creation view a user can create R2RML mappings. The user needs to choose tables that are going to be mapped. Then, she/he needs to search for an appropriate classes and properties to create mappings using a graphical interface. An example mapping is shown in Figure 5. Classes are represented with an orange background, datatype properties with a green background and object properties with a blue background. 5. Management of R2RML mappings – each created mapping can be saved for future reference. A user can delete mappings, correct them or generate an R2RML file that contains all or selected mappings. 6. Textual creation of SPARQL queries – current version of SQuaRE provides an option to create SPARQL queries using a text-based interface. A user can write and execute a query. The view of a user interface for creating queries is shown in Figures 6, 7, 8, 9 and 10. Graphical editor for creating queries is one of our future development plans. 7. Management of SPARQL queries – each constructed SPARQL query can be saved and used in future. A user can execute, delete or export a SPARQL query. Moreover, the user can select few queries (or all of them) and generate a separate .txt file that contains their definitions. 8. Execution of SPARQL queries – created SPARQL queries can be executed and results are shown in a form of a table, an RDF graph or answer ‘yes’ or ‘no’.
The aforementioned main list of features provides an intuitive ontology-based access to relational data. Moreover, by exporting functionality (importing features are still in development) a user can use SQuaRE to create mappings and test them by creating SPARQL queries, and then save everything into external files. This allows to import queries and mappings into another tool that supports both SPARQL and R2RML. 3.2
SQuaRE is developed in Java as a web application. The architecture of SQuaRE is presented in Figure 1. The tool consists of modules that provide different functionality.
The SQuaRE architecture is divided into two separate sides – client and server. The client side consists of modules working on a client’s machine in a user’s web browser and provides a presentation layer.
The main module, from the user’s point of view, is Visual R2RML Mapper which provides tools for visual (graph based) mappings of relational database metadata, such as table columns, and user provided ontology entities.
Moreover, there are modules responsible for data source configuration and ontology management. The former allows the user to configure a data source by providing DBMS, host location and port, username and password. The latter provides an interface to import an ontology and browse hierarchies of classes and properties.
The server-side modules consist of Data Source and DBMS Manager which manages the user defined data sources and provides JDBC-based access, Ontology Handler for OWL ontology processing, and SPARQL Query Executor which utilizes already defined mappings and allows to execute SPARQL queries in the context of a relational database.
SQuaRE applies well-known tools to handle OWL ontologies, relational data
and SPARQL queries. The main tools that SQuaRE uses are the following:
vrSe deSi
tDa eSourc dna SMDB
yrQue orutcxeE
tDa eSourc
lsuaVi LM2R rpeMa
yrQue ortdiE
tneilC edSi
– OWL-API [
– Javascript libraries – we use a set of popular Javascript tools such as:
AngularJS8, jQuery9, Cytoscape.js10 with CoSE Bilkent layout [
In order to present the usability of SQuaRE we provide an example use case
and a simple instruction how to use the tool. We used the W3C’s R2RML [
After creating a new project (here named “W3C (1) Project”) user needs
to configure a data source providing DBMS, a database location and name,
username and password. When all settings are correct the data source view
may look like in Figure 2. It consists of two tables named emp and dept with
information about employees and departments. Each table contains one row
which content may be seen in Section 2.1 of [
After connecting to a database, the second task is to import OWL domain ontology which then is processed and presented to the user in a form of hierarchies of classes, object type properties and datatype properties (Figure 3).
When data source and ontology are selected the user is able to start creating new mappings. The mapping process is preceded by choosing tables (Figure 4) which will be used during the creation of a particular mapping.
If the user selects more than one table she/he should define join predicates (Figure 4) which will be used for proper joining records from the selected tables.
The main mapping part consists of selecting classes, object type properties and/or datatype properties from the right-hand side ontology view shown in Figure 5). The user may drag and drop them into the center located canvas. Then she/he may link selected ontology entities with each other as well as with the left-hand side located columns descriptions of particular data source tables.
A complete mapping of W3C’s R2RML example (sections 2.1 to 2.5
inclusive of [
Based on the aforementioned data source, ontology and mapping the user may begin executing SPARQL queries. SQuaRE is capable of executing all four SPARQL query forms. The SELECT form returns variables and their bindings which are presented in a form of a table (shown in Figure 6).
The SPARQL DESCRIBE and CONSTRUCT forms return RDF graphs which are presented in a form of graphs where orange color indicates objects, grey color indicates literals, blue and green colors indicates object type properties and datatype properties, respectively (shown in Figures 7 and 8).
The SPARQL ASK query form returns boolean answer indicating whether a query pattern matches or not. Boolean query results are presented in Figure 9 (positive) and in Figure 10 (negative).
The W3C R2RML Recommendation’s section 2.6 example [
As a result we obtained an environment that is ready to be used by an inexperienced user.
Fig. 8: The SPARQL CONSTRUCT query result.
Several tools have been implemented to support a user in defining mappings
between data sources and ontologies. We provide the list of the most similar
tools to SQuaRE:
– OntopPro [
Nevertheless, the tool is very handy and easy to use.
– ODEMapster [
The aforementioned tools provide different features that overlap in some
cases. However, none of them provide the comprehensive functionality for
OBDAbased scenario. SQuaRE provides features for creating and managing of both:
R2RML mappings and SPARQL queries. Moreover, it supports users in the
execution of queries and presents results in a graphical way. Moreover, we are going
to implement support for a graphical creation of SWRL rules [
SQuaRE is aimed at providing a simple user interface and easy to use methodology. Nevertheless, it should be perceived as a tool that tries to acquire the best features of other applications and provide them in a graphical way with an easyto-use interface. The most similar tool at this stage of development is Karma, but without handling SPARQL queries and results in a graphical manner (but Karma provides more mapping methods than SQuaRE and more features regarding data integration). It is worth to notice that SQuaRE is still at the early stage of development whereas most of the tools from the list are being developed in the last few years. Some of them are even discontinued, like ODEMapster or RBA. 6
In this paper we presented the SQuaRE tool which is a web-based environment that provides: (i) creation of R2RML mappings between relational databases and OWL ontologies, and (ii) creation and execution of SPARQL queries. The tool provides a lot of useful features that can be applied in an OBDA-based scenario.
Currently, we are developing a graph-based method for creating SPARQL
queries. In this case we will fully support a graphical environment for handling
R2RML and SPARQL. We also plan to include RuQAR [
Acknowledgments. The work presented in this paper was supported by 04/45/ DSMK/0158 project. 13 http://d2rq.org/