Date and Darwen intend this manifesto to be evolutionary, not revolutionary. It convincingly describes how to integrate objects and relations naturally and simply. The authors state that object technology contains exactly one unquestionably good idea (user-defined types) and one probably good idea (type inheritance) and that these ideas are completely orthogonal to the relational model. They argue that objects can be included naturally in Codd’s relational model by considering relational domains as object classes--abstract data types with relevant domain-specific operations applicable to instances of these types. They “believe that a true ‘object-relational system’ would be nothing more nor less than a true relational system--which is to say, a system that supports the relational model, with all that such support entails” (p. 22). Date and Darwen clearly explain the reasons for choosing their approaches over some other, perhaps better-known, possibilities. They also state that “much of the object literature is confused over all of the logical differences discussed…logical vs. physical, model vs. implementation, and value vs. encoding vs. appearance, as well as value vs. variable difference in particular” (p. 10). They make these distinctions clear and explicit.

The book proposes, and in fact requires, precise specifications using invariants (predicates to be satisfied at statement boundaries) as well as pre- and postconditions. The heading (specification) of a relation can be regarded as a predicate, so the relation type is a predicate; this corresponds to the definition of a type as a predicate in the international standard, the Reference Model for Open Distributed Processing (RM-ODP) [1]. The authors stress that predicates, and not names, represent the semantics of the data. For example, a tuple in a relation is interpreted as a true proposition that clearly satisfies the invariant (predicate) defining the relation type. Unfortunately, many other texts still equate “meaningful names” with semantics. The importance of collective state and behavior, as opposed to attaching state and behavior to a specific object (the message-oriented object model) is emphasized throughout.

Any type specification contains at least one possible representation. However, an actual representation provided by the type implementer may differ from any possible representation, and is hidden from both the type user and the type definer. This approach contributes to disciplined ad hoc queries and updates.

The authors stress that SQL is not the same as the relational model. They reasonably criticize SQL for excessive complexity and for inconsistencies. To deal with these SQL problems (such as NULLs), they introduce and consistently use explicit constructs.

Date and Darwen expend a considerable amount of effort in presenting a model of single and multiple subtyping and inheritance, since they consider many widely available treatments deficient, due, in particular, to incomplete, unclear, or mutually inconsistent definitions. Their model is often close to the approach used in RM-ODP, but provides much more detail; it is not clear, however, whether it includes RM-ODP types that are not templates. The “specialization by constraints” somewhat reluctantly proposed by the authors is a good approach to defining subtyping in a clean, explicit, and simple way.

Appendix B, on database design, presents some questionable ideas. It is based on an example of employees and is not convincing, since departments can hardly be considered properties of employees. Explicit use of relationships would be a much better way to resolve these design issues, and is supported by the rest of the book. In fact, the authors correctly state that “supporting relationships directly is exactly what relations do” (p. 458).

This well-written book is not for beginners or for vocational training. It is shorter and contains more food for thought than some thousand-page product-specific tomes. The book’s ideas are correct and useful, but in some cases the authors use an overly syntactic and possibly overly detailed approach to deliver their message. Approaches that stress semantics, like the RM-ODP approach, could have improved the presentation. Also, in at least one example, the authors are inconsistent: why is “status” an integer (p. 192)? Finally, expressions like “the system will know that…” are overused. The caution the authors display elsewhere would have been helpful since, from the specification viewpoint, “the system” is of no interest. The bibliography is long and interestingly annotated. I most certainly recommend this book.