In this paper, we present a multi-temporal RDF database model employing triple timestamping with temporal elements, which best preserves in the multi-temporal setting the scalability property enjoyed by triple storage technologies. The data model is equipped with manipulation operations which allow knowledge engineers to maintain a multi-temporal RDF database in order to manage temporal versions of an ontology.
When an ontology is changed, some applications require the past version to be
kept in addition to the new one, giving rise to multi-version ontologies. This is the
case of the legal domain where ontologies must evolve as a natural consequence
of the dynamics involved in normative systems [
In the design of semantics based information systems, triple store
technology [
In order to preserve the scalability property of the triple storage approach
as much as possible also in the presence of temporal semantics, one has to limit
the proliferation of value-equivalent triples which could be generated by a non
very careful definition of the operational semantics of modification statements.
Actually, in the previous sentence we have extended to RDF triples the notion of
value-equivalent tuples defined in temporal database theory [
The issue has in part been acknowledged also in [
In this work, we propose to move another step forward and improve the
notion of normalized temporal RDF database by employing the whole
state-ofthe-art temporal database techniques to avoid data redundancy. Therefore, we
propose to introduce temporal elements [
The paper is organized as follows. In Section 2, we provide some background information on application requirements which lead our design choices. Hence, a multi-temporal RDF database model employing temporal element timestamping will be introduced in Section 3. In Section 4, the operational semantics of modification operations for the maintenance of a multi-temporal RDF database is presented. Conclusions will be finally found in Section 5. 2
In this section, we sketch some features of the reference application scenario we consider in the background, which is important for the design choices we have taken.
In particular, we focus on (multi-version) ontologies which are used to support
a semantically indexed access to a usually very large repository of (multi-version)
data resources. Snapshot queries, that is queries which reconstruct a single
ontology version valid a given point in the multidimensional time domain, are of
vital importance in this framework [
For the sake of consistency, the same temporal perspective must be used
when accessing both the ontology to select a class of interest and then the data
resources linked to such a class. In other words, the temporal selection involves
the extraction from the multi-version repository of the ontology version and of
the linked data resource versions which are valid at the same (multidimensional)
time point. Full details on the application scenario can be found in [
For instance, in [
In such an application context, at least three temporal dimensions are needed
for a correct modelling of the evolution of data resources and of the related
ontology:
– validity time is the time a norm is in force in the real world
– efficacy time is the time a norm can be applied to concrete cases; while
such cases exist, the norm continues its efficacy even if no longer in force
– transaction time is the time a norm is stored in the information system
Notice that both validity and efficacy time dimensions have the semantics of
valid time in temporal database terminology [
In this vein, we previously considered in [
Another application domain we could consider is the medical one: for
example, clinical guidelines can play the role of data resources and ontologies can be
used to formalize diseases to which guideline prescriptions can be applied to. At
least three independent temporal dimensions (including transaction time) are of
interest also in such a framework [
Let us start from the defintion of an N -dimensional time domain
T = T1 × T2 × · · · × TN
where Ti = [0, uc)i is the i-th time domain. Right-unlimited time intervals are
expressed as [t, uc), where uc means “Until Changed”, though such a symbol is
often used in temporal database literature [
Hence, we can define a multi-temporal RDF triple as:
(s, p, o | T )
where s is a subject, p is a property, o is an object and T ⊆ T is a timestamp
assigning a temporal pertinence to the RDF triple (s, p, o). We will also call the
(non-temporal) triple (s, p, o) the value or the contents of the temporal triple
(s, p, o | T ). The temporal pertinence of a triple is a subset of the
multidimensional time domain which is represented by a temporal element [
T =
! 1≤j≤m
1≤j≤m Ij =
! [tjs, tje)1 × [tjs, tje)2 × · · · × [tjs, tje)N where the unioned N -dimensional intervals are all disjoint (i.e. Ij ∩ Ik = ∅ for all 1 ≤ j < k ≤ m).
This definition of temporal triple is similar to the ones in [
A multi-temporal RDF database can then be defined as a set of timestamped RDF triples:
RDF-TDB = { (s, p, o | T ) | T ⊆ T } with the integrity constraint:
∀(s, p, o | T ), (s", p", o" | T ") ∈ RDF-TDB: s = s" ∧ p = p" ∧ o = o" =⇒ T = T " which requires that no value-equivalent distinct triples exist.
The adoption of timestamps made-up of temporal elements instead of
(multitemporal) simple intervals avoids the duplication of triples in the presence of a
temporal pertinence with a complex shape. For example, consider a
tridimensional time domain and a temporal triple X1 = (s1, p1, o1 | T1), where T1 =
[t", uc) × [t", uc) × [t", uc), which must be partially replaced by a new triple X2 =
(s2, p2, o2 | T2), where T2 = [t"", uc) × [t"", uc) × [t"", uc) and t" < t"". The time
pertinence left to X1 after the modification is T1\T2, which can be decomposed
into a minimal number of three non-overlapping tridimensional intervals (e.g.
[t", uc) × [t", uc) × [t", t"") ∪ [t", uc) × [t", t"") × [t"", uc) ∪ [t", t"") × [t"", uc) × [t"", uc)).
Hence, if we used interval timestamps, at least three copies of the triple with
contents (s1, p1, o1) would be required to cover the region. With temporal elements
indeed, we make the union of such intervals and produce a single temporal
element to timestamp a single copy of X1. In other words, we store different triple
versions only once with a complex timestamp rather than storing multiple copies
of them with a simple timestamp as in [
The memory saving we obtain grows with the dimensionality of the time domain, but it can even be appreciated with a monodimensional time domain, when the temporal pertinence of a triple is not a convex interval. For example, the temporal triples: (s, p, o | [t1, t2)) (s, p, o | [t3, t4)) where t2 < t3, can be merged with temporal element timestamping into a single triple:
(s, p, o | [t1, t2) ∪ [t3, t4)) Whereas the same space is basically required for globally storing the timestamps in both cases (i.e. the space needed by four time points), the space required for storing one occurrence of the triple contents (s, p, o) is saved in the latter case. Moreover, with element timestamping, according to the integrity constraint introduced above, no two temporal triples can have the same non-temporal contents and, thus, checking of uniqueness and of functional properties constraints can be performed more easily. In particular, in Sec. 4 we will define the semantics of modification operations in such a way that the integrity constraints concerning temporal elements are automatically preserved.
The only retrieval operations we consider in this paper are snapshot queries
[
RDF-TDB(t¯) = { (s, p, o) | (s, p, o | T ) ∈ RDF-TDB ∧ t ∈ T }
¯
Using a SPARQL-like syntax [
where the URI http://myExample.org/tGraph denotes a multi-temporal RDF triple store. However, the full definition of a multi-temporal extension of SPARQL is beyond the scope of this paper. 4
In this section, we introduce modification operations for the maintenance of a
multi-temporal RDF database and formalize their operational semantics via a
sort of triple calculus analogous to the tuple calculus used for the relational
data model. Algorithms for their execution can be derived from such description
in a straightforward way, although there were room left for optimization.
However, as any modification usually impacts on a few temporal triples at a time,
optimization of their execution should not be a real issue. As far as syntax is
concerned, also for temporal modification operations we do not provide a
complete SPARQL-like syntax, although the examples we provide are inspired by
the SPARQL/Update proposal [
In an N -dimensional temporal model, users can assign a validity to the effects
of a modification by specifying a value for N −1 of the temporal dimensions. Like
in temporal query languages as TSQL2 [
Notice that the union and difference between two temporal elements involved
in timestamp update operations must be computed carefully in order to preserve
the temporal element format of the result [
Assuming tv specifies an (N −1)-dimensional temporal element (transaction time is implied), the generic statement for the insertion of a temporal triple (s, p, o) with validity tv into the temporal RDF database can be written as: INSERT DATA {s, p, o} VALID tv Semantics The effect of the insertion can be specified by the following triple calculus expression, where RDF-TDB and RDF-TDB" are the temporal RDF database state before and after the modification, respectively: ∪ #(s, p, o | tv × [now, uc)) $$ ¬∃(s, p, o | T ) ∈ RDF-TDB%
∧ T " = coalesce(T ∪ tv × [now, uc))% In particular, if a temporal triple (s, p, o | T ) with non-temporal contents (s, p, o) is already present in the database, then a new timestamp for it is computed as T " = coalesce(T ∪ tv × [now, uc)) and finally the temporal triple is replaced by (s, p, o | T ") in the database; otherwise, the triple (s, p, o | tv × [now, uc)) is simply added to the database. 4.2
Assuming tv specifies an (N − 1)-dimensional temporal element (transaction time is implied), the generic statement for the deletion with validity tv from the temporal RDF database of all the temporal triples (s, p, o) satisfying a selection predicate pred can be expressed as:
DELETE {s, p, o} VALID tv
WHERE pred(s, p, o) Semantics The effect of the deletion can be formalized in triple calculus as follows: \ #(s, p, o | T ) $$ ∃(s, p, o | T ) ∈ RDF-TDB ∧ pred(s, p, o) ∧ T ∩ tv × [now, uc) -= ∅% ∧ pred(s, p, o) ∧ T ∩ tv × [now, uc) -= ∅ ∧ T " = coalesce(T \ tv × [now, uc))% The effect is that for each temporal triple (s, p, o | T ) in the database such that the selection predicate pred(s, p, o) evaluates to true and T ∩tv ×[now, uc) -= ∅, the triple (s, p, o | T ) is replaced by the triple (s, p, o | T ") with equal contents and timestamp restricted to T " = coalesce(T \ tv × [now, uc)). 4.3
Assuming tv specifies again an (N − 1)-dimensional temporal element
(transaction time is implied), the generic statement for the substitution with validity tv
of all the temporal triples (s, p, o) satisfying a selection predicate pred with the
triple (s", p", o") can be expressed as:
While the INSERT and DELETE statements can be considered the only necessary
primitive operations, also more complex modification instructions (e.g. involving
multiple or computed insertions, manipulation of RDF graph stores [
WHERE pred(s, p, o) DELETE {s, p, o} VALID tv WHERE pred(s, p, o) ; INSERT DATA {s!, p!, o!} VALID tv whose effect is equivalent to the execution in the same transaction of a DELETE followed by an INSERT defined as follows: High-level ontology change operations (e.g. to add a new property to a class or an inheritance link to a class or to a property) can also be defined in terms of the manipulation primitives presented in this Section.
For instance, considering lightweight RDFs ontologies, a ADD PROPERTY(Class, Property, Range, Validity) operator can be introduced to add a new property with a given range to a class. It can be defined as:
INSERT DATA { Property rdfs:domain Class ;
rdfs:range Range . } VALID Validity A CHANGE PROPERTY RANGE(Property, NewRange, Validity) operator, to be used to change the range of a property, can be defined as:
SET { Property rdfs:range NewRange } VALID Validity Finally, a DEL PROPERTY(Class, Property, Validity) operator can be introduced to delete a property of a class, defined as:
DELETE { Property rdfs:domain Class ;
rdfs:range ?range . } VALID Validity Example In order to see an example of their application, let us consider a bitemporal domain and assume to (pro-actively) define on 1989/12/1 an ontology valid from 1990 in the current RDF database. Hence, we consider a property P with range R1 to be added to a class C in this version. This can be done by means of the command which follows:
ADD PROPERTY(ex:C, ex:P, ex:R1, FROM ’1990-01-01’) Assuming the statement was executed on 1989/12/1, its execution caused the temporal triples which follow: ( ex:P rdfs:range ex:R1 | [1990/1/1, uc) × [1989/12/1, uc) ) to be added to the bitemporal RDF database.
Then we consider the creation of a new ontology version valid from 2005, where the range of property P is actually R2, for which the following command has been used (on 2005/1/1): After its execution, the triples above are replaced in the new database state by: ( ex:P rdfs:range ex:R1 | [1990/1/1, uc) × [1989/12/1, 2005/1/1) ∪ [1990/1/1, 2005/1/1) × [2005/1/1, uc) ) ( ex:P rdfs:range ex:R2 | [2005/1/1, uc) × [2005/1/1, uc) ) Finally, we consider the (retro-active) creation of a new ontology version valid from 2009, where property P is deleted from class C. This can be done by executing (now) the statement:
DEL PROPERTY(ex:C, ex:P, FROM ’2009-01-01’) The database state after its execution contains the triples which follows: ( ex:P rdfs:range ex:R1 | [1990/1/1, uc) × [1989/12/1, 2005/1/1) ∪ ( ex:P rdfs:range ex:R2 | [2005/1/1, uc) × [2005/1/1, now) ∪ [1990/1/1, 2005/1/1) × [2005/1/1, uc) ) [2005/1/1, 2009/1/1) × [now, uc) ) As a result, in the current database state (i.e. as of now w.r.t. transaction time), property P has range R1 in the ontology version valid from 1990 to 2005 and range R2 in the version valid from 2005 to 2009. The domain of P is class C in both such ontology versions. P is no longer a property of class C in the ontology version valid from 2009.
Similar macro commands can also easily be defined to manipulate versions of serialized RDF representations of OWL ontologies. 5
In this paper, we presented a multi-temporal RDF database model employing triple timestamping with temporal elements, which best preserves in the multitemporal setting the scalability property enjoyed by triple storage technologies.
The data model has been equipped with a snapshot extraction operator and modification operators, whose semantics has been provided, which allow knowledge engineers to maintain a multi-temporal RDF database in order to manage temporal versions of an ontology.
Some of the effected design choices were motivated by the application requirements of an ontology-based personalization service of a multi-version repository of legal documents (or clinical guidelines). It is our intention to explore the applicability of our approach in application fields with more generic requirements in future work.
In future research, we will also consider extensions of the proposed RDF database model, including the development of a complete multi-temporal SPARQLlike query language and the adoption of suitable multidimensional index structures to efficiently support the execution of temporal queries.