Object Database Development: Concepts and Principles / Edition 1

Object database development is becoming one of the best ways to build software for many advanced applications. To succeed in creating these advanced applications, we need a disciplined approach to development that is based on sound principles. This book presents the fundamental principles and concepts needed for developing advanced database applications, showing how to apply these principles successfully.

The development approach presented in this book is object oriented, but the approach allows for a broad range of target database systems. The range includes standard relational database systems, object-relational database systems, object-oriented database systems, and active database systems.

Besides being object-oriented, the approach in this book is also model driven. The underlying model, which is computationally complete, has a formal foundation rooted in mathematical model and proof theory. The model also supports multiple views, including both a graphical and textual views. Furthermore, the model is applicable over the full range of development activities, from analysis through specification, design, and implementation. This capability allows for seamless and reversible software development.

The book is aimed at both university students and sophisticated practicing professionals. University instructors can use the book to teach database application development to undergraduate students or object-oriented database theory and its application to development environments to graduate students. (See the section "Teaching from this Book" for some specific suggestions on how to organize courses with various objectives.) Practicing professionalscan read the book for a wide range of reasons, including (1) to learn a rigorous, object-oriented approach to application development, (2) to learn object-oriented design and development theory, (3) to learn about the formal foundations of database systems and languages, and (4) to use the underlying theory as a guide for developing support tools.

The book is not written for systems programmers who are implementing transaction-processing and concurrency-control systems, query optimizers, indexing and hashing schemes, or crash-recovery systems. It does not, however, ignore these underlying system components on which database applications are built. Although the main focus is on application development, the book covers each of the system components just listed in enough depth to provide sufficient understanding for platform-independent application development.

Organization and Underlying Philosophy

Prerequisites for the book include a solid introduction to programming and discrete mathematics. Ideally, the practice of programming and the theory of discrete structures would have been taught in a unified course of study. We also take this approach here, unifying theory and practice throughout the book.

The book consists of an introductory chapter and three parts: preliminaries, preparation, and production. Chapter 1, the introduction, discusses database application development in general and motivates both the book's concepts-and-principles approach to development and its development model-a conceptual model that makes it easy to describe the world as it is.

The preliminaries part of the book includes five chapters. Chapter 2 is about conceptual database fundamentals, including database abstractions and data models and languages. Chapter 3 presents system and physical database fundamentals, covering much of the underlying system-level implementation information, which is used later to motivate design decisions based on cost analyses and assumptions about the services provided by the underlying system. Chapter 4 gives a detailed description of the model used throughout the book for database application development. Chapter 5 discusses predicate calculus and other theoretical foundations of database theory. Based on this foundation, Chapter 6 shows how to formalize applications in terms of the model described in Chapter 4. Chapter 6 also uses the same formalization to give a formal definition of the model in terms of itself.

The preparation part of the book comprises five chapters, which cover analysis, specification, and design. Chapter 7 explores analysis methods, model integration, and analysis validation. It includes some new results on object-set congruency, which provide a way to measure the cohesiveness of an object-set definition and to find missing object sets of potential interest. Chapter 8 covers system boundary and interface specification and introduces a specification language for both declarative and procedural specification. The specification language is a newly developed, model-equivalent, textual language that allows specification size to scale up while remaining faithful to the underlying model.

Chapters 9 and 10 discuss data design. Although relational database textbooks base their design discussions almost exclusively on normal forms, this book takes a different approach. It does not directly introduce normal forms at all, except in the exercises. Instead, it develops a design theory systematically based on information- and constraint-preserving hypergraph transformations. This solves several of the problems that have recently caused normalization theory to fall into some disfavor. The data-design approach taken in this book does the following:

• Provides a smooth connection to analysis and specification because the model we use (unlike standard Entity-Relationship models) already is a hypergraph over object sets (that is, attributes).

• Provides an easy and systematic way to extract functional, multi-valued, and join dependencies automatically from analysis/ specification models. Too often, proponents of normalization theory have assumed that these constraints are given or are easy to obtain, but obtaining them is hard work and should not be ignored.

• Does not make the universal-relation assumption. This assumption is another often-ignored trap in applying normalization theory; in the real world, the assumption often fails. The book attacks the problem directly, showing how to resolve the issues involved.

• Develops a unified approach to dependency theory, integrating design methods based both on functional and on join dependencies as a single unified whole. Often the treatment of dependencies, although appearing unified, is almost totally disjoint.

• Introduces the notion of a trade-off between object identity and lexical identity and provides for transformations between these two representations. Usually relational discussions ignore object identity and object-oriented discussions ignore lexical identity, but there is a place for both.

• Treats the design of nested relations and complex object schemes as a natural extension of flat scheme design. It also includes a discussion of the properties of nested normal form, a new theoretical result that has not appeared in other texts. (Again, only the theory and properties are discussed as they apply to making design decisions-the normal form itself is in the exercises.)

• The design objectives for the approach are driven by time and space efficiency concerns, rather than by a desire for higher normal forms.

Chapter 11 discusses the design of object modules and shows how to integrate data design with behavior design. Continuing the design-transformation approach in Chapters 9 and 10, this chapter shows how to transform application-model hypergraphs into object modules. An object module is a generalization of the concept of an object class, as found in object-oriented languages, and it is the link to implementation. The discussion about object modules includes an exploration of the concepts of class, type, encapsulation, inheritance, and polymorphism, all of which are important for object-oriented database systems. The transformational approach then continues by showing how behavior patterns can be transformed into object modules either for single-processor database systems or for multiprocessor, distributed database systems.

The production part of the book has six chapters. Chapter 12 discusses ODMG implementation as a generic example. Chapters 13 through 17 follow with five case studies. Each of the case studies takes a problem all the way from application description to working code, using a particular database system. The case studies are small, about one thousand lines of code on average, and are representative of what might be expected of a student for a semester's project. As a group, the case studies also show an application of all the topics covered in the text, thus also serving both as a review of the material and as an illustration of the theory in practice. The chosen systems represent the range of applications for which this book has been developed, including Oracle, which represents standard relational database systems; UniSQL, which represents object-relational database systems; O2 and ObjectStore's persistent storage engine for Java, both of which represent object-oriented database systems; and Ode4.1, which represents active database systems.

We use an on-line shopping example throughout the book to illustrate system development. Chapter 4 introduces the example. The example then passes through analysis (Chapter 7), specification (Chapter 8), design (Chapters 9-11), and finally into code (Chapter 12). The example is more realistic than typical textbook development scenarios, where the thought process behind the development is mostly hidden. Usually an author has done all the work and has made all the simplifying assumptions beforehand. As presented here, the running example takes several twists and turns and has some false starts and later corrections. This is intentional. With such an approach, readers receive a more realistic view of the actualPreface vii development process. The example is not fully realistic, however, because it makes many simplifications to control the possible explosion in the number of concerns that should be fully resolved. Nevertheless, a reader should get the impression that there is much to do in order to analyze, specify, and design, as well as implement, a large project.

Teaching from this Book

This book strikes a balance between being too theoretical, on the one hand, and largely ignoring theory and its role in practice, on the other hand. In general, the main body of the text presents a rigorous and disciplined approach to application development, but largely omits theorems, except for some of the most important claims, and omits proofs. To allow for a more theoretical approach, however, the text includes numerous exercises, not only to help students understand the basic concepts presented, but also to review technical background material and to expand on theoretical ideas only claimed or briefly presented in the main body of the text. Some of the exercises are a series of learning experiences, where new concepts are introduced piecemeal and then checked in exercises. Other exercises define some of the standard concepts that have been omitted from the main body of text, such as the well-known normal forms. One of the appendices contains answers for some of the exercises, particularly for those requesting proofs of central theorems and for those that introduce new material. The exercises, especially those with answers in the book, make it possible for instructors to extend the text into areas of their particular interest and to present a more theoretical course.

This book can serve as a text for several different types of courses:

1. An upper-division course on application development for object-oriented databases.

   The focus of this course would be on application development for an object-relational or object-oriented database system such as UniSQL or O₂. No previous introduction to database systems should be necessary. Suggested coverage includes all of Chapters 1-4, a brief overview of Chapters 5 and 6, all of Chapters 7 and 8, a "cookbook" approach to Chapters 9 and 10, all of Chapters 11 and 12, and the case studies in Chapters 14-16. A similar course could be taught under the assumption that the students had already taken a standard introductory database course as a prerequisite. When taught as a second course, Chapters 2 and 3 should not be necessary, although they can serve as an excellent review. The additional time gained by not needing to cover Chapters 2 and 3 and by being able to assume that the students have already been introduced to normalization theory would make it possible to cover Chapters 9 and 10 in detail rather than by using a "cookbook" approach.

2. An upper-division course on application development for relational databases.

   The book is well suited for an introductory course on relational database systems in which application development is emphasized. Suggested coverage includes all of Chapters 1-3; Chapter 4, with an emphasis on data modeling in Section 4.1; Chapter 5 and Section 6.1, which provide the theoretical foundation for relational database systems; a brief overview of Chapters 7 and 8 on analysis and specification; a thorough study of Chapters 9 and Sections 10.1-10.7 on data design, including the supplementary exercises on relational normalization theory; and the relational database case study in Chapter 13. For a more theoretically inclined relational-database course, an instructor could spend extra time on relational calculus and Datalog in Chapter 5 and delve deeper into the properties of schemes produced from canonical hypergraphs while omitting Chapter 8 and all but Section 4.1 of Chapter 4 and Section 7.4.2 of Chapter 7. For a course more inclined toward practical application development, an instructor could cover all of Chapter 4, omit or provide only a brief overview of Chapters 5 and 6, and spend extra time on Chapter 7 and on interface forms in Chapter 8.

3. A senior or graduate-level course on application development for active databases.

   Because two-thirds of the underlying model described in the text is on active object behavior, this is an excellent text for studying the general principles of active objects, particularly active objects in database systems. Suggested coverage includes Chapters 1-3; Chapter 4, with an emphasis on behavior and interaction modeling; a brief overview of Chapter 5 for foundational material; Chapter 6, with an emphasis on dynamic and temporal formalization; Chapters 7 and 8, with an emphasis on functional specification; an overview of Chapters 9 and 10; a thorough study of Chapters 11 and 12; and the active database case study in Chapter 17.

4. A senior or graduate-level course on tools for database application development.

   The book can nicely support a course on the development of CASE tools and environments for developing database applications. The text itself suggests some tools and gives several basic algorithms that could form the basis for additional tools. Furthermore, the rigorous approach and underlying formalism provide the basis for many more tools. The course could consist of identifying and giving high-level designs for tools across the entire development spectrum, plus doing an implementation of one, or part of one, of the identified tools. The entire book can serve as background reading, but the meat of the course should emphasize Chapter 6; the congruency exercises in Chapter 7; the language in Chapter 8; the transformations in Chapters 9-11; and code generation in Chapter 12.

5. A graduate-level object-oriented database theory course.

   The formalism of the text can nicely support a graduate-level theory course. The main body of the text provides the context for the theory, including the motivation, the main flow of thought, the basic formalism, and theorems for some of the central ideas. The exercises, structured to be instructional as well as aids to learning, provide the remaining material needed for a theory course. Suggested coverage includes an in-depth study of Chapters 5, 6, 9, and 10 and the theorem-and-proof exercises in Chapter 11, and a careful reading of the proofs in the appendix containing answers for selected exercises.

Teaching material for the text is available both in the book and outside the book. Each chapter begins with a list of topics to which the reader should pay particular attention and a series of thought questions the reader should keep in mind while reading the chapter. A summary at the end of each chapter follows up on these topics and answers these questions. Included in most chapters are boxed comments that add ancillary insight and commentary. Sometimes these boxed comments are motivational, sometimes they help tie theory and practice together, and sometimes they merely add interesting comments as side notes. Instructors may choose from among the many exercises both to aid students in learning and to emphasize particular topics of interest. An appendix provides answers to selected exercises. An instructor manual contains answers to additionalx Preface exercises. The manual also contains teaching suggestions and transparency masters for Chapters 1 through 12. A World Wide Web site has an implementation for the case studies. The instructor 's manual includes one additional case study on deductive databases similar to the five case studies included in the book. There are also some tools available. These include a drawing tool to create diagrams for application models and a syntax checker for the model-equivalent language. Some tools developed as suggested for Course 4 above have also been implemented, but these tools are only available on an "as-is" basis with no assurance that they will even work. Links to all the supplements can be found on the book's official web site at ...