HISTORICAL BACKGROUND There are applications that require the recording and management not only of data but also of the time during which this data is valid. A typical example is the data maintained by pension and life insurance organizations, for these organizations to determine the benefits, a person qualifies for. Similarly, such organizations have to record their financial obligations at various time periods in the future. In the case of a relational model, every tuple in a relation contains not only ordinary data (e.g. Id and various attributes) but also the time period during which this data is valid. There are however many practical problems, outlined below, which cannot be faced directly by the use of a conventional Database Management System (DBMS). As a consequence, much programming is required. Hence, the satisfaction of actual user requirements necessitated the definition of a period-stamped temporal model. The bulk of research, on the definition of such a model, appeared in the 80’s, at a time when powerful computers could process big volumes of data.

In this paper we present the first data structure for partially persistent B-trees with constant worst-case update time, where deletions are handled in a symmetrical to insertions manner. Our structure matches the query times of optimal partially persistent B-trees that do not support constant update time thus, we have managed to reduce the worst-case update time to a constant, without a penalty in the query times. The new data structure is produced by mixing two other data structures, (a) the partially persistent B-tree and (b) the balanced search tree with constant worst-case update time.

The PACK and UNPACK operators provide the basis for greatly simplifying the formulation of certain kinds of queries that arise frequently in the temporal context, but there’s still room for further improvement. With such considerations in mind, this chapter shows how the familiar operators of the relational algebra can all be generalized appropriately, as U_ operators. To be specific, it discusses U_ versions of the familiar dyadic operators (UNION, INTERSECT, MINUS, D_UNION, I_MINUS, JOIN, MATCHING, NOT MATCHING); the n-adic operators (UNION, INTERSECT, D_UNION, JOIN); and the monadic operators (restrict, project, EXTEND, GROUP, UNGROUP). It also discusses U_ comparison operators. It concludes with an examination of the intuition underlying all of these new operators.

This chapter focuses on the logical difference between relation values (relations) and relation variables (relvars). In particular, it discusses and explains a variety of concepts and properties that are widely thought of as applying to relations as such but in fact don’t—they apply to relvars instead. The concepts in question include relational assignment (the well known shorthands INSERT, DELETE, and UPDATE in particular, also the less well known shorthands D_INSERT and I_DELETE); keys and foreign keys; key constraints, foreign key constraints, and other integrity constraints; The Golden Rule; and base vs. virtual relvars (views). The chapter concludes by defining and discussing the relational model as such.

This chapter describes and illustrates a set of generic, read-only operators on relations that together constitute what’s called the relational algebra. The algebraic closure property is explained and its significance discussed in detail. Operators described include RENAME, restrict, project, UNION, INTERSECT, MINUS, JOIN, TIMES, MATCHING, NOT MATCHING, EXTEND (two versions), GROUP, and UNGROUP. Image relations are explained, including in particular a discussion of their usefulness in formulating summarization queries. Relational comparisons (relation equality, relation inclusion, etc.) are discussed, as are primitive operations and the important notion of relational completeness. The use of WITH in formulating complicated expressions one step at a time is illustrated.

This chapter introduces a convenient informal notation for points and intervals and for some of the most fundamental operators on such points and intervals: first, last, next, prior, BEGIN, END, PRE, POST, and so on. Using that notation, it then defines and illustrates a collection of generic comparison operators for intervals, known generically as Allen’s operators: interval equality, interval inclusion and proper inclusion, BEFORE and AFTER, OVERLAPS, MEETS, MERGES, and BEGINS and ENDS. Using these operators, the chapter then goes on to define interval analogs of the well known set theory operators UNION, INTERSECT, and MINUS. Finally, it shows how all of these operators can be used to help with the practical problem of formulating queries.

Although the concept of packing and unpacking relations is essentially straightforward (at least when the operation is performed on the basis of just a single interval attribute), it turns out that the concept has a variety of implications and ramifications—not all of which are immediately obvious—when the operation is performed on the basis of N such attributes when N is not equal to 1. This chapter investigates such matters in depth. In particular, it shows how those investigations lead to an important concept of equivalence among relations and to a novel concept of redundancy in relations with interval attributes.

This chapter discusses a number of miscellaneous issues arising from the fundamental interval type notion and the related point type notion. First, it considers the possibility of supporting several distinct successor functions for “the same” point type; in particular, it shows how the concept of type inheritance can be used to support that possibility. It also considers the pragmatically important special case of intervals defined over points of type NUMERIC(p,q) for some precision p and scale factor q. This latter discussion leads to the need to extend the type inheritance concepts already discussed to deal with multiple inheritance. The chapter also revisits the notion of granularity from Chapter 4 and considers how that notion relates to the more familiar notion of scale.