Building an Object-Oriented Database System

1st Edition - June 1, 1992
Authors: Francois Bancilhon, Claude Delobel, Paris Kanellakis
Language: English
Hardback ISBN:
9 7 8 - 1 - 5 5 8 6 0 - 1 6 9 - 7

Modern database and software system technology must respond to a wide variety of needs. Advanced applications such as office automation, CAD, or software engineering have new re… Read more

Building an Object-Oriented Database System

Purchase options

LIMITED OFFER

Save 50% on book bundles

Immediately download your ebook while waiting for your print delivery. No promo code is needed.

Institutional subscription on ScienceDirect

Request a sales quote

Modern database and software system technology must respond to a wide variety of needs. Advanced applications such as office automation, CAD, or software engineering have new requirements in design environments, transaction mechanisms, and data types. This comprehensive volume by designers, implementors and users covers all aspects of building an object-oriented software system from data model through system implementation, interfaces, and applications. Utilizing techniques from databases, object-oriented languages, programming environments, and user interfaces, O2 is a landmark object-oriented database system representing a new generation of database technology. This guide will help researchers, database designers, and users to assess the nature and potential of object-oriented technology for themselves.

Building an Object-Oriented Database System: The Story of 02
Edited by Francois Bancilhon, Claude Delobel, and Paris Kanellakis

Preface

Acknowledgements

Part I Introduction to Object-Oriented Database Systems

1 The Object-Oriented Database System Manifesto, by Atkinson, Bancilhon, DeWitt, Dittrich, Maier, and Zdonik
- 1 Introduction
- 2 Mandatory Features: The Golden Rules
  - 2.1 Complex Objects
  - 2.2 Object Identity
  - 2.3 Encapsulation
  - 2.4 Types and Classes
  - 2.5 Class or Type Hierarchies
  - 2.6 Overriding, Overloading, and Late Binding
  - 2.7 Computational Completeness
  - 2.8 Extensibility
  - 2.9 Persistence
  - 2.10 Secondary Storage Management
  - 2.11 Concurrency
  - 2.12 Recovery
  - 2.13 Ad Hoc Query Facility
  - 2.14 Summary
- 3 Optional Features: The Goodies
  - 3.1 Multiple Inheritance
  - 3.2 Type Checking and Type Inferencing
  - 3.3 Distribution
  - 3.4 Design Transactions
  - 3.5 Versions
- 4 Open Choices
  - 4.1 Programming Paradigm
  - 4.2 Representation System
  - 4.3 Type System
  - 4.4 Uniformity
- 5 Conclusion
- 6 Acknowledgements
- References

2 The Story of O2,, by Deux et al.
- 1 Introduction
  - 1.1 A System Overview
- 2 A Programmer's View of the System
  - 2.1 The Data Model and the Data Definition Language
  - 2.2 The O2 Languages
  - 2.3 Development and Execution Modes
  - 2.4 Distribution
- 3 Looks, the User Interface Generator
  - 3.1 Major Features of Looks
  - 3.2 A Simple Programming Example
- 4 OOPE, the Programming Environment
  - 4.1 The OOPE Design Principles
  - 4.2 The Programming Functionalities
  - 4.3 The Programming Tools
- 5 The Implementation
  - 5.1 System Decomposition and Process Layout
  - 5.2 The Schema Manager
  - 5.3 The Object Manager
- 6 Performance of the O2 Prototype
  - 6.1 Simple Tests
  - 6.2 Wisconsin Benchmark Selection Times
- 7 Conclusion
- 8 Acknowledgements
- References

Part II The O2 Data Model

3 Introduction to the Data Model, by Kanellakis, Lecluse, and Richard
- 1 Historical View of the O2 Approach
- 2 Objects Versus Values in OODBs
- 3 The O2 Data Model
  - 3.1 Values and Objects
  - 3.2 The Syntax of Types and Classes
  - 3.3 Class Hierarchy and Subtyping
  - 3.4 The Semantics of Types and Classes
  - 3.5 Methods
  - 3.6 Database Schema
  - 3.7 Instances of a Database Schema
- 4 Acknowledgements
- 5 A Roadmap for Part 2
- References

4 O2, an Object-Oriented Data Model, by Lecluse, Richard, and Velez
- 1 Introduction
- 2 Overview
- 3 Objects
- 4 Types
  - 4.1 Type Structures
  - 4.2 Methods
  - 4.3 Type Systems
- 5 Databases
- 6 Conclusion
- 7 Acknowledgements
- References

5 Object Identity as a Query-Language Primitive, by Abiteboul and Kanellakis
- 1 Introduction
  - 1.1 The Structural Part
  - 1.2 The Operational Part
  - 1.3 Expressive Power
  - 1.4 Type Inheritance
  - 1.5 Value-Based versus Object-Based
  - 1.6 Relation to O2
- 2 An Object-based Data Model
- 3 The Identity Query Language
  - 3.1 Syntax
  - 3.2 Semantics
  - 3.3 Shorthands and Examples
- 4 IQL Expressibility
- 5 The Sublanguages of IQL
- 6 Type Inheritance
- 7 A Value-based Data Model
- 8 Acknowledgements
- References

6 Method Schemas, by Abiteboul, Knallakis, and Waller
- 1 Introduction
- 2 Method Schemas
  - 2.1 Syntax
  - 2.2 Semantics
  - 2.3 Consistency
  - 2.4 Variations
- 3 Recursion-Free Schemas
- 4 Schemas with Recursion
- 5 Covariance
- 6 Practical Issues
  - 6.1 Avoiding Recursion
  - 6.2 Updates
- 7 Acknowledgements
- References

7 A Framework for Schema Updates in an Object-Oriented Database System, by Zicari
- 1 Introduction
  - 1.1 Preliminary O2 Concepts
  - 1.2 Updates: What Do We Want to Achieve?
  - 1.3 Organization of the Paper
- 2 Ensuring Structural and Behavioral Consistency
  - 2.1 Structural Consistency
  - 2.2 Behavioral Consistency
  - 2.3 The Interactive Consistency Checker
- 3 Schema Updates
  - 3.1 Changes to the Type Structure of a Class
  - 3.2 Changes to the Methods of a Class
  - 3.3 Changes tot he Class-Structure Graph
  - 3.4 Basic Schema Updates
- 4 Method Updates
  - 4.1 Adding a Method in a Class
  - 4.2 Dropping a Method from a Class
- 5 Type Updates
  - 5.1 Structural Consistency
  - 5.2 Behavioral Consistency
- 6 Class Updates
  - 6.1 Addition of Edge
  - 6.2 Removal of an Edge
  - 6.3 Addition of a Node
  - 6.4 Deletion of a Node
- 7 Implementation Issues
- 8 Related Work
- 9 Conclusion and Future Work
  - 9.1 Data Structure
  - 9.2 Update-Execution Model
  - 9.3 Object Updates
  - 9.4 High-Level Restructuring
  - 9.5 Tools
  - 9.6 Incomplete Types
- 10 Acknowledgements
- References
- Appendix: Cost Analysis
  - A.1 Architecture
  - A.2 Parameters
  - A.3 Assumptions
  - A.4 Notations
  - A.5 Costs

Part III The Languages

8 Introduction to Languages, by Bancilhon and Maier
- 1 A Brief Survey
- 2 Historical View of the O2 Approach
  - 2.1 The O2 Database Programming Language
  - 2.2 The O2 Query Language
- 3 Language Integration in OODBs
- 4 Roadmap for Part 3
- References

9 The O2 Database Programming Language, by Lecluse and Richard
- 1 Introduction
- 2 Objects and Values in O2
- 3 Types and Classes
  - 3.1 The Schema Definition Language
  - 3.2 Object Creation
  - 3.3 Naming and Persistence
- 4 Manipulation of Objects and Values
  - 4.1 Method Definition
  - 4.2 Manipulating Values
  - 4.3 Iterator
- 5 Subtyping and Inheritance
  - 5.1 Subtyping
  - 5.2 Inheritance
  - 5.3 Late Binding
- 6 Interesting Features
  - 6.1 Exceptional Attributes
  - 6.2 Exceptional Methods
- 7 Type Checking
- 8 Related Work
  - 8.1 Other OODBs
  - 8.2 Other Systems
- 9 Conclusion
- 10 Acknowledgements
- References

10 Lisp O2: A Persistent Object-Oriented Lisp, by Barbedette
- 1 Introduction
- 2 Object-Oriented Features
  - 2.1 Objects and Classes, Values and Types
  - 2.2 Inheritance
  - 2.3 Operation Implementations: Methods
  - 2.4 Object Creation: Constructor
  - 2.5 Coping with Faults: Exceptions
  - 2.6 Type-Checking Methods
- 3 Integrating Persistence Facilities in the Language
- 4 System Design
  - 4.1 The Persistent Layer
  - 4.2 The Object Layer
- 5 Related Work
- 6 Future Work
- 7 Acknowledgements
- References

11 A Query Language for O2, by Bancilhon, Cluet, and Delobel
- 1 Introduction
- 2 Object-Oriented Database System
- 3 Uses of the Query Language
  - 3.1 For Ad Hoc Queries
  - 3.2 For Access to the Database
  - 3.3 For Simple Programs
  - 3.4 For Shortcuts in the Programming Language
- 4 The Design of a Query Language
  - 4.1 Relationship with Encapsulation
  - 4.2 Data Versus Methods
  - 4.3 The Answer to a Query
  - 4.4 Integration in the Programming Language
  - 4.5 Relationship with the Type or Class System
- 5 The O2 Data Model
- 6 Design Choices
- 7 The Query Language
  - 7.1 Simple Queries
  - 7.2 Access to All Levels of a Structure
  - 7.3 Lists and Sets inside a Query?
  - 7.4 Flat and Nested Values
- 8 Semantics of the O2 Query Language
- 9 Other Query Languages
  - 9.1 The Query Language for Orion
  - 9.2 OSQL, the Iris Query Language
  - 9.3 The Query Language for Exodus
  - 9.4 Two Query Languages for O2
- References

12 Reloop, and Algebra-Based Query Language for O2 , by Cluet, Delobel, Lecluse, and Richard
- 1 Introduction
- 2 An Example
  - 2.1 The Designer's View
  - 2.2 The User's View
- 3 Design Issues
  - 3.1 Classes and Encapsulation
  - 3.2 Values
- 4 The Reloop Language
- 5 Reloop Semantics through an Algebra
  - 5.1 The Algebra Operators
  - 5.2 Reloop Semantics
- 6 Translation from Reloop to CO2
  - 6.1 The CO2 Language
  - 6.2 The Macro-Algebra
- 7 Conclusion
- 8 Acknowledgements
- References
- Appendix: Construction of the Algebraic Macro-Operators
  - A.1 The ( Operator
  - A.2 The U+ Operator

13 Using Database Applications to Compare Programming Languages, by Gamerman, Lanquette, and Velez
- 1 Introduction
- 2. The Applications
  - 2.1 The Bill of Materials Application
  - 2.2 The Unix Mail Application
- 3 C+ SQL
  - 3.1 Developing the Bill of Materials Application in C+SQL
  - 3.2 Developing the Unix Mail Application in Basic
  - 3.3 Conclusions
- 4 Basic-Pick
  - 4.1 Developing the Bill of Materials Application in Basic
  - 4.2 Developing the Unix Mail Application in Basic
  - 4.3 Conclusions
- 5 Prolog
  - 5.1 Developing the Bill of Materials Application in Prolog
  - 5.2 Developing the Unix Mail Application in Prolog
  - 5.3 Conclusions
- 6 Smalltalk-80
  - 6.1 Developing the Bill of Materials Application in Smalltalk-80
  - 6.2 Developing the Unix Mail Application in Smalltalk-80
  - 6.3 Conclusions
- 7 The O2 System
  - 7.1 Developing the Bill of Materials Application in O2
  - 7.2 Developing the Unix Mail Application in O2
  - 7.3 Conclusions
- 8 Conclusions
  - 8.1 Development Time
  - 8.2 Code Size
  - 8.3 Number of Variables
  - 8.4 Conformity to Specifications
  - 8.5 Other Aspects
  - 8.6 General Conclusion
- 9 Acknowledgements
- References

Appendix: The Programs
- A.1 The C+SQL Programs
- A.2 The Basic Programs
- A.3 The PROLOG Programs
- A.4 The Smalltalk-80 Programs
- A.5 The O2 Programs

Part IV The System

14 Introduction to the System, by Delobel and Velez
- 1 The Functionality of an Object Manager
  - 1.1 Direct Support for the Data Model
  - 1.2 Efficient Access to Objects
  - 1.3 Variations in Object Size
  - 1.4 Persistence of Objects between Program Executions
  - 1.5 Database Distribution
  - 1.6 Transaction Processing
  - 1.7 Database Versions
- 2 Historical View of the O2 Approach
  - 2.1 the V0 Object Manager
  - 2.2 The V1 Object Manager
- 3 The Capabilities of the O2 System
  - 3.1 Data Model and Large Objects
  - 3.2 Efficient Access to Objects
  - 3.3 Persistence
  - 3.4 Database Distribution
  - 3.5 Transactions and Concurrency
  - 3.6 Database Versions
- 4 A Roadmap for Part 4
- References

15 The O2 Object Manager: An Overview, by Velez, Bernard, and Darnis
- 1 Introduction
- 2 Functional Requirements
  - 2.1 Data Model Requirements
  - 2.2 Application Requirements
  - 2.3 Architectural Requirements
- 3 Main Design Choices
  - 3.1 Modes of Operation
  - 3.2 Handling Distribution
  - 3.3 Object Access
  - 3.4 Object Representation
  - 3.5 Persistence
  - 3.6 Clustering on Disk
  - 3.7 Handling Concurrency at the O2 Level
- 4 Overview of the System
  - 4.1 The System Interface Module
  - 4.2 The Memory-Management Module
  - 4.3 The Communication Manager
- 5 Comparison with Related Work
  - 5.1 GemStone
  - 5.2 Orion
- 6 Conclusions and Future Work
- 7 Acknowledgements
- References

16 Handling Distribution in the O2 System, by Bernard and Stève
- 1 Introduction
- 2 Overall Design of the Distribution
  - 2.1 Workstation/Server Task Assignment
  - 2.2 Tasks Involved in Distribution
- 3 Object-Transfer Protocol
  - 3.1 Presentation Protocol
  - 3.2 Minimizing the Number of Messages
  - 3.3 Minimizing the Number of Memory Copies
  - 3.4 Serializing and Deserializing Data
- 4 The Execution-Transfer Protocol
  - 4.1 Decoupling from Transport Protocol
  - 4.2 Orphan Detection
  - 4.3 Embedded Calls
  - 4.4 Coherence between the Two Sites
  - 4.5 Argument Passing
- 5 Workstation/Server Interactions
  - 5.1 Synchronous Interactions
  - 5.2 Asynchronous Interactions
- 6 Fault Tolerance
  - 6.1 Processes Involved in O2
  - 6.2 Starting O2 from a Workstation
  - 6.3 Handling Abnormal Process Terminations
- 7 Related Work
- References

17 Clustering Strategies in O2: An Overview, by Benzaken, Delobel, and Harrus
- 1 Introduction
- 2 The O2 Clustering Strategies
  - 2.1 Placement Trees
  - 2.2 A Clustering Algorithm
- 3 Self-adaptative Clustering Strategies
  - 3.1 Definition of Good Placement Trees
  - 3.2 Simplifying Assumptions
  - 3.3 Cost Function
  - 3.4 Automatic Derivation of Placement Trees
- 4 Performance Measurements
  - 4.1 Early Measurements
  - 4.2 From Hypermodel to CluB-0
- 5 Conclusion
- 6 Acknowledgements
- References

18 Three Alternative Workstation-Server Architectures, by DeWitt, Futtersack, Maier, and Velez
- 1 Introduction
- 2 The Three Workstation-Server Architectures
  - 2.1 The Object-Server Architecture
  - 2.2 Page-Server Architecture
  - 2.3 The File-Server Architecture
- 3 Prototyping the Workstation-Server Architectures
  - 3.1 File Server
  - 3.2 Page Server
  - 3.3 Object Server
  - 3.4 Concurrency Control and Recovery
- 4 The Altair Complex-Object Benchmark
  - 4.1 Database Design
  - 4.2 Queries
  - 4.3 Benchmark Organization
- 5 Performance Evaluation
  - 5.1 Test Environment
  - 5.2 Database Build Time
  - 5.3 Clustering and Smearing Tests
  - 5.4 Impact of Workstation Buffer Space
- 6 Related Work
- 7 Conclusions
- 8 Acknowledgements
- References

19 Consistency of Versions in Object-Oriented Databases, by Cellary and Jomier
- 1 Introduction
- 2 The Database-Version Approach
- 3 Object-Version Identification
- 4 Operating on Objects
  - 4.1 Reading
  - 4.2 Updating
  - 4.3 Deletion
  - 4.4 Creation
- 5 Concurrency Control
- 6 Version Management of Composite Objects
- 7 Conclusions
- 8 Acknowledgements
- References

20 Integrating Concurrency Control, by Cart and Ferrie
- 1 Introduction
- 2 User Transactions and O2 Objects
  - 2.1 Representation of O2 Objects
  - 2.2 Hierarchy of Abstraction Levels
- 3 Constraints upon Concurrency
  - 3.1 Classification of Methods on Classes and Instances
  - 3.2 Compatibility of Methods
  - 3.3 Access Control of Classes and Instances
  - 3.4 Creation and Deletion of Instances
  - 3.5 Creation and Deletion of Classes
- 4 Object and Operation Properties Exploited by CC
  - 4.1 Primitive and Constructed Objects
  - 4.2 Compatibility and Commutativity between Operations
  - 4.3 Independence of Objects at the Same Abstraction Level
- 5 Impact of a One-level Transaction Model
  - 5.1 Physical Locking
  - 5.2 Physical and Logical Locking
- 6 Impact of a Multilevel Transaction Model
  - 6.1 Necessity of Object Independence
  - 6.2 Multilevel Two-phase Locking
  - 6.3 Exploiting Method Commutativity
- 7 Conclusion
- 8 Acknowledgements
- References

Part V The Programming Environment

21 Introduction to the Programming Environment, by Delobel, Kanellakis, and Plateau
- 1 The Technical Challenges
  - 1.1 Interaction between User and Database
  - 1.2 The Software Engineering Problems
- 2 Historical View of the O2 Approach
- 3 A Roadmap for Part 5
- References

22 Building User Interfaces with Looks, by Plateau, Borras, Leveque, Mamou, and Tallot
- 1 Introduction
  - 1.1 Existing User-Interface Tools
  - 1.2 Looks
- 2 The Looks Data Model
- 3 Main Features of Looks
  - 3.1 Generic Presentations
  - 3.2 Editing Presentations
  - 3.3 Masks
  - 3.4 Placements
  - 3.5 Modes
  - 3.6 Links
  - 3.7 Interactive Method Activation
  - 3.8 Specific Presentations
- 4 A Programming Example
- 5 Conclusion
- References

23 The O2 Programming Environment, by Borras, Doucet, Pfeffer, and Tallot
- 1 Introduction
- 2 Design Principles
- 3 Programming with OOPE
  - 3.1 Programming Tools
  - 3.2 A Tour with OOPE
- 4 Related Work
- 5 Implementation Choices and Future Improvements
- 6 Conclusion
- 7 Acknowledgements
- References

24 Using a Database System to Implement a Debugger, by Doucet and Pfeffer
- 1 Introduction
- 2 The Compiling Process
- 3 The O2 Debugger
  - 3.1 Information Managed by Debuggers
  - 3.2 The O2 Debugger Architecture
  - 3.3 The O2 Debugger Paradigm
- 4 The Symbol Database
  - 4.1 Fine Granularity
  - 4.2 Creation of a Symbol Database
  - 4.3 Structure of a Symbol Database
- 5 Database Management during the Debugger Process
  - 5.1 Dynamic Binding
  - 5.2 Management of the Execution Stack
- 6 Evaluation of Gains
  - 6.1 Performance Gain
  - 6.2 Space Gain
  - 6.3 Functionality Gain
- 7 Related Work
  - 7.1 A Similar Symbol Table Organization
  - 7.2 Debuggers That Use a Database
- 8 Conclusion and Future Work
- 9 Acknowledgements
- References

25 Incremental Compilation in O2, by Larcheveque
- 1 Introduction
- 2 A Survey of Language-based Editors
- 3 Main Functionalities
  - 3.1 Programs and Applications
  - 3.2 User Interaction
- 4 The Semantic Component
  - 4.1 Code Generation
  - 4.2 Parse-time Semantic Actions
- 5 The Syntactic Component
  - 5.1 Conventions
  - 5.2 Requirements and Assumptions for the Incremental Parser
  - 5.3 Extended Example
  - 5.4 Augmenting the Parser for Optimal Context Reuse
  - 5.5 Adding Flexibility to the Parser
- 6 Further Research
- References

26 Self-explained Toolboxes, by Arango
- 1 Introduction
- 2 The Toolbox Approach
  - 2.1 What Is a Toolbox?
  - 2.2 Class Identification
  - 2.3 Classification of Operations
- 3 The Business-Application Toolbox
  - 3.1 The Learning Mechanism
  - 3.2 Using the Toolbox
  - 3.3 Extending the Toolbox
- 4 Conclusions
- 5 Acknowledgements
- References

Part VI Examples of O2 Applications

27 A Guided Tour of an O2 Application, by Grosselin and James
- 1 The Altair Travel Agency
- 2 Displays and Data Capture
- 3 The O2 Query Language
- 4 Multimedia Objects
- 5 The O2 Programming Environment

28 Geographic Applications: An Experience with O2, by Scholl and Voisard
- 1 Introduction
- 2 Map Model and Query Language
  - 2.1 The Map Model
  - 2.2 Examples of Queries on Maps
- 3 Architecture of the Prototype
  - 3.1 Available Functionalities
  - 3.2 Architecture
- 4 Implementation of the Map Level
  - 4.1 Expressive Power of the O2 Query Language
  - 4.2 Integration of the O2 Query Language
  - 4.3 Implementing Generic Relational-Algebra Operations
  - 4.4 Design of a Query Language
  - 4.5 Current Implementation
- 5 Implementation of Geometric Functions
  - 5.1 Queries
  - 5.2 Structure
  - 5.3 Methods
- 6 The User Interface
  - 6.1 Functionalities of the Interface
  - 6.2 Current Implementation
- 7 Conclusion
- 8 Acknowledgements
- References

Appendix I: An O2 Schema for the Geometry of a Map

Appendix II: Extension of CO2 for Implementing Relational

Operations

Index