Temporal Queries Research Articles

The Snapshot Index: An I/O-Optimal access method for timeslice queries

We present an access method for timeslice queries that reconstructs a past state s( t) of a time-evolving collection of objects, in O ( sol log bn + ¦s(t)¦ b ) I/O's, where ¦s(t)¦ denotes the size of the collection at time t, n is the total number of changes in the collection's evolution and b is the size of an I/O transfer. Changes include the addition, deletion or attribute modification of objects; they are assumed to occur in increasing time order and always affect the most current state of the collection (thus our index supports transaction-time.) The space used is O ( n b ) while the update processing is constant per change, i.e., independent of n. This is the first I/O-optimal access method for this problem using O ( n b ) space and O (1) updating (in the expected amortized sense due to the use of hashing.) This performance is also achieved for interval intersection temporal queries. An advantage of our approach is that its performance can be tuned to match particular application needs (trading space for query time and vice versa). In addition, the Snapshot Index can naturally migrate data on a write-once optical medium while maintaining the same performance bounds.

Query languages for statistical databases

Statistical database management systems keep raw, elementary and/or aggregated data and include query languages with facilities to calculate various statistics from this data. In this article we examine statistical database query languages with respect to the criteria identified and taxonomy developed in Ozsoyoglu and Ozsoyoglu (1985b). The criteria include statistical metadata and objects, aggregation features and interface to statistical packages. The taxonomy of statistical database query languages classifies them with respect to the data model used, the type of user interface and method of implementation. Temporal databases are rich sources of data for statistical analysis. Aggregation features of temporal query languages, as well as the issues in calculating aggregates from temporal data, are also examined.

TOS

In the areas of sciences, engineering and design, the entities experience both structural and state changes. Existing database models allow changes in the structure and state through the techniques of schema evolution and version management, respectively, but fail to capture and represent both of these changes together and at the same time. In this paper we formally introduce the Temporal Object-Oriented System (TOS) which allows simultaneous changes in both the structure and state of the objects. An object in TOS is called a temporal object (TO). An aggregation of different TOs of the system can give rise to a new object which is then referred to as a temporal complex object (TCO). Both temporal objects and temporal complex objects can replace and refresh their knowledge through a process called renovation. The paper also discusses the process of renovations for both TOs and TCOs and enumerate their temporal parameters (i.e., timespan, life-span and life-sequence). A query language for the TOS, called Temporal Object Query Language (TOQL), is also proposed which is a super-set of the relational query language SQL.

Announcement—the temporal query language TSQL2 final language definition

Announcement—the temporal query language TSQL2 final language definition

SIGMOD challenges paper

Various types of computer systems are used behind the scenes in many parts of the telecommunications network to ensure its efficient and trouble-free operation. These systems are large, complex, and expensive real-time computer systems that are mission critical, and contains a database engine as a critical component. These systems share some of common database issues with conventional applications, but they also exhibit rather unique characteristics that present challenging database issues. Major DBMS issues for network management include choosing the right data model, handling two different kinds of data in terms of integrity and recovery constraints, supporting temporal queries, satisfying real-time performance and high availability requirements, and several miscellaneous issues. Some of these issues have been investigated in various areas of database researches, but most of them largely remain in the research stage. Advances in these areas that result in actual integrated implementations for data-intensive, real-time and temporal applications are eagerly awaited.

Towards an infrastructure for temporal databases

the discussion. Specifically, an initial glossary of temporal database concepts and a. test suite of temporal queries were distributed before the workshop. Both of these document*s were amended based on the analysis and critique of the workshop. A language design committee was constituted after the workshop to develop a consensus temporal query la,nguage extension to SQL-92; this design also benefited from the discussion at the workshop. This report documents the discussions and consensus reached at the workshop. The report. reflects the conclusions rea.ched at the workshop in June, 1993 and further discussions amongst the group participants through electronic mail. In preparing this report, each group coordinator assembled ideas and prepared an initial draft, which was then reviewed by a.11 the workshop participants. The record of the deliberations of these four groups, in the following four sections, forms t.he bulk of this report. Each of these sections begins with the group’s charter and a brief snapshot of the status of the field and ends with a list of follow-on efforts. The last, section identifies the workshop pa.rticipants. The full report’ provides more discussion and many additional references t,o the literature.

A Temporal Query System for Protocol-Directed Decision Support

Chronus is a query system that supports temporal extensions to the Structured Query Language (SQL) for relational databases. Although the relational data model can store time-stamped data and can permit simple temporal-comparison operations, it does not provide either a closed or a sufficient algebra for manipulating temporal data. In this paper, we outline an algebra that maintains a consistent relational representation of temporal data and that allows the type of temporal queries needed for protocol-directed decision support. We also discuss how Chronus can translate between our temporal algebra and the relational algebra used for SQL queries. We have applied our system to the task of screening patients for clinical trials. Our results demonstrate that Chronous can express sufficiently all required temporal queries, and that the search time of such queries is similar to that of standard SQL.

The design and implementation of a data extraction scheme to facilitate model-database communication

The concept of organizational decision support and the criteria for designing such support systems (ODSS) have recently received a great deal of attention. In spite of major differences among the decision processes at the organizational, group, and individual levels, the requirements for securing data from the corporate database in an ODSS still remains a significant issue. In addition, the computer and communication technologies that integrate the subsystems of knowledge, data, and models assume increased relevance in the ODSS. Indeed, the richness of problems of making the most of such technologies becomes even more important in the ODSS environment. In the present work, the issues of integrating models and databases through the use of a data extraction scheme are examined. In particular, certain aspects of the query generation algorithms that allow the user or model to view the database as a single relation are described. The generated query is then translated into TQUEL, resulting in a temporal query reflecting the historical nature of the corporate database.

Aggregates in the temporal query language TQuel

This paper defines new constructs to support aggregation in the temporal query language TQuel and presents their formal semantics in the tuple relational calculus. A formal semantics for Quel aggregates is defined in the process. Multiple aggregates; aggregates appearing in the where, when, and valid clauses; nested aggregation; and instantaneous, cumulative, moving window, and unique variants are supported. These aggregates provide a rich set of statistical functions that range over time, while requiring minimal additions to TQuel and its semantics. We show how the aggregates may be supported in an historical algebra, both in a batch and in an incremental fashion, demonstrating that implementation is straightforward and efficient.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Reverse Chaining for Answering Temporal Logical Queries

A possible structure for the past data of a partitoned temporal database is reverse field chaining. Under this technique field versions are chained by descending time. Exact analysis derives the expected number of block accesses when logical queries against a partitioned temporal database with reverse chaining are satisfied. Numerical results are given

A relational-calculus query language for historical databases

In this paper, an approach to handle time in relational query languages is outlined. The approach is based on extending Boolean and comparison operators by allowing their operands to be sets of intervals. The proposed temporal logic is shown to satisfy the properties of the normal Boolean logic. A relational-calculus query language using the extended logic is developed. The extended logic presented in this paper provides a good degree of flexibility in expressing different temporal requirements and therefore promises to be a successful approach for designing powerful temporal query languages.

Representation and compilation of knowledge in point-based temporal system

We propose a temporal model based on time points which allows one to incorporate uncertain temporal relations, absolute sense of time, and partial temporal knowledge. It also maintains the status history and is persistent with respect to its present situation. In this article, we describe how to maintain, update, and retrieve data from this point-based temporal knowledge base. Temporal knowledge is acquired through reified sentences and temporal ordering relations. the temporal knowledge is maintained in a directed graph called Minimal Temporal Network, which is represented in a matrix called Ordering Matrix. This graph is minimal because any redundancy, if there exists any, is eliminated at the update time. to maintain complete world knowledge of past and present, this temporal system works in conjunction with a situational database. A simple deduction system can reason with the situational database and the ordering matrix. Temporal ordering matrix can be constructed in O(kN2) time and any new constraint can be propagated in O(N2) time where N is the number of transitions and k is the average number of out branching factor of the temporal network. With our approach, most of the temporal queries can be answered in a constant time.

Inadequacy of interval timestamps in temporal databases

In a temporal database, the value of an attribute is timestamped to indicate its period of validity in the real world. Two data types for timestamps have evolved: an interval, and a finite union of intervals called a temporal element. The use of intervals as timestamps splits the history of an object across several first normal form (1nf) tuples, but the use of temporal elements allows the entire history of an object to be captured into a single non-1nf tuple. According to the form of the tuple thus obtained, the two approaches may be called the 1nf approach and the non-1nf approach. We believe that the latter approach is superior. The query language TQUEL, based upon the 1nf approach, is perhaps the most well known of all temporal query languages. To make a comparison between the two approaches, we introduce a non-1nf tuple calculus, called TCAL, and compare it with TQUEL. We show that the retrieve statement of TQUEL is weaker than its counterpart in TCAL. We also argue that TQUEL is not as user friendly as TCAL. Our remarks also apply to other temporal query languages, such as TSQL, where the timestamps are intervals.

Design and implementation of a temporal query language with abstract time

Temporal databases maintain not only current data of an enterprise but also the history of evolution for the current data (i.e. temporal data). In order to access an object from temporal databases, query languages should have facilities of specifying time. All users will use not only absolute time (e.g. July 1987) but also abstract time (or relative time) (e.g. last summer) for specifying the time that an event occurred. In this paper, we designed an extended temporal query language (ETQL) which supports both absolute time and abstract time specification. An introduction of the abstract time concept in the temporal query language provides users with friendliness and easiness in specifying time. The ETQL was implemented as front-end system on INGRES DBMS running under the 4.2BSD UNIX system.

Performance analysis of temporal queries

Temporal databases maintaining history data on line extend conventional databases with capabilities for historical queries and rollback operations. To analyze the performance of temporal queries on databases using various access methods, we propose a model that takes a temporal query and a database schema as input, and outputs the estimated I/O cost for the query on that database. The model consists of four transformations through a series of formal expressions characterizing all phases of query processing. We validate the model by comparing the I/O cost estimated from the model with the actual cost measured from a prototype temporal DBMS. Since conventional databases are a subset of temporal databases, the model can also be used to analyze the performance of conventional databases.

A temporal relational model and a query language

This paper proposes an extension of the relational data model for incorporating temporal semantics of the real world into a database. In this temporal relational model (TRM), the attributes are categorized as synchronous and asynchronous. This categorization leads to the notions of temporal dependency and time normal form. The imposition of time normal form avoids redundancy and retrieval and update anomalies. New relational algebra operations for this model are also discussed. A temporal query language called tsql, which is a superset of sql, has been proposed to retrieve information from time-varying relations. tsql has several new features, which provide extremely powerful query processing capabilities for time-varying relations. The model and the language have numerous applications, where data in their historical form are important.

Performance evaluation of a temporal database management system

A prototype of a temporal database management system was built by extending Ingres. It supports the temporal query language TQuel, a superset of Quel, handling four types of database static, rollback, historical and temporal. A benchmark set of queries was run to study the performance of the prototype on the four types of databases. We analyze the results of the benchmark, and identify major factors that have the greatest impact on the performance of the system. We also discuss several mechanisms to address the performance bottlenecks we encountered.