applying object-oriented technologies in modeling and querying temporally oriented clinical...

100 IEEE TRANSACTIONS ON INFORMATION TECHNOLOGY IN BIOMEDICINE, VOL. 1, NO. 2, JUNE 1997

Applying Object-Oriented Technologiesin Modeling and Querying Temporally

Oriented Clinical Databases Dealing withTemporal Granularity and Indeterminacy

Carlo Combi,Member, IEEE, Giorgio Cucchi, and Francesco Pinciroli

Abstract—The need of managing temporal information given atdifferent levels of granularity or with indeterminacy is commonto many application areas. Among them, we focus on clinical datamanagement. Different time granularities and indeterminacy arealso needed in querying temporal databases. In this paper, wedescribe GCH-OSQL (Granular Clinical History-Object Struc-tured Query Language), an object-oriented temporally-orientedextension of SQL. GCH-OSQL is based on an object-orientedtemporal data model, GCH-OODM. GCH-OODM allows storageof clinical information at different and mixed granularities orwith temporal indeterminacy. GCH-OSQL deals with the validtime of clinical information. The temporal extension of the SE-LECT construct includes the addition of the TIME-SLICE andMOVING WINDOW clauses, and the capability to reference thetemporal dimension of objects in the WHERE and SELECTclauses. Using object-oriented technologies, a system prototypefor GCH-OSQL and GCH-OODM has been implemented andapplied to data management of follow-up patients after coronaryangioplasty intervention.

Index Terms—Database technology, object-oriented technol-ogy, medical informatics, temporal databases.

I. INTRODUCTION

DIFFERENT fields of computer science deal with temporaldata management and representation: artificial intelli-

gence, software engineering, and databases are some of thosefields, in which topics related to the management of thetemporal dimension of data are dealt with [1], [28], [38], [49].

In database field, topics related to temporal databases gainedincreasing attention during the last years [13], [15], [25],[30], [38], [49]. Among main research directions, we can

Manuscript received February 4, 1997; revised July 3, 1997. This workwas supported in part by contributions from MURST Italian National Projectfor Medical Informatics, the Department of Biomedical Engineering of thePolitecnico di Milano, and CNR’s Centro Studi per la Teoria dei Sistemi,Department of Mathematics and Computer Science of the University of Udine.

C. Combi is with the Dipartimento di Matematica e Informatica, Universita’degli Studi di Udine, 33100 Udine, Italy (e-mail: [email protected]).

G. Cucchi was with the Dipartimento di Bioingegneria, Politecnico diMilano, Milano, Italy. He is now with Sinapsi srl, Rome, Italy.

F. Pinciroli is with the Dipartimento de Bioengegneria, Politecnico diMilano, Milano, Italy. He is also with the Centro di Ingegneria Biomedica delCNR, Milano, Italy.

Publisher Item Identifier S 1089-7771(97)07233-6.

distinguish the study of temporal data models and the defini-tion of suitable temporal query languages [49]. The proposedtemporal data models usually consist in extensions of alreadyexisting data models, like the relational model, the entity-relationship model, the object-oriented models [31], [44], [49],[54]; similarly the query languages for temporal databases arebased on extensions of the most known query languages [31],[36], [39], [43], [48].

Medical Informatics pays particular attention to the problemof managing and representing the temporal aspect of clinicalinformation [11], [14], [22], [23], [27], [41], [50]. Time isimportant for clinical medicine both in defining the diagnosis,in identifying the therapy, and in defining the prognosis [11],[21], [41]: these decision making actions hold during a timeand are dealt with in respect to information that is temporallycharacterized. In order to assess a diagnosis, in fact, thephysician finds out the clinical history of the patient, composedusually by previous pathologies, therapies, and symptoms,the patient narrates; this information completes data collecteddirectly from the patient, i.e., the blood pressure, heart rate,identified by their temporal location [40]. In supporting bycomputer the storage and the retrieval of this information, weneed to deal with the temporal dimension of clinical data,besides with the complex structure of natural language-relateddata. The considered temporal dimension is usually thevalidtime, i.e., the time during which the information is true in themodeled reality [49].

A. Modeling and Querying Temporal Clinical Data

Some important issues have to be considered in temporally-oriented clinical data.

• The temporal dimension is expressed by using sometimesthe concept of interval, for facts having a span of time,and sometimes the concept of instant for events holdingat a time point [11], [14], [22], [53]. This temporaldimension, moreover, can be expressed in different andheterogeneous way: the used time axis, for example, hasdifferent time units (“in 1989 the patient had myocardialinfarction,” “at 1:00 p.m. the patient had an episode ofatrial fibrillation: it lasted 48 minutes”); in other casesthe temporal location is expressed with some vague-

1089–7771/97$10.00 1997 IEEE

COMBI et al.: APPLYING OBJECT-ORIENTED TECHNOLOGIES IN MODELING 101

ness (“between 17:30 and 18:15 the patient had for 6seconds ventricular fibrillation”). We say that temporaldimension of clinical information is given at differentgranularities, i.e., with different units of measure, andwith temporalindeterminacy, i.e., with some vagueness indefining its temporal location [45]. Furthermore, differentgranularities and/or indeterminacies can be used in manyvarying ways to define temporal intervals (“at 17:30 for20 seconds,” “for 3 hours until 16:20,” “it started between14:20 and 14:33 and it ended between 18 and 18:30”).We also have to consider that this heterogeneity can bepresent for the same kind of clinical information: anepisode of atrial fibrillation can be identified, in a context-varying way, both by the definition of its starting andending instants, and by the day of occurrence and theduration in seconds.

• In querying the system about the stored clinical infor-mation we usually use different granularities with norelation to the ones used when storing data. In thesame query different granularities/indeterminacies can beused. Queries can consider conditions both explicitlyrelated to absolute time, and about relative temporallocation between data [29]. It must be possible, in otherwords, to define queries on the database that wouldbe expressed in natural language by sentences as: “Wewant to identify those patients who suffered from acutemyocardial infarction in 1989 and who, in the six monthsafter that event, had had episodes of ventricular fibrillationlasting no more than 3 seconds” or “We want to knowwho are the patients who, in the years between 1980 and1985, underwent an angioplasty intervention, followedby a reintervention in the following three months, andwho have been treated with calcium antagonists after thesecond intervention for at least 45 days and no more than60 days.”

• In dealing with information having different granulari-ties/indeterminacy, it is possible that in some cases sometemporal relations cannot be asserted for sure. It is notpossible, for example, to establish the before/after relationbetween two pathologies, represented, respectively, bythe two sentences “myocardial infarction on October 22,1994” and “atrial fibrillation episode in October 1994.”

• Clinical information, finally, may consist both of naturallanguage sentences (“the patient suffered from breath-ing problems in Winter, 1989,” “the patient finished on10/10/87 a therapy with thrombolytics, lasting from twoyears”), and of quantitative parameter values, related tosome measurements on the patient (“on March 23, 1995,at 15:22 the physician got a blood pressure of 170/95mmHg from the patient,” “blood sample of September14, 1995: cholesterol in serum is 222 mg/dl”) [11], [14].

B. Object-Oriented Temporal Query Languages

Object-oriented technology applied to the database field hassome features useful—abstract data type definition, inheri-tance, complex object management—in modeling and man-aging complex information, as that coming from clinicalmedicine [7], [9], [11], [22], [24].

In the temporal database field, and also in applying temporaldatabases to the management of clinical data, the definitionand implementation of languages for querying temporal object-oriented databases have not yet so deeply investigated, as ithas been done for query languages for temporal relationaldatabases [44].

Three approaches have been adopted in dealing with thetemporal dimension of data by object oriented data models andquery languages [44]: i) direct use of the object oriented datamodel; ii) use of other extensions to the data model, to managethe temporal dimension; and iii) definition of data temporaldimension in anad hocdata model. In the following, we willfocus on the first and the third of the mentioned approaches,because both of them deal explicitly with the temporal aspectof data.

1) OODAPLEX [54] and TIGUKAT [18], [32] adopt thefirst approach. In these systems suitable data types allowthe database designer to model temporal information.For example, in modeling different concepts of time,OODAPLEX allows the usage of the supertypepoint,from which each user-defined or system-supported datatype inherits, to represent different temporal dimensions[54].

TIGUKAT models valid time at the level of objectand of collections of objects [18]: however, the singleapplication is allowed to use the rich set of system-supported types, to define the real semantics of valid(or transaction) time [32]. The query language definedin TIGUKAT is able to follow the more recent standardsexisting for SQL; the proposed query language TQLextends SQL statements to support the object-orienteddata model of TIGUKAT; in a similar way to what itis proposed in OODAPLEX, also TQL doesn’t definespecific constructs to explicitly manage temporal aspectsof a query [32].

2) The second approach is mainly based on the concept of“version,” to support the history of attribute values fora class [44].

3) The third approach, based on the definition of suitabledata models able to consider the temporal dimension ofdata, is present in many proposals dealing with the def-inition of temporal query languages, like OOTempSQL[8], TOOSQL [36], and OQL/T [47].

C. Motivation and Overview of GCH-OODM and GCH-OSQL

In this paper, we propose the query language GCH-OSQL (Granular Clinical History-Object Structured QueryLanguage); GCH-OSQL satisfies some requirements notcompletely supported by the proposals from literature [8],[32], [36], [54]. Particularly GCH-OSQL and GCH-OODM(Granular Clinical History-Object-Oriented Data Model),the subtended object-oriented temporal data model, havesome features coming from the needs observed in managingtemporal clinical databases.

In modeling temporal clinical data, in fact, we have toconsider, for example, symptoms, described by the patientwith natural-language expressions containing different time


granularities and temporal indeterminacy, as illustrated inSection I-A. Clinical evaluation of these symptoms is per-formed according to criteria involving indeterminacy andgranularities: e.g., in the definition of unstable angina differentgranularities are involved—symptoms of “angina at rest, formore than 20minutes,” or “new onset, within twomonths,exertional angina, involving marked limitations of ordinaryphysical activity,” or “increasing angina within twomonthsfrom the initial presentation,” or “post-myocardial infarctionangina, at least 24hoursafter” [4]. Finally, therapy prescrip-tions involve different time units and/or indeterminacy: e.g.,nitroglycerin is recommended “for the first 24 to 48hours inpatient with acute myocardial infarction and CHF (CongestiveHeart Failure), large anterior infarction, persistent ischemia,or hypertension,” but in intensive medical management ofunstable angina, “the heparin infusion should be continued for2 to 5 days,” and morphine prescriptions are given by usingminutesas time unit [4], [37].

Despite to these needs in managing temporal clinical infor-mation, GCH-OODM and GCH-OSQL focus on the followingtopics.

• Seamless management of valid time defined at differ-ent levels of granularity or with indeterminacy. Validtime can be expressed at different time granularities orwith indeterminacy both in inserting data into and inquerying the database. The granularity/indeterminacy atwhich we consider clinical information, is, in fact, relatedto different needs, depending if we are inserting data orif we are querying the database: a patient with “atrialfibrillation on March 25, 1989 for 85 minutes” belongs tothe group of patients having “atrial fibrillation in 1989 forless than 24 hours.” An interval is usually adopted to rep-resent valid time [11], [54], but it is possible that differentgranularities/indeterminacies are used, to define startinginstant, ending instant, and duration of the interval itself[11]. Expressions like “starting from October 3, 1990, forthree months,” “From December 4, 1990 to January 6,1991,” “in 1990 for 6 days,” “starting from June 1990,lasting between 6 and 9 days,” “for 6 days until February,1995” are suitably modeled and managed by GCH-OSQLand GCH-OODM: at the best of our knowledge, thereare no temporal query languages, from literature, ableto represent all those different granularities of valid-timeintervals. GCH-OSQL allows us to query an object-oriented database about many temporal relationships,taking into account different granularities; besides theusual relationships between intervals or between instants,for example, it is possible to express concepts like “inthe same year” or “in the same month.” Sometimes theserelationships are quantitatively specified, by expressionslike “two months later” or “within 6 days” [29].

• Management of uncertainty due to different gran-ularities/indeterminacies of valid times in temporalrelationships. Temporal relationships between objectshaving valid times specified at different granularities orwith indeterminacy may be neither false nor true; GCH-OSQL is able to manage and to allow the expression ofconcepts related to uncertainty in temporal relationships,

like “it is possible that ,” “it maybe that ,” or “it isfor sure that ” [11], [29].

• Modeling complex temporal clinical information. Tem-poral and atemporal features of complex objects aresuitably modeled. Temporal features of an object can con-sist of other different objects, having their own temporaldimension; a symptom, for example, can be modeled asan object having a temporal dimension (i.e., the intervalover which the symptom happened), but it can have also aproperty, consisting of the set of all the related therapies,being objects having another temporal dimension.

With respect to the needs and features above described,GCH-OSQL is based on an object-oriented data model, namedGCH-OODM (Granular Clinical History-Object Oriented DataModel). It extends the results in modeling time and clinicalinformation described in [11] and applies them to a moregeneral object-oriented data model. The temporal dimensionis modeled by somepredefined data types, allowing timemanagement at different abstraction levels. GCH-OODM dis-tinguishestemporal objects, having a valid time, andatempo-ral objects, modeling non time-varying entities, or for whichtemporal dimension is not significant. GCH-OSQL belongs tothose query languages generalizing the syntax of the widelydiffused query language SQL [5] to support objects [2]. GCH-OSQL is, then, only syntactically an extension of SQL: itallows users1 familiar with relational systems to deal withthe same well-known model for the formulation of the query.On the other hand, GCH-OSQL is completely object-oriented,being based on object-identity for the retrieval of objects andsupporting other object-oriented features, like inheritance andencapsulation.

GCH-OSQL allows us to query a database about temporalfeatures: conditions related to temporal properties are ex-pressed in the clause WHERE, by specifying suitable temporalrelationships between objects, on the basis of the time-relatedpredefined data types. Two added clauses TIME-SLICE andMOVING WINDOW allow us to temporally constrain thesubpart of the database GCH-OSQL will consider in theevaluation of the query [36].

GCH-OSQL adopts a hybrid approach, with regard to thetaxonomy proposed in [44]: GCH-OSQL supports a set ofpredefined data types to model time, but allows the user toenrich this set withad hoc time-related data types, simi-larly to OODAPLEX and TIGUKAT [32], [54]; on the otherside, differently from these last systems, it explicitly definesand manages valid time of temporal objects and also addssome suitable clauses for temporal queries, similarly to whatproposed in TOOSQL and TempOOSQL [8], [36].

GCH-OSQL has been implemented and has been appliedto an object-oriented system prototype for managing medicalrecords of follow-up patients who underwent an angioplastyintervention [10], [34], [51]: it has allowed us to verify on areal clinical application the usefulness of the proposed querylanguage. The user interface of the system is window-based

1In the following, if not explicitly mentioned, we will refer to the term“user,” to identify technical people, responsible for the design, the develop-ment, and the management of the clinical database. The term “end-user” refersto a user, possibly involved in the clinical use of the system.


and allows different interaction modalities, depending on end-user skills [9].

D. Organization of the Paper

The rest of the paper is organized as follows: in Section II,we describe the object-oriented temporal data model GCH-OODM. After a brief description of the main concepts relatedto time modeling, already presented in [11], emphasis is givenon the more specifically object-oriented and novel featuresof the data model. Section III provides a detailed descriptionof GCH-OSQL, using a simple example database from theclinical domain. An example of a real clinical application,where GCH-OODM and GCH-OSQL have been applied, isthen provided. In Section IV, we describe the system prototypewe implemented, both for issues related to the architectureand for issues related to the user interface. In Section V,we provide a detailed comparison of our proposal with otherrelevant query languages described in the literature. Section VIpresents the final outlines.

II. THE OBJECT-ORIENTED TEMPORAL

DATA MODEL GCH-OODM

GCH-OODM is an object-oriented data model, extended toconsider and manage the valid time of information. The modeldoes not consider the problem of the temporal evolution ofobjects nor the role changes of objects [6], [54]; it focuses onthe capability of managing valid time expressed by differentand mixed granularities and/or with indeterminacy.

A. Basic Concepts and Notation

An object can model any entity of the real world, e.g., apatient, a therapy, a time-interval. The main feature of anobject is its identity, that is immutable, persists during theentire existence of the object, and is independent from theproperties or the behavior of the object. This identity is usuallyperformed by an identifier, called OID (Object IDentifier).An object is characterized by astate, described by attributes,not accessible from outside, and by aninterface, defined bymethods, describing modalities, by which it is possible tointeract with the object itself [2].

Objects are created as instances of aclass. Several distinc-tions and interpretations have been proposed for the termsclass and type; in the following we will use these termsas synonyms, to describe the proposed data model [46]. Aclass characterizes the behavior of its instances, by describingthe methods applicable to objects, instances of the class. Bymethods, properties of objects and relations between objectsof the same class or of different classes are expressed. Eachmethod has a declaration, consisting of a name, a set ofparameters, identified by name and type, and a result, identifiedby a type. Like attributes, code associated to the execution ofa method is not accessible from outside. The collection of thedeclarations of a class is called interface of the class. Froma notational point of view, the reference to a methodapplied to an object will be written as .

GCH-OODM supports the main features of object-orienteddata models, as applied to databases: besides the already

mentioned object identity and encapsulation, the data modelsupports also single inheritance, polymorphism, managementof complex objects, persistence [24].

Besides the usual types (char, char*, int, real) GCH-OODM uses some collection types: sett , bag t ,list t , array t . Each of these types is a type generator,in respect with the type t in the angle brackets [7].GCH-OODM uses, to model the temporal dimension ofinformation, some predefined data types: the type hierarchyel_time, instant, duration, interval; the collection typet_o_set, and some of its specializations, by which setsof temporal objects are modeled. The typegranularitymodels different time units: objects of this type can havevalues belonging to the set, ordered by descending values,SUP INF composed by the

symbols of the considered time units and by the symbolsSUP and INF, for granularities, respectively, coarser andfiner than the units of measure of the adopted Gregoriancalendar. GCH-OODM relies on a three-valued logic, modeledby the type bool3, to manage uncertainty coming fromcomparison between temporal dimensions expressed atdifferent granularities/indeterminacies.

B. Managing the Three-Valued Logic: The Class bool3

The presence of different granularities/indeterminacies leadsto manage relations between intervals possibly having, be-sides the two logical valuesTrue or False, a logical valueUndefined. It is not always possible to establish with cer-tainty the truth or the falsehood of relations existing betweenintervals [11].

Let us think of the two sentences “In December 1994 thepatient suffered from a headache for seven days,” and “InDecember 1994 the patient suffered from pneumonia for 15days.” While we can affirm for sure that for the patient thepneumonia lasted more than the headache, we cannot answerwith True or False to the question if the patient sufferedfrom the headache before suffering from pneumonia. Boththese answers could be wrong, because we haven’t enoughinformation (which are the starting and the ending day of thetwo pathologies).

We then use a three-valued logic, in which the valuesT: True, F: False, and U: Undefinedare present. The usuallogical connectives AND, OR, NOT, IMPLIES, , and thelogical quantifiers EXISTS (), and FOR EACH () havebeen extended to consider the third truth valueUndefined. Theadopted three-valued logic derives from Kleene’s logic, wherethe third truth value U is related to situations, about which itis not possible to know the truth or falsehood [33], [35]. Incomparison with the Kleene’s logic we added the new logicalconnectives T(), U(), and F(), to explicitly manage each of thethree truth values. The interpretation of the logical connectives,depending on the values of the formulas A and B, is describedby the following truth tables. In GCH-OODM, formulas mayconsist of: a) methods returning a logical value (managed bythe classbool3), b) comparison operations between objectsreturned by suitable methods and/or suitable typed constants,or c) composition by the logical connectives of formulas of


type a) or b).

A NOT A T(A)

T F TF T FU U F

A B A AND B

T T TF T FU T UT F FF F FU F FT U UF U FU U U

The meaning of the other logical connectives can be definedby the above defined ones: A OR B stands for NOT((NOTA) AND (NOT B)); F(A) stands for T(NOT A); U(A) standsfor NOT (T(A) OR T(NOT A)). This three-valued logic ismanaged by the predefined data typebool3.

C. Time Modeling

An interval, expressed in a heterogeneous way like inexamples of Section I, is represented by its starting instant,duration, and ending instant. Obviously, some constraintsexist among the values of starting instant, ending instant,and duration of an interval: if we are specifying instantsand duration at different granularities or with indeterminacy,given the values of two of the three entities characterizingan interval, the value of the third entity depends on thegranularities/indeterminacy of both the given values. Thisis the reason for which, only using both starting and end-ing instants and duration, it is possible to express an in-terval with different and heterogeneous granularities or withindeterminacy [11].

Instants and duration, expressed at different granulari-ties/indeterminacy, are based on a discrete time axis, wherepoints, named elementary instants, are represented by thefinest time unit considered by the model. In our data modelthat of seconds is the unit of measure of the time axis. It isalso possible to define duration, having values of one or moreorders of magnitude lower than seconds (by the symbol),and unknown (by the labelunknown) [11].

In GCH-OODM, in order to manage the temporal dimen-sion, some classes have been defined, modeling the conceptsof elementary instant, instant, duration, and interval.

The classel_time allows us to model time points on thebasic time axis, named elementary instants. Each elementaryinstant is identified by the corresponding chronon, i.e., thenondecomposable unit of time supported by the temporalDBMS [45], [49]. By the classel_timeproperties of integersare extended to the time axis. This way, both time points andspans between time points are modeled in a homogeneousway: time points are identified on the basic time axis by

their distance from the origin of the axis. The classel_timeprovides, then, functions both to manage the absolute locationof time points on the time axis—i.e., calendar-related functionsable to deal with leap years, months having 28, 29, 30, or31 days—and to manage time spans—i.e., functions able toperform operations on time spans by the adoption of conceptslike the mean month—and also to compute sum and differenceoperations on time points/time spans. For clarity reasons wewill use two different formats, to specify time points, i.e.,anchored time spans, and distances between time points, i.e.,unanchored time spans. We use the usual calendric format

to specify a time point. We will use theformat , to identifya distance between time points ( , andstand for values related to the corresponding time unit). Thetime point , for example, identifies the firstsecond of October 10, 1994; the time spanidentifies a duration lasting 5 min and 2 s (we will omit tospecify , but only for time unitscoarser than the coarsest time unit having a nonzero value).

The class instant allows us to represent a time point,identified by the granule, i.e., a set of contiguous chronons,containing it. This class uses, by the methodsinf() andsup(), two objects of typeel_time, to represent the lowerand upper bound of the granule, in which the generictime point is located. A granule can be expressed bydifferent time units, e.g., by the format or

, or it may be specified by two time points, i.e., theupper and the lower bound of the granule, by the format

, if wehave to model explicit indeterminacy. The instant ,for example, may coincide with anyone of the time pointsincluded between the two bounds and

, represented by two objects ofel_time type: the notation will be equivalentto . The instant

specifies atime point between 12:30 and 12:36 of December 12, 1996.

The classduration allows us to model a generic duration,specified at arbitrary granularity. This class uses, by themethods inf() and sup(), two objects of typeel_time, torepresent the lower and upper distances between chronons,between which the value of the given duration is included. Aduration is expressed by an ordered sequence of elements,composed by an integer followed by a granularity spec-ifier (from years to seconds, ): e.g.,

. The duration , for example,stands for a time span betweenand . A duration may also beexpressed by specifying the lower and upper distances, e.g.,

,for explicit indeterminacy.

Suitable methods allow the expression of relations and ofoperations, like sum or differences, on instances of the classesinstant and duration [11].

A generic interval, i.e., a set of contiguous time points, ismodeled by the classinterval. The methodsstart(), end(), anddur() allow us to identify, respectively, to starting instant,


(a)

Fig. 1. Temporal relations between intervals in GCH-OODM. (a) The notation and a graphical example for each of the relations between intervals definedin GCH-OODM are represented. This figure describes relations defined by starting and ending instants of intervals. Inverse relations are not mentioned.Considering also inverse relations, we would have 16 relations. Intervals are represented in respect with the basic time axis, modeled by the classel_time.On the time axis time points being possibly starting and ending instants are highlighted. When needed an auxiliary time axis is represented, related to theconsidered granularity. In GCH-OODM, methods of the classinterval representing temporal relations are defined by the methods of classesinstant andduration, based, in turn, on methods of the classel_time (see Appendix A for a formal definition of the defined temporal relations).

the ending instant and the duration of the interval. Suitablemethods of the classinterval allow us to establish temporalrelations between two intervals, specified by different andnot predefined granularity and/or indeterminacy. Relationsbetween intervals are a superset of the 13 Allen’s relationsand they can be divided in granularity-related relations andgranularity-independent relations [1], [11] or in relations based

on the location of intervals on time axis and duration-relatedrelations [Fig. 1(a) and (b)]. These relations are described indetail in [11]. Appendix A provides a formal definition formethods of the class interval.

Using methodsstart(), end(), and dur() is not redundantto identify an interval: e.g., the interval having the meth-ods and returning, respectively,


(b)

Fig. 1. (Continued.) Temporal relations between intervals in GCH-OODM. (b) In the figure, the notation and a graphical example for each of the relationsbetween intervals defined in GCH-OODM are represented. This figure describes relations defined by duration of intervals. Inverse relations are not mentioned.Considering also inverse relations, we would have six relations.

The lower distance between elementary instants is represented by filled arrows; the greater distance between elementary instants is represented byempty arrows. Dashed/continuous lines distinguish distances related to the durations of the two intervals, if it is necessary (see Appendix A for a formaldefinition of the defined temporal relations).

and , could have the method returning(i.e., a

duration between one second and two days less one second)or .

This last interval, having the duration (24 h) specified at agranularity level (seconds) finer than that used in specifyingstarting (ending) instant, cannot be expressed, for example, inTSQL2 [45].

To explicitly refer to a given interval , we will usethe following notations: when startinginstant and duration are given, e.g. ;

when ending instant and durationare given, e.g., ;when starting and ending instants are given, e.g.,

.In Fig. 3 (Section III-A), some examples are given for

intervals, instants, and durations defined at different and mixedgranularities/indeterminacies.

D. Temporal and Atemporal Classes

GCH-OODM distinguishes, as already mentioned,temporalclassesand atemporal classes.

Temporal Classes:Objects instances of temporal classes(hereinafter temporal objects) have an associated valid interval.By these temporal objects we are able to represent informationfor which it is important to know the period during which theinformation is true in the modeled world. For example, theclass modeling the concept of pathology (or therapy) has toconsider the interval, during which the pathology was present(or the therapy was administered). The methodvalid_interval()returns the interval of validity of an object. By the validinterval it is possible to verify temporal relations betweenobjects instances of temporal classes. Temporal objects canhave many temporal properties; these properties, defined bysuitable methods, are represented by temporal objects, havingtheir own valid interval.


Atemporal Classes:Objects instances of atemporal classes(hereinafter atemporal objects) model information, not havingan associated temporal dimension. By these objects we are ableto represent information, for which the temporal dimension isnot interesting (let us think to an object modeling demographicdata of a patient, about which we do not want to record thehistory: address, profession, ). An atemporal object can,however, have properties represented by temporal objects. Forexample, the object modeling a hospital division, without anyvalid interval, can have a property related to the history of theheads of the division, modeled by temporal objects.

Both in temporal and atemporal classes we distinguish, then,a) temporal methods, modeling temporal features, returningtemporal objects, and b)atemporal methods, returning atempo-ral objects. In Fig. 2 (Section III-A), some examples are givenboth for temporal and atemporal classes and for temporal andatemporal methods.

E. Temporal Properties

In GCH-OODM temporal properties are modeled by tem-poral objects, which can be composed by sets of temporalobjects, with an approach having analogies with that in [18].Several temporal constraints can be defined by GCH-OODM.It is possible, for example, to model the constraints on the validtime of objects and properties described in other contributions[36], [54]: being an object modeling a temporal propertyof a temporal object , the following relation must hold:

.valid interval .IN o.valid interval 2

In GCH-OODM, the temporal properties of a temporalobject are not constrained like the above defined one. GCH-OODM allows us to model many other constraints existingbetween the valid interval of an object and the valid intervalof a temporal property. Let us think, for example, to a temporalpropertyo.prev() of a temporal object ; o.prev() is an objecthaving a valid interval that must precede the valid interval ofthe object . In this case the following condition holds:

.valid interval .AFTER o.prev valid interval 3

For these kind of constraints, which may exist between tem-poral objects, GCH-OODM allows us to explicit the existenceof constraints, during the design of the methods of temporalclasses for the considered database.

F. Set of Temporal Objects. The Class

The predefined classt_o_set (temporalobject set) allowsthe construction and the management of sets of temporalobjects. To the instances of the classt_o_set it is possibleto apply the usual operations on sets: insertion, deletion, inter-section, union, difference, existence of an element, emptiness,contained-in relation. Some methods are defined to verifythe existence, at a given granularity (if needed), of temporal

2The method IN stands for (DURING OR FINISHES OR STARTS), wherethe granularity used for relations FINISHES and STARTS is the finer betweenthose of the two operands.

3The method AFTER verifies the inverse relations of that verified by themethod BEFORE.

relations between objects belonging to an instance of the classt_o_set, characterized also by some atemporal features.

Let us consider for example the following methods, relatedto an instance I of the classt_o_set. Let be two logicalexpressions,4 and two temporal objects, an assignedgranularity. To explain the meaning of the following methods,we will use the methodsubset: I.subset returns the subset oftemporal objects belonging to I and satisfying the expression.

• I.OCCURS I

The method OCCURS() allows us to establish if in the setI there is an object satisfying the condition.

• I.CONTEMPORARYI I

x.valid time CONTEMPORARY valid time

The method CONTEMPORARY allows us to es-tablish if in the set I there are two temporal objects, satisfying,respectively, the logical expressionsand , and having thevalid intervals contemporary at a predefined granularity.

In a similar way, we defined methods allowing us to verifythe existence of the above described relations for temporalobjects belonging to the instance I of the classt_o_set. Similarmethods are defined to verify relations between a temporalobject and a given interval. All these methods are detailedin [11]. Appendix A reports the definition of these methodsaccording to the adopted object-oriented notation. Appendix Breports the notation of the methods in GCH-OSQL.

The classt_o_setis a temporal class. The valid interval of anobject I instance of the classt_o_setis evaluated on the basisof all the valid intervals of temporal objects belonging to I:

I valid interval start inf

valid interval start inf I

I valid interval start sup

valid interval start sup I

I valid interval end inf

valid interval end inf I

I valid interval end sup

valid interval end sup I

I valid interval dur inf

I valid interval end inf

SUB I valid interval start sup

I valid interval dur sup

I valid interval start sup

SUB I valid interval start inf

where the functions and SUB() related, respectively, tothe maximum evaluation and to the difference operation, aresuitably defined for the typeel_time. Granularity of the validinterval of an instance of the classt_o_setdepends, then, onthe granularities of the valid intervals of objects belonging

4A logical expression may consist in: a) methods returning a logical value(managed by the classbool3), b) predicates made by comparison operationsbetween objects returned by suitable methods and/or suitable typed constants,or c) composition by the logical connectives of expressions of type a) or b).


to the modeled set. Section III-A shows some examples ofobjects of the classt_o_set, with their valid intervals.

G. Some Specializations of the Class

Several specializations of the classt_o_setcan be defined,to manage only some types of temporal objects. This is theusual way to specialize classes defined by type generators:t_o_set is a specialization oft_o_set iff the temporalclass is a specialization of the temporal class. We canspecialize in an orthogonal way the classt_o_setto consideralso temporal constraints among managed temporal objects.Let us consider some specializations of the classt_o_set,allowing the management of particular features of sets oftemporal objects.

In GCH-OODM, it is possible to model temporal propertiesin a way similar to what is done by property-functions in [8]or by time-varying properties in [54] or by time sequencesin [36]. In this way, the classtime_varying_propertycan bedefined:

classtime varying property: public t o set.....

For each instance P of the class the following formula holds:

P time varying property NOT

P NOT valid interval valid interval

OR valid interval valid interval

AND valid interval gran

Each temporal object belonging to a set modeled by aninstance of the classtime_varying_propertyhas then a validinterval, not overlapping with other valid intervals of objectsbelonging to the same set; being that set composed by temporalobjects having a predefined and fixed granularity, the setis temporally ordered.

More generally, GCH-OODM allows the expression of sev-eral categories of sets of temporal objects, for which differentconstraints on valid intervals and/or on relations betweenvalid intervals of temporal objects hold. By specializationsof the classt_o_set, we are allowed to express features similarto those described by Jensen and Snodgrass for temporalrelational databases in [20].

Classesvalid interval regular with time unit at gran ,with and having assigned values, inherit from the classt_o_setand are similar to relationsvalid time interval regularwith time unit , defined by Jensen and Snodgrass [20].

For these classes the following formula holds:

P valid interval regular with time unit

at gran integer duration

valid interval end TEMP EXP AS

valid interval start SUM AND

valid interval gran AND

gran AND

where the notation stands for the application of themethod corresponding to the used granularity, to express

the duration at the right granularity [11]. By this temporalclass, for example, we can model that all therapies assignedto a patient must have a span multiple of a predefined numberof days.

It is also possible to define classes, modeling in adetailed way relations between valid intervals of temporalobjects belonging to the considered set. For example, the classvalid_time_event_regular_with_time_unit_ _at_gran_ , with

and having assigned values, is similar to relationsvalidtime event regular with time unit , defined in [20].

For this class the following formula holds:

P valid time eventregular with

X time unit at gran X integer duration

valid interval end TEMP EXP AS

valid interval end SUM AND

valid interval start TEMP EXP AS

valid interval end AND

valid interval dur TEMP EXP AS AND

valid interval gran AND

That class is able to model, for example, the set of data relatedto follow-up visits: acquired data have instantaneous validtimes with a predefined granularity (usually days), and twovisits must be distant of multiples of a predefined time span(e.g., two days).

In comparison with the taxonomy from Jensen and Snod-grass, GCH-OODM allows us to define classes, inheriting fromthe classt_o_set, modeling the existence of intra- and inter-valid interval relations. These relations are able to considerdifferent time granularities and indeterminacy to distinguishsure relations and possible relations, because of the adoptedthree-valued logic.

Further specializations allow us to verify some logicalconsistency of the stored information. In a set of diagnosesrelated to the same patient, for example, cannot exist twodiagnoses having two overlapping valid intervals, and con-tradicting or implying one another. Instances of the classconsistent_diagnoses, defined to manage only instances of thetemporal classdiagnosis, must satisfy the following formula:

P consistentdiagnoses clinically implies

OR clinically conflicting

IMPLIES T valid interval BEFORE

valid interval OR valid interval BEFORE

valid interval

More generally, constraints on temporal objects, managedby specializations of the classt_o_set, can be founded both ontemporal relations between valid intervals and on constraintsdefined by atemporal methods of the considered temporalobjects.

III. T HE GCH-OSQL QUERY LANGUAGE

The temporal extension to SQL syntax concerns the partneeded for database querying. We did not define any particular


Fig. 2. The schema of the example clinical database.

syntax for update, insert, and delete operations, to preserve in-formation hiding [7], [46]. The specific programming languageof the adopted object-oriented DBMS directly manages theseoperations.

The temporal extension includes the addition of the TIME-SLICE and MOVING WINDOW clauses in the original SE-LECT statement; the temporal dimension of objects may bereferred to in the WHERE and SELECT clauses.

A GCH-OSQL query may be expressed this way, wheresquare brackets mean the clause is optional:

The query returns data retrieved through methods listed inthe SELECT clause, from classes instances in the databaselisted in the FROM clause, satisfying the conditions imposedthrough the optional clauses WHERE, TIME-SLICE, MOV-ING WINDOW.

Retrieved objects are those for which the specified condi-tions result in TRUE or UNDEFINED logical values. There-fore also objects who might satisfy the specified conditionsare included in the result.

According to the object-oriented approach we exposedbefore, object attributes are referred to through methods listedin the clauses, hiding implementation details to users. When amethod is specified in a clause, the related code is executed.An object can be reached through apath expression(implicitjoin): it consists in a sequence of methods separated by a “.”(see Example 3.1).

In showing main features of GCH-OSQL, we will considerthe database described in the following section.

A. The Example Database

The example schema represented in Fig. 2, obviously farfrom the real clinical data complexity, considers both temporaland atemporal classes. A hierarchy of classes is described,using a C++-like syntax. It refers to a clinical database,where data about patients are stored: data are related tothe symptoms a patient suffers from and to the parameters(like heart rate) collected during follow up visits. For eachsymptom data on assigned therapies is stored. The atemporalclass patient has two temporal properties, modeled by themethodsvisit_set() and symptom_set(), returning instances ofthe temporal classt_o_set. These instances are specializedto manage sets of temporal objects of, respectively,symptomandvisit classes. The temporal classsymptomhas a temporalproperty, modeled by the temporal methodtherapy_set(), tomanage a set of temporal objects of classtherapy. Methodss_name() or heart_rate(), for example, are atemporal.

To show both the modeling features of GCH-OODM andthe query capabilities of GCH-OSQL, we will consider in thefollowing the instance of the example database depicted inFig. 3.

B. The SELECT Clause

In the SELECT clause object methods or path expressionscan be listed, with a comma between them. In this clauseonly methods related to data displaying are allowed: it is notpossible to use in this clause updating methods, that have sideeffects on the state of the database.

Example 3.1: The query “Find all the patients having hadchest pain and display patient name, the starting instant ofeach chest pain symptom, and the assigned therapies” will beexpressed as in (Q3.1) at the bottom of the page. The resultof this query is in (R3.1) at the bottom of the next page.

“ ” (Q3.1)


(a) (b)

(c)

(d)

(e)

Fig. 3. The instance of the example clinical database. In showing an instance of the example database, we use a table for objects of the same class. Eachobject, corresponding to a row of the table, is represented by its OID and by the values of its methods. If methods return complex objects, the OID’s ofthe returned objects are contained in the corresponding column. The inheritance of the classpatient from the classpersonis represented by using the sameOID’s in the corresponding parts. The table for the objects of the classt_o_sethas two special columns containing, respectively, the class name and theOID’s of the managed temporal objects (objectclass and OIDset). Values of valid intervals are given according to the notations described in Section II-C.Values of valid intervals for objects of the classt_o_setare evaluated according to the formulas in Section II-F.

In [8], OOTempSQL is proposed, an object-oriented exten-sion of TempSQL, defined for temporal relational databases.Temporal elements model the valid time: they are finiteunions of intervals; the temporal dimension of information

is modeled byproperty functions, allowing one to expressproperties of temporal objects. The language OOTempSQLadds to the SELECT statement the WHILE clause, to defineconditions on the temporal elements of property functions; it

“ ” “ ” “ ”“ ” “ ” (R3.1)


also allows the reference to the temporal domain of temporal-object properties.

TOOSQL supports both valid and transaction time;TOOSQL is, then, a bi-temporal query language [19]. Inmodeling valid time, TOOSQL, by the related data model,encodes attribute values as time sequences, composed by(value, temporal element) pairs [44]; proposed extensions toSQL are related to all the statements, both for query andfor updating. In more detail, the SELECT statement hassome new clauses: WHEN, to define constraints on the validtime of retrieved objects; GROUP TO, to link new temporalsequences to other temporal sequences previously stored inthe database; MOVING WINDOW, to consider aggregatedata (e.g., the mean salary) in respect to an interval having aspecified duration and moving on the valid time of an attribute;TIME SLICE, to consider only those objects valid in thespecified interval. The clauses ROLLBACK and WITHOUTCORRECTIONS, finally, allow us to query the database aboutthe transaction time [36]. In TOOSQL, it is somehow possibleto use different time granularities, usually statically predefinedduring the definition of types [36].

OQL/T is a query language for object-oriented knowledgebases [47]. This language supports for associations betweenobjects and constraints on the valid time; many functions andtemporal relationships have been introduced to define in asimple way complex temporal conditions [47].

C. The FROM Clause

The objects in the database containing the data we areinterested in are instances of the classes listed in the FROMclause. To each listed class an object variable is associated.An object variable is represented by an alpha–numeric string,whose first character can not be a digit: it is used to referto object instances of the related class in the database. InGCH-OSQL object variables must be present.

In Example 3.1, object variables P for the classpatientandS for the classsymptomare used.

D. The WHERE Clause

In the WHERE clause, the logical conditions which expressthe constraints that must be satisfied by the selected objects arespecified. Complex constraints may be composed by simplerconditions, using the logical connectives AND, OR, NOT, andthe connectives MUSTBE, MAYBE, MUSTNOTBE, trans-lating the T(), U(), F() GCH-OODM connectives. Conditionsinvolving temporal relations are expressed in the WHEREclause through methods of classesinstant, duration, interval,and t_o_set.

Example 3.2: The query “Find all the symptoms occurringduring visits; display the name and the interval of validity ofthe symptom, and also the name of the patients suffering fromit” will be expressed as in (Q3.2) at the bottom of the page.

The result of the query will be:

“ ” “ ”

We underline that the result of the query considers alsoobjects that may satisfy the condition expressed in the WHEREclause: in our case, it is only possible that nausea happenedduring the visit.

Example 3.3: “Find the patients having had nausea andheadache, while headache surely occurred before nausea”: thisquery (Q3.3) can be expressed in the two ways shown at thebottom of the page.

The result of the query will be:“ ”

Like other proposals, in GCH-OSQL we have not addedany other clause (as WHEN or WHILE [8], [36]), that wouldallow one to separately express the temporal part of the query.This choice allows one to express the query constraints in aseamless way, without forcing the user to divide the selectcondition. This choice, moreover, avoids some anomalies,

(Q3.2)

i)

“ ” “ ”

ii)

“ “ ””“ “ ”” (Q3.3)


as, for example, expressing some temporal constraints in theWHEN clause and some others in the WHERE clause [36].

E. The TIME-SLICE Clause

This clause allows the user to query along the temporaldimension of objects, considering only those objects in thedatabase whose valid time is contained in the interval specifiedin the clause. Also objects whose valid time could be containedin the specified interval are selected. In this clause it is possibleto use the MUST and MAY keywords. Using the MUSTkeyword, only those objects whose valid time is certainlycontained in the interval specified in the clause are selected,while using the MAY keyword only those objects are selectedfor which it is uncertain that their valid time is contained in thespecified interval. In the TIME-SLICE clause the time intervalmay be expressed in many different ways:

• by the FROM TO keywords, in order to definean interval by its starting and ending instants: e.g.,

. It is alsopossible to specify only the FROM or the TO keywords.

• by the FROM..FOR keywords, in order to define aninterval by its starting instant and its duration: e.g.,

.• by the FOR TO keywords, to define an interval

by its duration and its ending instant: e.g.,.

• by the AT keyword, to define an interval as a singlegranule: e.g., .

Example 3.4:The query “Find all symptoms happenedstarting from October 2, 1994 to November 12, 1996 in theafternoon; display the name and the interval of validity ofthe selected symptoms” will be expressed as in (Q3.4) at the

bottom of the page. The result of this query is in (R3.4) atthe bottom of the page.

It is worth noting that the capability of defining the TIME-SLICE interval by, respectively, FROM TO, FROM FOR,and FOR TO keywords is not redundant: for example, theclausewill consider, on the chronon time axis, an interval having aduration between 24 h plus 1 s and 72 h less 1 s; the clause

willconsider, on the chronon time axis, an interval having startingand ending instants expressed exactly like in the previousclause, but having a duration of exactly 48 h.

F. The MOVING WINDOW Clause

Using this clause, the objects stored in the database areexamined through a temporal window, of the width specifiedin the clause, moving along the temporal axis. The constraintsexpressed in the other clauses are checked only on the databaseobjects visible through that window.

Example 3.5: “Print the name of patients having had heartrate greater than 120 and symptoms of palpitation in a periodof fifteen days”; this query well be expressed as in (Q3.5) atthe bottom of the page.

The result will be:“ ”

In the MOVING WINDOW clause through the MUSTor MAY keywords, only, respectively, certain or uncertainsituations can be considered.

G. Some Closing Queries

To have a comprehensive idea of GCH-OSQL, let usconsider some more complex queries on our example database.

(Q3.4)

“ ”“ ”

“ ”“ ”

“ ” (R3.4)

“ ”“ “ ””

(Q3.5)


Example 3.6: “Find those patients having had, within aperiod of four months, headache before nausea and othersymptoms surely before headache. Display their names, thesymptoms they had surely before headache, and the therapiesrelated to these last symptoms. Consider only the periodstarting from about noon, October 9, 1994, and lasting 25months”; this query is expressed as shown in (Q3.6) at thebottom of the page. The result of this query is in (R3.6) atthe bottom of the page.

Example 3.7: “Find those patients having had a therapysurely during the period composed by the second half of Julyand the first ten days of August, 1996. Display their names,their therapies, and their previous symptoms having a timespan of less than 36 to 48 hours. Consider only symptoms

having a temporal distance less than 30 to 45 days”; this queryis expressed as shown in (Q3.7) at the bottom of the page. Theresult of this query is in (R3.7) at the bottom of the page.

Query Definition: Some features of GCH-OSQL and GCH-OODM can be observed in the previous queries on the exampledatabase.

i) Instants, durations, and intervals are modeled in a seam-less way both with indeterminacy and with differentlevels of granularity. It happens both in storing temporaldata and in querying the database: e.g., in the TIME-SLICE clause of Example 3.6, both granularity andindeterminacy are present in the interval specification.In the example database (Fig. 3) we have both granular-

“ ” “ ”

(Q3.6)

“ ” “ ” “ ” “ ”“ ” “

” (R3.6)

(Q3.7)

“ ” “ ” “ ”

“ ” “ ” “ ”(R3.7)


ity and indeterminacy in the specification of the validintervals of temporal objects: e.g., the valid intervalof the temporal object s7 of the classsymptomhas astarting instant specified at the granularity of hours and aduration explicitly expressed with indeterminacy. Severalgranularities and indeterminacies can, then, coexist, asshown in the example database (Fig. 3) and in Examples3.6 and 3.7 (i.e., granularities of months, days, andexplicit indeterminacy).

ii) Indeterminacy and granularity in specifying valid in-tervals of stored data and in querying the databaseare not related. For instance, in Example 3.6 granu-larity of months and indeterminacy are present in theclauses, while the database contains data with differentindeterminacy and granularities of months, days, hours,minutes (Fig. 3). In Example 3.7, indeterminacy andgranularities of days are present, while in the result wecan observe data having granularities of days, hours,and indeterminacy.

iii) Indeterminacy in specifying instants, durations, andintervals both in storing and in querying data allowsus to model concepts like “close to,” “about at,”and similar. From this point of view, GCH-OODMand GCH-OSQL do not provide any syntax, todirectly represent those concepts; the user is simplyallowed to define instants, durations, and intervals,and to use temporal relationships, to arbitrarilyrepresent those concepts. For instance, in the TIME-SLICE clause of Example 3.6, the expression “aboutnoon, October 9, 1994” is modeled by the instant

, i.e.,a time point between 11:30 and 12:30 of May 9, 1994.

iv) Uncertainty from temporal relationships is suitablymanaged in the WHERE clause by the connectivesMUSTBE and MAYBE, and in the clauses TIME-SLICE and MOVING WINDOW by the keywordsMUST and MAY. Let us consider the Example 3.7;by asking for therapies surely occurred during theinterval from July 15 to August 10, 1996, we excludethe therapy with aspirin for the same patient. If wehad omitted the keyword MUSTBE, also the therapywith aspirin would have considered in the result. Onthe other hand, if we had inserted the keyword MUST(MAY) in the MOVING WINDOW clause, we wouldhave considered only the symptom “chest pain” (“chestand arm discomfort”) for that patient.

Query Processing:Different logical steps can be identifiedin the evaluation of a GCH-OSQL query.

1) Evaluation of the contents of the FROM clause: for eachobject variable there is corresponding internal variableranging on OID’s of objects of the related class. Candi-date solutions for the query can be represented as tuplesof OID’s, ranging on the corresponding class, as definedin the FROM clause.

2) Evaluation of the atemporal conditions (i.e., conditionsnot involving methods of the classesel_time, instant,duration, interval, t_o_setor of classes inheriting from

them) expressed in the WHERE clause: among allthe candidate solutions only the solutions are retainedfor which the corresponding objects satisfy atemporalconditions. In Example 3.6, the following candidatesolutions are retained, after the evaluation of atemporalconditions related to the methods HASMEMBER() ofthe classt_o_set, ands_name() of the classsymptom:

P S1 S2 S3

In our case, the object variable S3 is ranging up tonow on all the objects of classsymptombelonging tothe suitable object of classt_o_set, related to a specificpatient.

3) Evaluation of the temporal part of the content of theWHERE clause: methods related to the time-modelingclasses (see Appendix A for their formal definition)are considered. By these methods, it is possible toconsider relations between, for example, intervals givenat different granularity/indeterminacy in a seamless way.Candidate solutions are those coming from the previousstep, for which the temporal part of the condition returnsthe truth valuesTrue or Undefined. By the connec-tives MUSTBE (MAYBE) only the truth valueTrue(Undefined) is considered. In Example 3.6, candidatesolutions will be, after considering the BEFORE methodof the classinterval and the SMALLER one of the classduration:

P S1 S2 S3

4) Evaluation of the content of the TIME-SLICE clause:each valid interval of temporal objects of each candi-date solution is compared with the interval specified inthe TIME-SLICE clause. Only candidate solutions areretained, having temporal objects with the valid intervalcontained in the TIME-SLICE interval (i.e., satisfyingthe relation modeled by the DURING method). Thekeyword MUST (MAY) allows us to consider onlyobjects, for which the relation is sure (possible). InExample 3.6, candidate solutions after the TIME-SLICEevaluation are:

P S1 S2 S3

5) Evaluation of the clause MOVING WINDOW: the can-didate solutions coming from the previous steps arefinally “viewed” through a window moving along the


time axis. Among the candidate solutions, only thoseare selected for which there is a time window havingthe duration specified in the clause MOVING WIN-DOW containing the valid intervals of all their temporalobjects. To do that, an instance of the classt_o_setiscreated for each candidate solution, managing all its tem-poral objects. If the valid interval of thet_o_setinstancehas a duration smaller than the duration expressed in theMOVING WINDOW clause (i.e., satisfying the relationmodeled by the method SMALLER in classduration),the corresponding candidate solution is considered forthe final query result. The keyword MUST (MAY)allows us to consider only objects, for which the relationis sure (possible). In Example 3.6, candidate solutionsafter the MOVING WINDOW evaluation are:

P S1 S2 S3

6) Application of the methods defined in the clause SE-LECT to the suitable objects of the final candidatesolutions. In Example 3.6 methods are applied only toobjects referenced by object variables P and S3, andthe result, involving the methodsdisplay() for classesinstant, and t_o_set, is shown in Example 3.6.

H. The Application to a Clinical Database

GCH-OODM and GCH-OSQL have been used in the def-inition and development of a clinical database, containingdata coming from patients who underwent a coronary-arteryangioplasty [9]. These patients suffer from an insufficientsupply of blood to the coronary arteries due to a partial (ortotal) obstruction of some coronaric vessels. Coronary revas-cularization is performed by inflations of a balloon, placed ona suitable catheter: the catheter causes a dilation of the stenoticarea of the vessel and lets more blood through. This operation,also known as PTCA (Percoutaneous Transluminal CoronaryAngioplasty), receives more and more consensus in clinicalfield, and in a lot of cases is a valid alternative to by-passsurgery operations. Patients who have undergone this kind ofoperation are periodically followed up, to prevent sufferancefrom new stenoses or re-stenoses.

The object-oriented database containing data about this kindof patients is composed by different data categories:

• patient ID data;• auxiliary demographic data;• data related to risk factors;• data related to current and previous therapies;• data related to current and previous diagnoses;• data related to follow-up visits.

The clinical database contains some temporal objects, mod-eled through the temporal classestherapy, relative to pre-vious and current therapies,diagnosis, relative to previousand current pathologies,angio_visit, relative to parametersrecorded in a visit, as heart rate, systolic and diastolic bloodpressure, and others. The same clinical database allows alsothe integration among alpha–numeric data and related images,to manage relationships between data about observed steno-sis and angio–cardiographic images displaying stenoses, asdetailed in [34].

The database is patient-oriented: the classpatientallows theaccess to all patient data. Every object of thepatientclass canhave multiple object instances of the temporal classestherapy,diagnosis, angio_visit, managed through multiple instances ofthe t_o_setclass (or its subclasses). Fig. 4 shows the databaseschema according to a Booch-based graphical notation.

To show the GCH-OSQL expressiveness about situation ofclinical relevance, consider the following query: retrieve thename of all the patients that, after having had normal valuesof blood pressure (DBP values between 100 and 60 and SBPbetween 150 and 100) for three weeks and more, suffered fromangina, followed by PTCA intervention in 36 months. Only theperiod starting from Winter, 1988 must be considered (see thequery (CLIN_Q) at the bottom of the page).

In this GCH-OSQL query some particular features maybe noticed: i) different time granularities (years, months,days) and indeterminacy (Winter 1988) are explicitly used;ii) the MUSTBE connective allows us to verify by the prece-dence condition between angina occurrence and angioplastyintervention; iii) for temporal relations the query uses bothmethods of theinterval class (BEFORE is a method ofthis class) andt_o_set class (MANTAINS is a method ofthat class); iv) through methods of thet_o_set class it ispossible to verify some complex conditions involving objectscontained in a set (in this case that at the end of a timeperiod of at least 21 days of normal blood pressure, an

“ ” “ ”

“ ”“

”

(CLIN Q)


Fig. 4. Booch-based class diagram of the object-oriented clinical database schema. An amorphous blob (cloud) represents a class; class name is inside theblob. A using relationship is indicated by a line with an empty circle placed at one end to designate the class that uses the resources of another. A HASArelationship between classes is represented by a line with a black circle that identifies the class having the other as attribute. The cardinality is represented bythe numbers near to the lines. Continuous lines represent inheritance relationships. Arrows indicate the superclass. Blobs with thick line represent temporalclasses. Blobs with thin line represent atemporal classes. Classpersonmodels the ID data of the patient. The classpatient allows one to manage all data ofpatients. The classpatienthas some temporal sets of temporal objects, belonging, respectively, to the classestherapy, diagnosis, angio_visit. Atemporal classrisk_factoranddemographiccomplete patient’s data. The class hierarchy under the classangio_examis not represented in the figure. It refers to the databasestructure allowing the integration of data and images related to the stenosis observation (see [34] for a detailed description).

angina episode has happened); and v) the condition expressedthrough the MANTAINS5 method includes also the patientsfor which a period of 21 days of normal blood pressurehas been possible. In the Appendices, there are the formaldefinition and the notation of theinterval and t_o_setclassmethods.

IV. SYSTEM IMPLEMENTATION

GCH-OODM and GCH-OSQL are characterized by thepresence of a prototypal implementation, applied to a man-agement system of clinical histories [9], [51]. A prototype

5The MANTAINS method allows one to verify that the condition expressedas first argument is valid for all the temporal object instances whose valid timeis contained in the interval specified through the two following arguments.

of GCH-OSQL and a graphical interface have been imple-mented on a Sun workstation, in the OpenLook graphicalenvironment; the prototype is based on the ONTOS object-oriented database management system [26]. ONTOS has beenused in the implementation of the clinical database too, towhich GCH-OSQL has been applied, related to the follow-up of patients after a coronary angioplasty intervention, asdescribed in the previous section [9]. The prototype has beenevaluated on few clinical data, on which system performancesdid not show any problem; being the implementation ofthis prototype inside a project involving many different re-search areas—like image and data integration, and clinicaldata visualization—a real clinical evaluation has not yet beenperformed on the prototype. Tests performed on the prototype


Fig. 5. The architecture of the GCH-OSQL implementation. A box represents a software module. A line with arrows is for links between modules. Threedistinct software layers can be observed: the user interface SW, the temporally oriented SW, and the object-oriented database system (ONTOS). Dotted boxeshighlight different ways of grouping the modules. See the text (Section IV) for a detailed discussion of the represented system architecture.

confirmed the capability of the system to store, represent,and query the database about complex temporal features ofdata. No attention has been paid to optimize the systemperformance, being our work focused on modeling and queryexpressivity issues: some interesting future works could berelated to the definition of efficient algorithms in implementingmethods of the classt_o_set or in clustering techniquesfor temporal objects. The global dimension of executableprograms related both to the management of clinical data andto GCH-OSQL is about 7 MB. The estimated size of thedatabase is mainly due to the storage of images, as detailed in[34]: for about 50 patients, considering both temporal clinical

data and coronarographic images, the database size is ofsome 300 MB.

A. System Architecture

The system architecture is composed by different modules(Fig. 5). The global architecture of the system is client-server: two software layers, named “user interface softwarelayer” and “database layer,” compose the client; the serverconsists in the ONTOS database management system. Themodules Clinical Database Interface Managerand GCH-OSQL Interface Managercompose the “user interface soft-


Fig. 6. An example of the CompleteGuide modality in composing the query. The main window globally displays the query; some other windows help toselect a class name, during the composition of the FROM clause. The MOVING WINDOW clause is not present in the prototype version of the system.

ware layer”; they allow the user to manage, respectively,the considered clinical database and the GCH-OSQL querycomposition. Under this layer, we can observe a “databaselayer” managing both the clinical database (Clinical DatabaseManager: CDM), to insert, update, delete clinical objects, andthe query execution (GCH-OSQL Query Manager: GQM).CDM and GQM are able to interact with theData Storageand Retrieval Systemprovided by ONTOS [26]. TheOOClinical Database Schema(OOCDS) and theGCH-OODMClass Schema(GCS) contain the description of classes related,respectively, to the clinical database (e.g., classespatient,therapy) and to the temporal data model (e.g. classest_o_set,interval, el_time).

Modules of ONTOSData Storage and Retrieval System,like Database Management Tools, Class Library, and OSQL(Ontos SQL), allow the above mentioned modules to performusual database services (persistency, recovery, concurrency,query, data insertion and deletion, etc.).

The module GQM, managing GCH-OSQL queries, is able touse services provided by different modules of ONTOS. GQMis linked to the modules OOCDS and GCS, describing thestructure of classes both of clinical database and of GCH-OODM; it is partially based on the query language provided byONTOS (OSQL), but it also uses the C++-based programminglanguage to access the database.

B. The GCH-OSQL Interface

One of the goals of the prototype interface was to give usersa simple and guided approach, so that also an inexperiencedend-user can make queries syntactically and semantically right[12]. The graphical interface of GCH-OSQL proposes, then,giving a guide, to reduce orthographic mistakes, syntax errors,and those errors caused by an insufficient knowledge of the

database schema. Moreover, this interface does not limit theuser capability of queries.

During the construction of GCH-OSQL graphical interface,two different needs have been considered:

• that of an experienced end-user of the system, that onlywants a guide as support to clause compilation; this guideis also known asElementary_Guide;

• that of a naive end-user, which wants to be followedstep-by-step in making the query; this guide is alsoknown asComplete_Guide. Fig. 6 shows the graphicaluser interface provided by theComplete Guide.

The flexibility in using the interface allows a satisfying useof the system also from end-users that have different degreesof expertise between that of a naive end-user and that of anexpert end-user.

V. RELATED WORK

To highlight the original features of GCH-OSQL, somerelevant temporal query languages described in the literatureare considered. These languages are compared to GCH-OSQL,in particular to the following aspects:

a) the adopted data model;b) the supported temporal entities (intervals, instants, tem-

poral elements);c) the supported temporal dimension, according to Snod-

grass taxonomy, that identifies in temporal databasesvalid time, transaction time, user-defined time [42];

d) entities to which temporal dimension is associated (ob-ject, tuple, attribute, etc.);

e) capability of managing different levels of temporal gran-ularity and indeterminacy;

f) capability of managing uncertainty from temporal rela-tionships.


TABLE IMAIN FEATURES OF THECONSIDERED TEMPORAL QUERY LANGUAGES IN DEALING WITH GRANULARITY AND INDETERMINACY

Table I summarizes the main features of the consideredtemporal query languages.

A. The Adopted Data Model

The examined languages can be divided in two differentgroups: those based on an object-oriented data model, andthose based on a particular extension of the relational model.In the first group are TOOSQL, OODAPLEX, OOTempSQL,OQL/T, and TQL [8], [18], [36], [47], [54]. In the secondgroup are HSQL, TempSQL, TSQL, TLSQL, and TSQL2 [14],[16], [31], [38], [39], [45].

B. The Supported Temporal Entities

In the considered languages, apart from TSQL2, TOOSQL,TempSQL, and OOTempSQL, the temporal dimension, re-lated to data recorded in the database, is represented by aninterval. The interval is specified by astarting instantanda final instant; instantaneous events are represented mak-ing equals the starting and final instants. In GCH-OSQLthe interval is specified by astarting instant, a final in-stant, and aduration. This lets the wider flexibility in point-ing out beginning, ending, and duration of an interval, atthe suitable granularity or indeterminacy. Typically GCH-OSQL allows the definition of an interval duration at afiner granularity (seconds, for example), while expressingbeginning and ending instants at a coarser granularity (asdays). This capability, absent in the other considered lan-guages, suits well the clinical data management [10]. InTempSQL and OOTempSQL, an object-oriented extension ofTempSQL, temporal elementsare introduced; using a tem-poral element more disjoint intervals, identified by a start

and an end, can be referenced [8], [16]. This concept al-lows to enrich the expression of the temporal dimension, forthe part, as to say, not linked to the use of different timemeasurement units.

In GCH-OSQL the time representation is made througha predefined type hierarchy; the database designer can alsouse this type hierarchy to represent new time concepts. Thechoice of representing temporal data through predefined typesis also adopted by some query-languages based on an object-oriented model, as OQL/T, TQL, TOOSQL [18], [36], [47].In OODAPLEX time is simply one of the language types; thedatabase designer has the chance to extend the type definitionto model the temporal dimension as preferred [54]. In the otherlanguages a built-in representation of time is used, so thattemporal attributes are automatically added to tuples, as inHSQL and TSQL [31], [38], [39], or a generic representationof time through temporal elements is used, as in TempSQLand OOTempSQL, or as in TLSQL, where temporal instantsare used to represent intervals [14].

In TSQL2 some data types are introduced to model conceptssimilar to those defined in GCH-OSQL: data typesdatetime,interval, andperiodof TSQL2 correspond, respectively, to thetypes instant, duration, and interval of GCH-OSQL [45].

C. The Supported Temporal Dimension

The temporal dimension in GCH-OSQL represents the validtime, as in HSQL, TSQL, TQuery, TLSQL, OQL/T, [14],[22], [31], [38], [39], [47]. In TQL, TOOSQL, TempSQL,OOTempSQL, and TSQL2, the temporal dimension can beused to express both valid time and transaction time [8], [16],[32], [36], [45]. OODAPLEX, through the use of functions,can model both valid time and transaction time, and other tem-


poral dimension defined by the user [54]. In HSQL, throughthe hypothesis that events are recorded at the same time theyhappen, the temporal dimension represents a transaction time[38], [39].

D. Entities to Which Temporal Dimension Is Associated

In GCH-OSQL the temporal dimension is associated toobjects. The same happens in OQL/T and TQL [18], [47],where, every entity being an object in each data model,the temporal dimension is associated to objects. The tem-poral dimension is associated to tuples in HSQL, TSQL,TSQL2, and TLSQL [14], [31], [38], [39]. In TempSQLand TOOSQL, the temporal dimension is associated to at-tributes (a tuple attribute in TempSQL, an object attributein TOOSQL) [16], [36]. In OODAPLEX it is possible toassociate the temporal dimension both to attributes and objects[54]. In OOTempSQL the temporal dimension is associated toattributes; temporal attributes are represented through func-tions, that for each instant belonging to a temporal elementreturn the attribute value [8]. GCH-OSQL is as flexible asOODAPLEX in linking temporal dimension to different enti-ties, because, especially through instances of the predefinedtemporal type t_o_set, it is possible to model the time-varying properties of an object through sets of temporalobjects. Different from OODAPLEX, GCH-OSQL does notmanage the lifespan of objects, types, and of the databaseitself [54].

E. Time Granularity and Time Indeterminacy

By GCH-OSQL, the user can express temporal data andtemporal conditions at the granularity and/or indeterminacy heconsiders the best suited, from years to seconds: GCH-OSQLmanages in an homogeneous way both different granulari-ties and indeterminacy directly connected to uncertainty inthe temporal location of instants, durations, and intervals.This lets the user express data in the more suited way,depending on the precision requested to represent temporaldimension, or depending on the knowledge degree of that.A similar degree of expressiveness, at a lower level of ab-straction, is present in TLSQL, defined to manage clinicaldata [14]. In TLSQL, the granularity is at the lowest levelrequired for the application; when there is uncertainty aboutthe temporal location of a clinical event, whose temporaldimension is represented by an instant, an uncertainty intervalis used, represented through two extremes, between whichthe instant to represent is certainly contained. If the useris sure about the instant in which the event happened, thetwo extremes of the uncertainty interval meet. In most ofthe examined languages the granularity is fixed, temporaldata is always expressed with the same time unit, and theproblem of the temporal indeterminacy in locating eventson the temporal axis is not considered. In TempSQL theconcepts of partial temporal element and of partial temporalassignment are introduced, to manage incomplete information,i.e., information that exists but is unknown. By these con-cepts it is possible to distinguish when an object attributehas unknown values, when we know its values, and when

the object itself does not exist [16]. Other examined lan-guages, as HSQL, TSQL, TOOSQL, TQL, OQL/T, allow,and nothing more, the use of different time units, throughconversion operations from one unit to others [16], [18],[31], [36], [38], [39], [47]. This approach to managementof different granularities of time seems more limited thanthe one proposed in GCH-OSQL; often, in fact, the gran-ularity is, however, fixed for each temporal dimension ina certain relation [38], [39]. In other proposals only duringthe query phase it is possible to use different time measure-ment units, while during the storing phase the granularityis fixed and can’t be modified [31], [36]. In [52], [53], theauthors attempt to propose a well formed interval repre-sentation, calledhistory, of data timestamped with differentgranularities. To do that, they introduce different historicalattribute semantics; the obtained historical data is then gran-ularity independent. It is worth noting that motivation in thiswork derives from experience in designing and developingclinical databases [3].

In TSQL2 problems related to different time granularitiesand to time indeterminacy are faced [45]. TSQL2 allowsthe definition and the management of different calendars,composed by several time granularities: this topic has not beenfaced in GCH-OSQL. In representing intervals with differenttime granularities, some constraints are introduced in TSQL2on the indeterminacy of the starting and ending instants. Theseconstraints restrict the capability of representing intervalsat different and mixed granularities: it is not possible, forexample, to define in TSQL2 the interval “in 1996 for threedays.” This limitation has been removed by GCH-OSQL.

F. Managing Uncertainty from Temporal Relationships

GCH-OSQL allows the management of uncertainty com-ing from temporal relations among data defined at differentgranularities, using a three-valued logic [11] and special con-nectives (MUSTBE, MAYBE, MUST NOTBE). This aspectis not considered in the examined temporal extensions, alladopting the usual two-valued logic, but TSQL2 and, partially,TempSQL [14], [16], [17], [31], [36], [38], [39], [45].

The Gadia’s approach in [16], [17] is based on a three-valued logic too. Gadia deals with uncertainty related to theset-based relationships betweenpartial temporal elements; hefocused on the existence of a tuple (or of the values of theirattributes) in a relation more than directly with the uncertaintycoming from temporal relationships [13].

In managing uncertainty for temporal relations, TSQL2adopts a probabilistic approach: for each time point the prob-ability is given that the indeterminate instant is located atthat time point [45]. This approach leads to extend the syntaxand the semantics of TSQL2 with the concepts of credibilityand plausibility. These concepts allow one to pragmaticallymanage truth-functional conditions in the TSQL2 SELECTstatement [45].

VI. FINAL OUTLINES

In this paper, we presented a temporally-oriented object-oriented data model, GCH-OODM, and the related query


language, GCH-OSQL. GCH-OODM and GCH-OSQL areable to deal with temporal information given at differentand mixed level of granularity and/or with indeterminacy.GCH-OODM and GCH-OOSQL focus on the needs fromthe management of complex clinical data. They havebeen applied to a real clinical database, dealing withdata from follow-up patients after coronary-artery angio-plasty.

A first result of our work is related to theseamlessmanagement of temporal granularity and of temporalindeterminacy. The user can,while inserting data, specifythe temporal dimension at the level he considers thebest suited, also depending on his knowledge or on theimportance the fact has (“episode of atrial fibrillation inApril 1995, for about 30 minutes,” “heart failure on March12, 1995 at 21:30”). GCH-OSQL allows, moreover, themanagement of granularity/indeterminacyin the queries:in querying the database, it is possible to verify theexistence of temporal relations at the desired granularity,that can be different from the one used in expressing thetemporal dimension of stored data (with respect to theabove examples, queries as “find all the patients who hadhad episodes of atrial fibrillation for less than 2 hours” or“find the patients who had an heart failure in 1995” can beexpressed). Moreover, both the granularity linked to the useof different time measure unit and the indeterminacy in thetemporal location of instants and intervals are treated in aseamless way.

We faced, then, themanagement of uncertainty in tem-poral relations by a three-valued logic. Through the useof the connectives MUSTBE, MAYBE, MUSTNOTBE, itis possible to explicitly refer to only one of the valuesof this logic. By this logic, it is possible to distinguishcertain situations from possible situations, especially in com-paring temporal dimensions expressed at different granular-ity.

GCH-OSQL, finally, allows ahomogeneous managementof temporal conditions in a query. Compared to SQL,GCH-OSQL has few additional clauses: TIME-SLICE andMOVING WINDOW. Instead of adding other clauses,the temporal conditions are expressed in the WHEREclause. In fact, in GCH-OSQL there are some methodsuseful to test particular temporal conditions among theobjects stored in the database. This choice allows, more-over, to build temporal types on those predefined in thetemporal model, and to express, through them,ad hoctemporal queries, without distinguishing the user-designedtemporal conditions from those directly implemented inGCH-OSQL.

APPENDIX ATHE FORMAL DEFINITION FOR METHODS OFCLASSES

INSTANT, DURATION, INTERVAL, AND,

A. Methods of Class Instant

Let two objects of the classinstant, an ob-ject of the classgranularity, having values

; methods representing relations betweeninstants are defined as follows and are based on comparisonsof objects, returned by the methods and , ofel_timeclass, i.e., the class modeling the time axis.

.TEMP EXPR AS

• T iff AND• F otherwise

.EQUAL

• T iff ANDAND

• F iff OR

• U otherwise

The notation is a shorthand for the suitable, correspondingmethod returning the value of an object of the classel_timeat the considered granularity.

.T SPECIFIES

• T iff AND ORAND

• F iff OR ORAND

• U otherwise

.BEFORE

• T iff• F iff OR AND

AND• U otherwise

B. Methods of Class Duration

Let two objects of the classduration; an ob-ject of the classgranularity, having values

; methods representing relations betweendurations are defined as follows, similarly to what describedfor methods of the classinstant.

.TEMP EXPR AS

• iff AND• F otherwise

.EQUAL

• T iff ANDAND

• F iff OR

• U otherwise

The notation is a shorthand for the suitable, correspondingmethod returning the value of an object of the classel_timeat the considered granularity.

.T SPECIFIES

• T iff AND ORAND

• F iff OR ORAND AND NOT

• U otherwise

.SMALLER

• T iff


• F iff OR ANDAND AND NOT

• U otherwise

The part NOT , in the formula related to thetruth value False, allows us to distinguish the case of twotime spans having both the value, for which the methodSMALLER returns the truth value U.

C. Method of Class Interval

Let two objects of the classinterval; methods repre-senting relations between intervals are defined as shown at thebottom of the page.

D. Methods for Class

Let be two logical expressions, and two temporalobjects, an assigned granularity, I an object of the classt_o_set. The following methods are defined for the classt_o_set(see the top of the next page).

APPENDIX BTHE GCH-OSQL SYNTAX

This section provides a partial description of GCH-OSQLsyntax, focusing the time-related aspects of the language.Temporal methods related to classesinterval and t_o_setarehighlighted.

In the following BNF productions, the words in bold styleare keywords, contained in the language, while those in italicare particular methods, objects:

• attr_method:methods returning the displayed objectproperties;

• obj_method:methods returning an object;• temporal_obj_method:methods returning a temporal ob-

ject, with a valid time;• label: used to refer to objects instances of the class to

which is linked in the FROM clause;• class: a class defined in the database schema;• bool3_method:a method returning a bool3 type result,

through which in our model the three-valued logic isrepresented;

• temporal_array: methods returning an array of temporalobjects;

• temporal_bag:methods returning a bag of temporal ob-jects;

• temporal_list: methods returning a list of temporal ob-jects;

• temporal_set:methods returning at_o_set, set of tempo-ral objects;

• int_const, char_const:a number and a character string,respectively;

• year, year/month, : different formats used to specify atemporal instant.

(For the remainder, please see pp. 123–125.)

.TEMP EXPR AS.TEMP EXPR AS AND .TEMP EXPR AS AND

.TEMP EXPR AS.CONTEMPORARY

.EQUAL AND .EQUAL.T SPECIFIES

.T SPECIFIES AND .T SPECIFIES.BEFORE

.BEFORE.OVERLAPS

.BEFORE AND .BEFORE AND.BEFORE

.DURING.BEFORE AND .BEFORE AND

.SMALLER.STARTS

.EQUAL AND .BEFORE.FINISHES

.EQUAL AND .BEFORE.MEETS

.EQUAL AND .BEFORE.LASTS AS

.TEMP EXPR AS.LASTS LIKE

.EQUAL.DUR SPECIFIES

.T SPECIFIES.LASTS LESS

.SMALLER


I.TEMP EXPR ASI.subset , I.subset .TEM EXPR AS

I.CONTEMPORARYI.subset , I.subset .CONTEMPORARY

I.T SPECIFIESI.subset , I.subset .T SPECIFIES

I.BEFOREI.subset , I.subset .BEFORE

I.OVERLAPSI.subset , I.subset .OVERLAPS

I.DURINGI.subset , I.subset .DURING

I.STARTSI.subset , I.subset .STARTS

I.FINISHESI.subset , I.subset .FINISHES

I.MEETSI.subset , I.subset .MEETS

I.LASTS ASI.subset , I.subset .LASTS AS

I.LASTS LIKEI.subset , I.subset .LASTS LIKE

I.DUR SPECIFIESI.subset , I.subset .DUR SPECIFIES

I.LASTS LESSI.subset , I.subset .LASTS LESS

I.MAINTAINSI.subset , I.subset .DURING AND

NOT I.subset(NOT ) .DURING

query ::= SELECT selectclause FROM from clause [ where ][ time slice ] [ moving window ]

arg ::= chain attr method constant

argument ::= temporalargument bool3 cond

binary operator ::= AND OR

bool3 arg ::= obj met chain attr method constant

bool3 cond ::= bool3 cond binary operator bool3 cond( bool3 cond ) bool3 arg comp operator bool3 arg

chain ::= label.[ obj met chain ]

classlist ::= class label, classlist class label

collection chain ::= chain collection type

collection comp method ::= HAS MEMBER (temporalobject)IS EMPTY () CONTAINS ( collection chain )CONTAINED IN ( collection chain )

collection expr ::= collection expr collection op collection exprcollection chain ( collection expr )


collection method ::= temporalmethod collection comp method

collection op ::= INTERSECTION UNION MINUS

collection operation ::= collection expr . collection method

collection type ::= temporalarray temporalbagtemporallist temporalset

comp operator ::=

constant ::= int const char const

dur chain ::= int const granularity dur chainint const granularity

duration ::= dur chain dur chain , dur chainundef

end time ::= inst

from clause ::= classlist

granularity ::= yy mm dd hh min ss

inst ::= instant temp chain .start() temp chain .end()

instant ::= year year/month year/month/dayyear/month/day/houryear/month/day/hour/minuteyear/month/day/hour/minute/second

year/month/day/hour/minute/second,year/month/day/hour/minute/second

int duration ::= duration temp chain .dur()interval ::= start time , int duration

start time , end timeint duration , end time

moving window ::= MOVING WINDOW dur chain

obj met chain ::= [ obj met chain .] obj method

predicate ::= temp method collection operationarg comp operator argarg threeargsop arg AND argchain bool3 method

sel list ::= , chain attr method[ sel list ]selectclause ::= selectlistselectlist ::= chain attr method[ sel list ]

specinterval ::= FROM instant TO instantFOR dur chain TO instantFROM instant FOR dur chainFROM instant TO instant AT instant


start time ::= inst

temp chain ::= chain temporalobj method.valid interval()

temp comp method ::= TEMP EXPR AS( temporalargument )CONTEMPORARY ( temporalargument , granularity )T SPECIFIES( temporalargument )BEFORE( temporalargument )OVERLAPS( temporalargument )DURING ( temporalargument )STARTS( temporalargument , granularity )FINISHES( temporalargument , granularity )MEETS( temporalargument , granularity )LASTS AS( temporalargument )LASTS LIKE ( temporalargument , granularity )DUR SPECIFIES ( temporalargument )LASTS LESS( temporalargument )

temp method ::= temp chain . temp comp method

temporalargument ::= temp chain interval

temporalmethod ::= OCCURS( argument )TEMP EXP AS( argument , argument )CONTEMPORARY ( argument , argument )T SPECIFIES( argument , argument )BEFORE( argument , argument )OVERLAPS( argument , argument )DURING ( argument , argument )STARTS( argument , argument , granularity )FINISHES( argument , argument , granularity )MEETS( argument , argument , granularity )LASTS AS( argument , argument )LASTS LIKE ( argument , argument , granularity )DUR SPECIFIES( argument , argument )LASTS LESS( argument , argument )MAINTAINS ( argument , argument )

threeargsop ::= BETWEEN NOT BETWEEN

time slice clause ::= MUSTBE specinterval MAYBE specintervalspecinterval

time slice ::= TIME-SLICE time slice clause

whereclause ::= NOT whereclause MUSTBE whereclauseMAYBE whereclause MUST NOTBE whereclause( whereclause )

whereclause binary operator whereclausepredicate

where ::= WHERE whereclause


REFERENCES

[1] J. Allen, “Toward a general theory of action and time,”Artif. Intell.,vol. 23, pp. 123–154, 1984.

[2] J. A. Blakeley, “OQL[C++]: Extending C++ with an object query ca-pability,” in Modern Database Systems.New York: Addison-Wesley,1995, pp. 69–88.

[3] R. L. Blum, “Discovery, confirmation, and incorporation of casualrelationships from a large time-oriented clinical data base: The RXproject,” Comput. Biomed. Res.,vol. 15, no. 2, pp. 164–187, 1982.

[4] E. Braunwaldet al., “Diagnosing and managing unstable angina,” inQuick Reference Guide for Clinicians, Number 10,AHCPR Publ. no.94-0603, U.S. Dept. Health and Human Services, Public Health Service,Agency for Health Care Policy and Research and National Hearth, Lung,and Blood Institute, Rockville, MD, May 1994.

[5] S. J. Cannan and G. A. Otten,SQL—The Standard Handbook.NewYork: McGraw-Hill, 1992.

[6] A. F. Cardenas, I. T. Ieong, R. K. Taira, R. Barcher, and C. M. Breant,“The knowledge-based object-oriented PIQUERY+ language,” IEEETrans. Knowledge Data Eng.,vol. 5, no. 4, pp. 644–657, 1993.

[7] R. G. G. Cattell, The Object Database Standard: ODMG-93.SanFrancisco, CA: Morgan Kaufmann, 1996.

[8] T. S. Cheng and S. K. Gadia, “An object-oriented model for tem-poral databases,” inProc. Int. Workshop Infrastructure for TemporalDatabases,Arlington, TX, 1993, pp. N-1–N-19.

[9] C. Combi, F. Pinciroli, M. Cavallaro, and G. Cucchi, “Querying tempo-ral clinical databases with different time granularities: The GCH-OSQLlanguage,” in19th Annu. Symp. Computer Applications in Medical Care,R. M. Gardner, Ed. Philadelphia, PA: Hanley & Belfus, 1995, pp.326–330.

[10] C. Combi, F. Pinciroli, G. Musazzi, and C. Ponti, “Managing anddisplaying different time granularities of clinical information,” in18thAnnu. Symp. Computer Applications in Medical Care,J. G. Ozbolt, Ed.Philadelphia, PA: Hanley & Belfus, 1994, pp. 54–958.

[11] C. Combi, G. Pozzi, and F. Pinciroli, “Managing different time granular-ities of clinical information by an interval-based temporal data model,”Meth. Inform. Med.,vol. 34, no. 5, pp. 458–474, 1995.

[12] S. Crespi Reghizzi Sintassi, “Semantica e tecniche di compilazione,”Clup, Milan, Italy 1990 (in Italian).

[13] J. Clifford and A. Tuzhilin, Eds.,Recent Advances in TemporalDatabases. London, U.K.: Springer, 1995.

[14] A. K. Das and M. A. Musen, “A temporal query system for protocol-directed decision support,”Meth. Inform. Med.,vol. 33, pp. 358–370,1994.

[15] R. Elmasri and S. K. B. Navathe,Fundamentals of Database Systems,2nd ed. Redwood City, CA: Benjamin/Cummings, 1994.

[16] S. K. Gadia and S. S. Nair, “Temporal databases: A prelude to parametricdata,” in Theory, Design and Implementation,A. U. Tansel, J. Clifford,S. Gadia, S. Jajodia, A. Segev, and R. Snodgrass, Eds. Redwood City,CA: Benjamin/Cummings, 1993, pp. 28–66.

[17] S. K. Gadia, S. S. Nair, and Y. C. Poon, “Incomplete information inrelational temporal databases,” inProc. 18th VLDB Conf.,Vancouver,B.C., Canada, 1992, pp. 395–406.

[18] I. A. Goralwalla and M. T.Ozsu, “Temporal extension to a uniformbehavioral object model,” inProc. Int. Workshop Infrastructure forTemporal Databases,Arlington, TX, 1993, pp. Z-1–Z-9.

[19] C. S. Jensenet al., “A consensus glossary of temporal databasesconcepts,”Sigmod Record,vol. 23, no. 1, pp. 52–64, 1994.

[20] C. S. Jensen and R. Snodgrass, “Temporal specialization and general-ization,” IEEE Trans. Knowl. Data Eng.,vol. 6, no. 6, pp. 954–974,1994.

[21] M. G. Kahn and K. A. Marrs, “Creating temporal abstractions inthree clinical information systems,” in19th Annu. Symp. ComputerApplications in Medical Care,R. M. Gardner, Ed. Philadelphia, PA:Hanley & Belfus, 1995, pp. 392–396.

[22] M. G. Kahn, S. Tu, and L. M. Fagan, “TQuery: A context-sensitivetemporal query language,”Comput. Biomed. Res.,vol. 24, pp. 401–419,1991.

[23] E. T. Keravnou, Guest Editor,Artificial Intelligence in Medicine,vol. 8,no. 3, 1996, special issue onTemporal Reasoning in Medicine.

[24] W. Kim, Modern Database Systems.New York: Addison Wesley,1995.

[25] N. Kline, “An update of the temporal databases bibliography,”SigmodRecord,vol. 22, no. 4, pp. 66–80, 1993.

[26] D. Krieger and T. Andrews, “C++ bindings to an object database,”in Modern Database Systems.New York: Addison Wesley, 1995, pp.89–107.

[27] C. Larizza, C. Berzuini, and M. Stefanelli, “A general frame-

work for building patient monitoring systems,” inArtificial Intelli-gence in Medicine,P. Barahona, M. Stefanelli, and J. Wyatt, Eds.Berlin/Heidelberg: Springer-Verlag, 1995, LNAI 934, vol. 5, pp. 91–102.

[28] R. Maiocchi and B. Pernici, “Temporal data management systems: Acomparative view,”IEEE Trans. Knowl. Data Eng.,vol. 3, no. 4, pp.504–524, 1991.

[29] A. Montanari and B. Pernici, “Temporal reasoning,” inTheory, Designand Implementation,A. U. Tansel, J. Clifford, S. Gadia, S. Jajo-dia, A. Segev, and R. Snodgrass, Eds. Redwood City, CA: Ben-jamin/Cummings, 1993, pp. 534–562.

[30] S. B. Navathe and R. Ahmed, “A temporal relational model and querylanguage,”Inform. Sci.,vol. 49. no. 2, pp. 147–175, 1989.

[31] , “Temporal extensions to the relational model and SQL,” inTheory, Design and Implementation,A. U. Tansel, J. Clifford, S. Gadia,S. Jajodia, A. Segev, and R. Snodgrass, Eds. Redwood City, CA:Benjamin/Cummings, 1993, pp. 92–109.

[32] M. T. Oszu, R. Peters, D. Szafron, B. Irani, A. Lipka, and A. Mu noz,“TIGUKAT: A uniform behavioral objectbase management system,”VLDB J., vol. 4, pp. 445–492, 1995.

[33] G. Panti, “Multi-valued logics,” inHandbook of Defensible Reasoningand Uncertainty Management Systems,D. Gabbay and P. Smets, Eds.Berlin, Germany: Kluwer, 1996.

[34] F. Pinciroli, C. Combi, and G. Pozzi, “ARCADIA: A system of theintegration of angiocardiographic data and images by an object-orientedDBMS,” Comput. Biomed. Res.,vol. 28, no. 1, pp. 5–23, 1995.

[35] N. Rescher,Many Valued Logic. McGraw-Hill, 1969.[36] E. Rose and A. Segev, “TOOSQL: A temporal object-oriented query

language,” Tech. Rep. LBL 33855, 1993.[37] T. J. Ryan, J. L. Anderson, E. M. Antman, B. A. Braniff, N. H. Brooks,

R. M. Califf, L. D. Hillis, L. F. Hiratzka, E. Rapaport, B. J. Riegel, R. O.Russell, E. E. Smith, III, and W. D. Weaver, “ACC/AHA guidelines forthe management of patients with acute myocardial infarction: A reportof the American College of Cardiology/American Heart AssociationTask Force on Practice Guidelines (Committee on Management of AcuteMyocardial Infarction),”J. Amer. Coll. Cardiol.,vol. 28, pp. 1328–1428,1996.

[38] N. L. Sarda, “Extensions to SQL for historical databases,”IEEE Trans.Knowl. Data Eng.,vol. 2, no. 2, pp. 220–230, 1990.

[39] , “HSQL: A historical query language,” inTheory, Design andImplementation,A. U. Tansel, J. Clifford, S. Gadia, S. Jajodia, A. Segev,and R. Snodgrass, Eds. Redwood City, CA: Benjamin/Cummings,1993, pp. 110–140.

[40] Y. Shahar, “A knowledge-based method for temporal abstraction ofclinical data,” Ph.D. dissertation, Stanford Univ., Rep. KSL-94-64, 1994.

[41] Y. Shahar and M. A. Musen, “Knowledge-based temporal abstraction inclinical domains,”Artif. Intell. Med.,vol. 8, no. 3, pp. 267–298, 1996.

[42] R. Snodgrass and I. Ahn, “A taxonomy of time in databases,” inProc.ACM SIGMOD Int. Conf. Management of Data,Austin, TX, 1985, pp.236–246.

[43] R. Snodgrass, “The temporal query language Tquel,”ACM Trans.Database Syst.,vol. 12, no. 2, pp. 247–298, 1987.

[44] , “Temporal object-oriented databases: A critical comparison,”in Modern Database Systems.New York: Addison-Wesley, 1995, pp.386–408.

[45] R. T. Snodgrass, Ed.,The TSQL2 Temporal Query Language.Boston,MA: Kluwer, 1995.

[46] R. M. Soley and W. Kent, “The OMG object model,” inModernDatabase Systems.New York: Addison-Wesley, 1995, pp. 18–41.

[47] S. Y. W. Su and H. H. M. Chen, “Modeling and management oftemporal data in object-oriented knowledge bases,” inProceedings ofthe International Workshop on an Infrastructure for Temporal Databases,Arlington, TX, 1993, pp. HH-1–HH-17.

[48] A. U. Tansel, M. E. Arkun, and G. Ozsoyoglu, “Time-by-example querylanguage for historical databases,”IEEE Trans. Softw. Eng.,vol. 15, no.4, pp. 464–478, 1989.

[49] A. U. Tansel, J. Clifford, S. Gadia, S. Jajodia, A. Segev, and R. Snod-grass, Eds.,Temporal Databases. Theory, Design and Implementation.Redwood City, CA: Benjamin/Cummings, 1993.

[50] S. W. Tu, M. G. Kahn, M. A. Musen, J. C. Ferguson, E. H. Shortliffe,and L. M. Fagan, “Episodic skeletal-plan refinement based on temporaldata,” Commun. ACM,vol. 32, pp. 1439–1455, 1989.

[51] C. Vassilakis, P. Georgiadis, and A. Sotiropoulou, “A comparativestudy of temporal DBMS architectures,” inProc. 7th Int. Workshop onDatabase and Expert Systems Application,R. R. Wagner and H. Thoma,Eds. Los Alamitos, CA: IEEE Comput. Soc. Press, 1996, pp. 153–164.

[52] G. Wiederhold, S. Jajodia, and W. Litwin, “Dealing with granularity oftime in temporal databases,” inProc. 3rd Int. Conf. Advanced Informa-tion Systems Engineering,R. Andersonet al., Eds. Berlin/Heidelberg:


Springer-Verlag, 1991, LNCS 498, pp. 124–140.[53] G. Wiederhold, S. Jajodia, and W. Litwin, “Integrating temporal data in

a heterogeneous environment,” in[TGC+93], pp. 564–579.[54] G. T. J. Wuu and U. Dayal, “A uniform model for temporal and

versioned object-oriented databases,” inTheory, Design and Implemen-tation. Redwood City, CA: Benjamin/Cummings, 1993, pp. 230–247.

Carlo Combi (M’96) received the Laurea degreein electronics engineering and the Ph.D. degreein biomedical engineering from the Politecnico ofMilan, Italy, in 1987 and 1993, respectively.

In 1994 and 1995, he was a post-doctoral fel-low at the Department of Biomedical Engineering,Politecnico of Milan. In April, 1996, he joined theDepartment of Mathematics and Computer Scienceof the University of Udine, Italy, where he is cur-rently an Assistant Professor of Computer Science.He has published more than 70 technical papers in

refereed journals and conference proceedings. He is guest editor (with YuvalShahar, Stanford University) of a forthcoming special issue of the journalComputers in Biology and Medicineon time-oriented systems in medicine.His current research interests include temporal databases and multimediadatabases, with a special focus on clinical information.

Dr. Combi is a member of IEEE Computer Society.

Giorgio Cucchi received the Laurea degree in elec-tronics engineering from the Politecnico of Milan,Italy, in 1995.

He is currently with Sinapsi srl, Rome, Italy,and is involved in a clinical history project atNeurology department of EOC Hospital in Lugano,Switzerland, and in a multimedia clinical historyproject involving satellite transmission. His researchinterests include advanced database applications,with a special focus on temporal query languages.

Francesco Pinciroli received the Laurea degreein electronics engineering from the Politecnico ofMilan, Italy, in 1969.

He is currently Associate Professor of MedicalInformatics at the Politecnico of Milan and has anappointment at the Center for Biomedical Engineer-ing of the Italian National Research Council (CNR).He has published more than 200 technical papersin refereed journals and conference proceedings.He has been co-editor of the bookDatabases forCardiology, (Kluwer, 1991). In 1992, he was editor

of the bookInformatica di base per la Medicina(Basic Computer Science forMedicine) published in Italian by UTET. His research activities is focusedmainly in the field of biomedical signals analysis and databases appliedto Cardiology, with emphasis on quantitative electrocardiography and onmultimedia databases. In 1987, he was Associate Editor of the journalComputers in Biology and Medicine, and in 1994 he became European DeputyEditor. Since 1989, he has been a member of the Advisory Board of the journalMethods of Information in Medicine. For many years he has been member ofthe “Comit de patronage” of the journalRevue Europeenne de BiotechnologieMedicale.

Dr. Pinciroli is Vice-President of the Italian Association of Medical Infor-matics (AIIM) and is member of the Gruppo Nazionale di Bioingegneria (TheItalian National Group on Bioengineering of the Italian National ResearchCouncil). He is also an associate member of the Italian Association of HospitalCardiologists (ANMCO). He is member of Working Group 5 on “MedicalDevices” of CEN/TC251. He is President of the corresponding Italian UNIMedical Informatics Commission for standardization (UNI is the major ItalianAgency for Standards).

applying object-oriented technologies in modeling and querying temporally oriented clinical...

Documents