As the real world evolves, the information contained in the knowledge bases is updated accordingly and the evolution history of entities and their properties becomes of great interest to users, who thus need effective query tools to explore it. In this paper, we (i) introduce SPARQLT and its user-friendly interface for expressing powerful structured queries on the history of RDF knowledge bases, and (ii) overview its underlying query engine that supports efficient evaluation of such queries and the management of historical information. To ensure ease of use, we take a by-example structured query approach that allows users to specify queries by entering simple conditions into the Infoboxes of Wikipedia pages extended with temporal fields. From this wysiwyg interface, the system derives and executes equivalent SPARQLT queries, sparing users from having to learn the query language and the underlying knowledge base schema. Our demo will introduce SPARQLT, its system and user-friendly interface, with the help of simple and intuitive examples.
There is a growing interest in large scale knowledge bases such as DBpedia and Yago,
which play a key role in semantic applications. In reality, large knowledge bases
undergo frequent changes. When the information in the real world evolves, the RDF triples
stored in the knowledge bases are updated to reflect those changes. The evolution
history of knowledge bases captures and describes the changes experienced by real world
entities and properties, which is of great interest to users. As a result, the management
of historical information has emerged as a critical problem for RDF knowledge bases,
motivating the launching of projects such as DBpedia Live [
In the project described in this paper, we collect the evolution history of knowledge
bases and store it in the temporal RDF model [
Mayor Population
Object Bob Filner
Todd Gloria Kevin Faulconer 1322553 1307402 1345895 1381069
Timestamp 12/04/2012 . . . 08/30/2013 08/31/2013 . . . 03/02/2014
03/03/2014 . . . now 12/19/2012 . . . 10/01/2013 10/02/2013 . . . 04/29/2014 04/30/2014 . . . 05/21/2015 05/22/2015 . . . now
Q1: SELECT ?t fSan Diego Mayor Todd Gloria ?tg Q2: SELECT ?person fSan Diego Mayor ?person ?t FILTER(YEAR(?t) = 2013)g Q3: SELECT ?pop ?t fSan Diego Mayor Bob Filner ?t .
San Diego Population ?pop ?tg
our system derives equivalent queries that are optimized and executed in our query
engine. To achieve fast query evaluation, we used efficient storage and index schemes for
temporal RDF triples based on Multi-Version B+ Tree (MVBT) [
Knowledge bases can be represented as RDF graphs which consist of a set of RDF
triples in the format of (subject, predicate, object), where subject and predicate are
Uniform Resource Identifiers (URI), and object can be a URI or a literal value. For
example, the statement “The mayor of San Diego is Kevin Faulconer” is represented by:
(San Diego Mayor Kevin Faulconer).1 Since the basic RDF graphs are designed for
static information, we represent the evolution history of RDF knowledge bases using the
temporal RDF graphs proposed in [
To query such temporal RDF graphs, we propose SPARQLT that extends SPARQL query pattern with a temporal element to match the temporal RDF triples. The SPARQLT query patterns are quadruplets fs p o tg, where each element is either a literal or a variable. Thus, a SPARQLT query is a set of SPARQLT query patterns annotated with temporal conditions, such as those for the basic operators discussed next.
Temporal Selection. We start from temporal selection queries with one SPARQLT query pattern. A typical example is the “when” query. By specifying s, p, o as literals and leaving t as a variable, users can retrieve the valid timestamps of given facts. This is the case of Q1 in Figure 1 that finds when Todd Gloria served as the mayor of San Diego. The SPARQLT query pattern also allows users to perform RDF triple matching with temporal constraints (e.g., at a previous version or within a certain period), such as Q2 in Figure 1 which returns the mayor of San Diego in 2013.
Temporal Join. Another important query class is temporal join query. In SPARQLT, a temporal join is expressed by multiple query patterns sharing temporal elements, i.e. days in our examples since this is the granularity of our point-based representation. An example of temporal join query is Q3 in Figure 1 that returns the population of San Diego when Bob Filner served as the mayor. 1 For the sake of simplicity, we omit the prefix parts of URIs (e.g. http://dbpedia.org/resource/).
(a) (b)
Fig. 2. (a) Query Interface (b) Navigation Window for Property Mayor
The temporal constraints are expressed in the FILTER clause. We support a set
of built-in functions including TSTART/TEND, YEAR/MONTH/DAY and PERIOD.
With these functions, SPARQLT readily expresses complex temporal conditions and
Allen’s operations [
These examples illustrate that the point-based temporal model leads to queries that
are simple to express using SPARQLT . This property is not shared by other approaches [
Our system consists of two main components: (i) a user interface that enables users to browse and search the knowledge and its history, and (ii) the SPARQLT query engine that manages the temporal data and evaluates SPARQLT queries.
User Interface. Our system provides a user-friendly interface that addresses the
problem of usability by extending the By-Example Structured Query (BEStQ) [
Our system also provides navigation toolbars so that users can browse the history of entities and properties. For example, if the user clicks on a property, the interface will show a navigation window where the user can see the property type and its history and specify temporal conditions, as shown in Figure 2(b). The interface is implemented as middleware systems on Wikipedia.
Query Engine. In our system, the temporal RDF triples are stored using in-memory MVBT indices that support fast range query processing. Taking a SPARQLT query, we first parse the query and generate an execution plan in which every SPARQLT query pattern is converted into a query pattern (k, i) on MVBT to retrieve all the temporal RDF triples with keys in range k and intervals overlapping interval i. A hybrid method combining dictionary based compression and prefix encoding is adopted to reduce the storage overhead of indices. The algorithms on MVBT are extended and optimized to exploit the characteristics of the compression scheme and query patterns.
Our query engine is implemented in Java and evaluated on the Wikipedia Infobox
History (38.5 million triples). We compare the query performance of our
implementation with (i) the reification approach using Jena and (ii) the SQL-based approach using
MySQL memory engine. The test query set contains 20 temporal selection and temporal
join queries, as those in Figure 1. In our implementation, the average execution times
for temporal selection and temporal join queries are 5 and 41 milliseconds respectively.
On average, our approach is 1 order of magnitude faster than the SQL-based approach
and 2 orders of magnitude faster than the reification approach. Interested readers are
referred to [
Demonstrating SPARQLT
The conference participants attending our demo will be able to explore structured
knowledge bases and their history in a simple and intuitive way. The demonstration starts with
a brief introduction of our system, followed by a hands-on phase in which the
participants can ask interesting queries on the history of people and places they are familiar
with, and test the performance of our query engine. We prepare two real world datasets:
Wikipeda Infobox History and GovTrack, with 38.5 million and 22 million temporal
RDF triples respectively. A tutorial video is available in [