Preface

This book is a major revision—in fact, a total rewrite—of an earlier one by the same authors. That earlier book was published by Morgan Kaufmann in 2003, under the title Temporal Data and the Relational Model. But the present book is so different from the previous one (except, to some extent, in its overall structure) that it doesn’t seem reasonable to refer to it as just a second edition. (We’ve even given it a different title, partly for that reason.) As a consequence, we won’t make any attempt in the text to call out specific points of difference with respect to that earlier book. Nor will we do what’s usually done with the preface to a new edition, which is first to repeat the preface from the previous edition and then to explain what’s changed in the new one. In other words, what you’re reading right now is, to all intents and purposes, the preface to a brand new book.

So what exactly is “temporal data”? Well, a temporal database system is one that includes special support for the time dimension; in other words, it’s a system that provides special facilities for storing, querying, and updating historical and/or future data. Database management systems (DBMSs for short) as classically understood aren’t temporal in this sense—they provide little or no special support for temporal data at all. However, this situation is beginning to change, for the following reasons among others:

■ Disks and other secondary storage media have become cheap enough that keeping large volumes of temporal data is now a practical possibility.

■ As a consequence, data warehouses have become increasingly widespread.

■ Hence, users of those warehouses have begun to find themselves faced with temporal data problems, and they’ve begun to feel the need for solutions to those problems.

■ In order to address those problems, certain temporal features have been incorporated into the most recent version of the SQL standard (“SQL:2011,” so called because it was ratified in late 2011).

■ Accordingly, vendors of conventional DBMS products have also begun to add temporal support to those products (there’s a huge market opportunity here).

Here are some examples of application scenarios where such temporal support is very definitely needed. The examples are taken, with permission, from “A Matter of Time: Temporal Data Management in DB2 10,” by Cynthia Saracco, Matthias Nicola, and Lenisha Gandhi (see Appendix F for further details):

1. An internal audit requires a financial institution to report on changes made to a client’s records over the past five years.

2. A lawsuit prompts a hospital to reassess its knowledge of a patient’s medical condition just before a new treatment was ordered.

3. A client challenges an insurance agency’s resolution of a claim involving a car accident. The agency needs to determine the policy terms that were in effect when the accident occurred.

4. An online travel agency wants to detect inconsistencies in itineraries. For example, if someone books a hotel in Rome for eight days and reserves a car in New York for three of those days, the agency would like to flag the situation for review.

5. A retailer needs to ensure that no more than one discount is offered for a given product during a given period of time.

6. A client inquiry reveals a data entry error involving the introductory interest rate on a credit card. The bank needs to correct the error, retroactively, and compute a new balance if necessary.

That same paper by Saracco, Nicola, and Gandhi also gives some indication of the development benefits to be obtained from the availability of “native” temporal support in the DBMS (IBM’s DB2 product, in the case at hand):

The DB2 temporal support reduced coding requirements by more than 90% over homegrown implementations. Implementing just the core logic in SQL stored procedures or Java required 16 and 45 times as many lines of code, respectively, as the equivalent SQL statements using the DB2 temporal features. Also, it took less than an hour to develop and test those DB2 statements. By contrast, the homegrown approaches required 4-5 weeks to code and test, and they provided only a subset of the temporal support built into DB2. Thus, providing truly equivalent support through a homegrown implementation would likely take months.

Now, research into temporal databases isn’t new—technical papers on the subject have been appearing in the literature ever since the beginning of the 1980s, if not earlier. However, much of that research ultimately proved unproductive: It turned out to be excessively complicated, or it led to logical inconsistencies, or it failed to solve certain aspects of the problem, or it was unsatisfactory for some other reason. So we’ll have little to say about that research in this book (apart from a few remarks in Chapter 19 and in the annotation to some of the references in Appendix F). Instead, we’ll focus on what we regard as a much more promising approach, one that’s firmly rooted in the relational model of data, which those others mostly aren’t, or weren’t. Of course, it’s precisely because of its strong relational foundations that we believe the approach we favor will stand the test of time (as it were!). And since the approach in question is directly and primarily due to one of the present authors (Lorentzos), the book can be regarded as authoritative.

The book also includes much original material resulting from continuing investigations by all three authors, material that’s currently documented nowhere else at all. Examples include new database design techniques; a new normal form; new relational operators; new update operators; a new approach to the problem of temporal “granularity”; and support for “cyclic point types.”1 Overall, therefore, the book can be seen as, among other things, an abstract blueprint for the design of a temporal DBMS and the language interface to such a DBMS. In other words, it’s forward looking, in the sense that it describes not only how temporal DBMSs might and do work today, but also, and more importantly, how we think they should and will work in the future.

One further point: Although this book concentrates on temporal data as such, many of the concepts are actually of much wider applicability. To be specific, the basic data construct involved is the interval, and intervals don’t necessarily have to be temporal in nature. (On the other hand, certain of the ideas discussed are indeed specifically temporal ones: for example, the notion sometimes referred to, informally, as “the moving point now.”)

Structure of the Book

The body of the book is divided into four major parts:

I. A Review of Relational Concepts

II. Laying the Foundations

III. Building on the Foundations

IV. SQL Support

To elaborate:

■ Part I (three chapters) provides a refresher course on the relational model, with the emphasis on aspects that don’t seem to be as widely appreciated as they might be. It also introduces the language Tutorial D—note the boldface name—which we’ll be using in coding examples throughout the book.

■ Part II (eight chapters) covers basic temporal concepts and principles. It explains some of the problems that temporal data seems to give rise to, with reference to queries and integrity constraints in particular, and it describes some important new operators that can help in formulating those queries and constraints. Note: We should immediately explain that those new operators are all, in the last analysis, just shorthand for certain combinations of operators that can already be expressed using the traditional relational algebra. However, the shorthands in question turn out to be extremely useful ones—not just because they simplify the formulation of queries and constraints (a laudable goal in itself, of course), but also, more importantly, because they serve to raise the level of abstraction, and hence the overall level of discourse, regarding temporal issues in general.

■ Part III (seven chapters) covers a range of more advanced temporal concepts and principles. In effect, it shows how the ideas introduced in Part II can be applied to such matters as temporal database design, temporal database updates, the formulation of temporal database constraints, and a variety of more specialized topics.

■ Part IV (one long chapter) describes the temporal features of the SQL standard.

In addition to the foregoing, there are six appendixes, covering (as appendixes are wont to do) a somewhat mixed bag of topics. Appendixes A-C discuss possible extensions to certain of the notions introduced in the body of the book. Appendix D provides an abbreviated grammar, for reference purposes, for the language Tutorial D. Appendix E discusses implementation and optimization issues. Finally, as already indicated, Appendix F gives an annotated and consolidated list of references for the entire book....