Spatio-temporal databases deal with geometries changing over time. The goal of our work is to provide a DBMS data model and query language capable of handling such time-dependent geometries, including those changing continuously which describe moving objects. Two fundamental abstractions are moving point and moving region, describing objects for which only the time-dependent position, or position and extent, are of interest, respectively. We propose to represent such time-dependent geometries as attribute data types with suitable operations, that is, to provide an abstract data type extension to a DBMS data model and query language. This paper presents a design of such a system of abstract data types. It turns out that besides the main types of interest, moving point and moving region, a relatively large number of auxiliary data types is needed. For example, one needs a line type to represent the projection of a moving point into the plane, or a "moving real" to represent the time-dependent distance of two moving points. It then becomes crucial to achieve (i) orthogonality in the design of the type system, i.e., type constructors can be applied uniformly, (ii) genericity and consistency of operations, i.e., operations range over as many types as possible and behave consistently, and (iii) closure and consistency between structure and operations of non-temporal and related temporal types. Satisfying these goals leads to a simple and expressive system of abstract data types that may be integrated into a query language to yield apowerful language for querying spatio-temporal data, including moving objects. The paper formally defines the types and operations, offers detailed insight into the considerations that went into the design, and exempli es the use of the abstract data types using SQL. The paper o ers a precise and conceptually clean foundation for implementing a spatio-temporal DBMS extension.

As with relational data, XML data changes over time with the creation, modification, and deletion of XML documents. Expressing queries on timevarying (relational or XML) data is more difficult than writing queries on nontemporal data. In this paper, we present a temporal XML query language, XQuery, in which we add valid time support to XQuery by minimally extending the syntax and semantics of XQuery. We adopt a stratum approach which maps a XQuery query to a conventional XQuery. The paper focuses on how to perform this mapping, in particular, on mapping sequenced queries, which are by far the most challenging. The critical issue of supporting sequenced queries (in any query language) is time-slicing the input data while retaining period timestamping. Timestamps are distributed throughout an XML document, rather than uniformly in tuples, complicating the temporal slicing while also providing opportunities for optimization.

Abstract not found

Migrating applications from conventional to temporal database management technology has received scant mention in the research literature. This paper formally defines three increasingly restrictive notions of upward compatibility which capture properties of a temporal SQL with respect to conventional SQL that, when satisfied, provide for a smooth migration of legacy applications to a temporal system. The notions of upward compatibility dictate the semantics of conventional SQL statements and constrain the semantics of extensions to these statements. The paper evaluates the seven extant temporal extensions to SQL, all of which are shown to complicate migration through design decisions that violate one or more of these notions. We then outline how SQL--92 can be systematically extended to become a temporal query language that satisfies all three notions.

In this paper, we propose a query language and data model for spatio-temporal information, including objects of time-changing geometry.

Temporal reasoning and temporal query languages present difficult research problems of theoretical interest and practical importance. One problem is the chasm between point-based temporal reasoning and intervalbased reasoning. Another problem is the lack of robustness and universality in many proposed solutions, whereby temporal extensions designed for one language cannot be easily applied to other query languages--- e.g., extensions proposed for SQL cannot be applied to QBE or Datalog. In this paper, we provide a simple solution to both problems by observing that all query languages support (i) single-value based reasoning and (ii) aggregate-based reasoning, and then showing that these two modalities can be naturally extended to support, respectively, point-based and interval-based temporal queries. We follow TSQL2 insofar as practical requirements are concerned, and show that its functionality can be captured by simpler constructs which can be applied uniformly to Datalog, QBE and SQ...

Transactions and concurrency control are significant features in database systems, facilitating functions both at user and system level. However, the support of these features in a temporal DBMS has not yet received adequate research attention. In this paper, we describe the techniques developed in order to support transaction and concurrency control in a temporal DBMS that was implemented as an additional layer to a commercial DBMS. The proposed techniques make direct use of the transaction mechanisms of the DBMS. In addition, they overcome a number of limitations such as automatic commit points, lock release and log size increment, which are imposed by the underlying DBMS. Our measurements have shown that the overhead introduced by these techniques is negligible, less than 1% in all cases. The approach undertaken is of general interest, it can also be applied to non-temporal DBMS extensions. Key words: Data Modelling, Temporal Databases, Transactions, Concurrency control.

This paper addresses the problem of generalizing temporal data based on calendar (date and time) attributes. The proposed method is based on a domain generalization graph, i.e., a lattice defining a partial order that represents a set of generalization relations for the attribute. We specify the components of a domain generalization graph suited to calendar attributes. We define granularity, subset, lookup, and algorithmic methods for specifying generalizations between calendar domains. To reduce the size of the domain generalization graph used in generalization and the number of results shown to the user, we use six types of pruning: reachability pruning, preliminary manual pruning, data range pruning, previous discard pruning, pregeneralization manual pruning, and post generalization pruning. 1

. Temporal reasoning and temporal query languages present difficult research challenges, which are slowly yielding to the combined attack of many investigations motivated by the theoretical interest and practical import of the problem. In this paper, we subscribe to TSQL2 insofar as practical requirements for a query language are concerned, but we propose a solution that overcomes its shortcomings, particularly the lack of universality whereby TSQL2 temporal extensions can not be easily applied to other query languages, such as QBE and Datalog. In this paper, we use Datalog as a framework to develop a new language --- Temporal Data Language (TDL). To support our claim of universality, we argue that TDL constructs and semantics can be directly applied to derive temporal extensions of languages, such as QBE and SQL. Finally, we evaluate alternative approaches to the implementation of TDL, using as the basis for implementation the LDL++ system with extended aggregates developed at UCLA. ...

A new variation of Overlapping B+-trees is presented, which provides efficient indexing of transaction time and keys in a two dimensional key-time space. Modification operations (i.e. insertions, deletions and updates) are allowed at the current version, whereas queries are allowed to any temporal version, i.e. either in the current or in past versions. Using this structure, snapshot and range-timeslice queries can be answered optimally. However, the fundamental objective of the proposed method is to deliver efficient performance in case of a general pure-key query (i.e. "history of a key"). The trade-off is a small increase in time cost for version operations and storage requirements.