The Web has evolved to a large variety of data usually published in RDF from multiple domains. A recurrent problem in recent literature concerns to perform a search over RDF instead of using structured queries in triple-pattern-based languages like SPARQL, which only expert programmers can precisely specify their information needs. In this paper, we propose Von-QBE, an open source tool to query over RDF databases without any technical knowledge about RDF or the queried ontology structure. This differs from the-state-of-art tools by being schema-based instead of instance-based. It can be impracticable to use instance-based approaches in big data scenarios where the RDF data is huge and demands lots of computational resources to keep the knowledge base in memory. Moreover, most of these solutions need the knowledge base materialized into RDF(or triplified ), which can be costly for legacy bases. We present various demonstration scenarios using the IMDB movie ontology.
The Web has evolved from a network of linked documents to one where both
documents and data are linked, resulting in what is commonly known as the
Web of Linked Data, that includes a large variety of data usually published in
RDF from multiple domains. As any database model, RDF requires formal query
languages to retrieve information. Tools that perform a search over RDF data
become increasingly important since writing structured queries in
triple-patternbased languages like SPARQL [
Consider the example question, such as "Find the title of action movies produced in Northern America and the name of their company". A possible SPARQL query formulation, assuming a user familiar with the schema of the underlying knowledge base and knows which entities are present at the data instances, could consist of the following:
SELECT DISTINCT ?x ?title ?company_name
WHERE { ?x a mo:Movie; mo:title ?title;
mo:isProducedBy ?y; mo:belongsToGenre [ a mo:Brute_Action ] .
?y :companyName ?company_name; :hasCompanyLocation [ a mo:Northern_America ] . }
This complex query requires a user’s familiarity with the knowledge base, which in general, no user (technical or not) should be expected to have. Basically, Von-QBE (stands for Virtualized Ontology Query By Example) addresses the problem: Given a natural language question QN and an underlying ontology O, its goal is to translate QN into a formal query QS as SPARQL that captures the information need to be expressed by QN . Von-QBE focuses on queries that emphasize classes and relations between them, not considering aggregation, disjunctive and negation queries.
A considerable number of question answering approaches for RDF data has
been proposed, to name a few [
[
A screencast of Von-QBE is available at YouTube 3. To the best of the authors’ knowledge, this work is the first that addresses the problem of question answering over RDF using only the schema. In the next section, we present the main components of Von-QBE. In Section 3, we present the demonstration scenarios. Section 4 draws the final conclusions. 2
Von-QBE
Von-QBE addresses the problem of question answering over RDF. Beyond that,
it also helps the user to construct its search interactively, providing examples.
Figure 1 shows Von-QBE architecture which comprises three main components:
Fragment Extractor, Fragment Expansor and Query Builder. All these
components handle the ontology schema as an RDF graph[
2 http://github.com/insightlab/von-qbe 3 https://youtu.be/ScXgGzhbx50 Keyword Matcher
Fragment
Constructor Fragment Extractor
Users Web Interface
3 - Suggestions Fragment Expansor
7 - Data 4 - SPARQL 2 - Fragment
Query Builder Ontology Schema
Von-QBE
Query Executor
L Q R A P 5S a t a D 6
RDF Data
Fragment Extraction is responsible for identifying, from a natural
language question QN , the ontology subset (here we call as a fragment ) that
corresponds to the classes and properties mentioned on QN . The Fragment Extraction
comprises two sub-components: 1) Keyword Matcher that identifies the ontology
concepts mentioned on QN by using similarity metrics[
Fragment Expansor. Von-QBE provides examples to the user by expands QN using the ontology classes and properties that are directly connected to the fragment retrieved from the previous module. Considering our ontology O represented as an RDF graph, and the fragment nodes are ontology concepts, the Fragment Expansor expands the fragment with all edges (of course, the ones that are not already in the fragment) that come in (or out) from the fragment nodes.
Query Builder works as follows: each edge in the fragment (outputted by Fragment Constructor or expanded with the suggestions outputted by Fragment Expansor and accepted by the user) is added as a triple pattern in the query, and the source and the target nodes are named as variables. Since the schema might have properties with multiple domains and ranges, Query Builder also adds a clause to inform the instance type (class) for each variable. All the triple patterns are given as input to Apache Jena library4 which generates QS according to the SPARQL syntax.
3
Von-QBE works with any RDF ontology that presents a schema and a SPARQL
endpoint. The current version of Von-QBE supports Virtuoso SPARQL endpoint
and Ontop[
Figure 2 shows Von-QBE’s interface. First, the user should write the keyword search or the query at the text field. Once the user has written a term, Von-QBE suggests other concepts or relations from the ontology schema based on the userwritten term(s). Figure 2 shows the suggestions given by Von-QBE to the query: movie title and actors. The property birth name (an attribute from the Actor class) appears as a suggestion. The user can choose it and keep constructing the search query.
Once the user finishes writing the search query, he/she can limit the number of triples returned based on a limit value and run the query over the database. Von-QBE will then retrieve the results and return them to the user, as in Figure 3. Von-QBE also provides the generated SPARQL from the user query search, 5 https://sites.google.com/site/ontopiswc13/home/imdb-mo In this paper, we present Von-QBE to address the problem of querying over RDF databases using natural language question or a keyword search. Moreover, VonQBE also helps the user to construct his/her query and translates the user-query search into SPARQL query. From the authors’ knowledge, Von-QBE is the first tool to address such a problem using only the ontology schema. As future work, we aim at using natural language processing tools to detect entities described in the query and find its corresponding concept over the ontology schema.