NSF GRANT: IIS-9811452
Alagic, Suad email: alagic@cs.usm.maine.edu
University of Southern Maine
A Family of the ODMG Object Models
AWARD ABSTRACT
The goal of this project is to provide research and technical solutions for major problems in the ODMG Standard, the currently proposed industrial standard for object-oriented databases. The main expected contributions of this project to the ODMG Standard are in the underlying type systems, the model of persistence, and the constraint language. The approach is based on establishing a well-defined family of object models replacing the existing single and inadequate ODMG Object Model. The expected results also include some implementation models and techniques applicable to the technology proposed by the ODMG Standard. As the ODMG Standard contains a binding for the Java programming language, some results of this project will also be applicable to the Java technology in general. The research team will play an active role in transferring results of this project to the ODMG by making specific proposals to the future releases of the Standard. The results of this project are intended to contribute to proliferation of a whole generation of commercial object-oriented database management systems compliant with a well-defined Standard that reflects properly the state of the object-oriented research.
http://www.cs.usm.maine.edu/~alagic/nsf_ODMG.html
Project References
S. Alagic, Type Checking OQL Queries in the ODMG Type Systems, ACM Transactions on Database Systems, 24 (3), pp. 319-360, 1999.
S. Alagic, O2 and the ODMG Standard: Do They Match?, Theory and Practice of Object Systems, 5(4), 1999.
S. Alagic, A Family of the ODMG Object Models, invited paper, Proceedings of ADBIS '99, Lecture Notes in Computer Science 1691, 1999.
S. Alagic and J. Solorzano, Java and OQL: A Reflective Solution for the Impedance Mismatch, L'objet, (6), 3, 2000.
S. Alagic and T. Nguyen, Parametric Polymorphism and Orthogonal Persistence, Proceedings of the ECOOP 2000 Symposium on Objects and Databases, Lecture Notes in Computer Science, 1813, 2001.
S. Alagic, Institutions: Integrating Objects, XML and Databases, Information and Software Techology, 2002 (to appear).
S. Alagic and S. Kouznetsova, Behavioral Compatibility of Self-typed Theories, Proceedings of ECOOP, Lecture Notes in Computer Science, 2002 (to appear).
S. Alagic, B. Cabana and J. Logan, ACID Java Transactions, 2002, submitted.
Type Checking OQL Queries in the ODMG Type Systems
Abstract
Several negative results are proved about the ability to type check queries in the only existing proposed standard for object-oriented databases. The first of these negative results is that it is not possible to type check OQL queries in the type system underlying the ODMG Object Model and its definition language ODL. The second negative result is that OQL queries cannot be type checked in the type system of the Java binding of the ODMG Standard either. A solution proposed in this paper is to extend the ODMG Object Model with explicit support for parametric polymorphism (universal type quantification). These results show that JavaTM cannot be a viable database programming language unless extended with parametric polymorphism. This is why type checking of OQL queries presents no problem for the type system of the C++ binding of the ODMG Standard. However, a type system that is strictly more powerful than any of the type systems of the ODMG Standard is required in order to properly type ordered collections and indices. The required form of polymorphism is bounded type quantification (constrained genericity) and even F-bounded polymorphism. A further result is that neither static nor the standard dynamic object-oriented type checking is possible for Java OQL. This is in spite of the fact that Java OQL combines features of two strongly and mostly statically typed languages. Contrary to one of the promises of object-oriented database technology, this result shows that the impedance mismatch does not disappear in the ODMG Standard. A type-safe reflective technique is proposed to overcome this mismatch.
O2 and the ODMG Standard: Do They Match?
Abstract
The ODMG Standard is the only existing proposed standard for object-oriented databases. The future of the Standard depends ultimately upon its acceptance by the vendors of object-oriented database management systems. This paper evaluates the level of compliance of a commercial system that played a significant role in the development of the ODMG Standard and claims ODMG compatibility. A number of thorny issues in the Standard itself are also analyzed. The analysis includes the data model and the definition language, the type system, the model of persistence, the transaction model, the query language, the C++ and JavaTM bindings.
A Family of the ODMG Object Models
Abstract
A family of the ODMG Object Models is proposed as a solution to the problems of the ODMG Standard related to the type systems, the model of persistence, and the model semantics. This family is intended to replace the existing single and inadequate ODMG Object Model. Unlike the ODMG Standard, all the models in this family are equipped with orthogonal persistence. The most basic model in the family corresponds to the JavaTM programming language. A strictly more sophisticated model features the form of parametric polymorphism suitable for object-oriented database technology. The next model in the hierarchy is equipped with type-safe reflective capabilities. The most sophisticated model is enriched with a logic-based constraint language that is completely missing from the ODMG Standard. Each model in the family is well-defined and avoids the inconsistencies of the ODMG Object Model.
The ODMG Object Model: Does it Make Sense?
This material is based upon work supported in part by the U.S. Army Research Office under grant number DAAH04-96-1-0192.
Abstract
The ODMG Object Model is shown to have a number of problems. A major confusion is caused by the intended type of polymorphism and the way it is expressed in the Model. Dynamic type checking is required even in situations when static type checking is possible. There are situations in which there is no way that type checking can determine whether a particular construct is type correct or not. The model of persistence in the ODMG Standard is not orthogonal, which has undesirable pragmatic consequences on complex objects. The discrepancies between the ODMG Object Model and the particular language bindings of the ODMG Standard are non-trivial. This paper presents solutions to some of these problems together with the associated formal system. Without such a formal system the recommended ODMG bindings are open to a wide range of different, and sometimes confusing interpretations. The criticism expressed in the paper is intended to be helpful in developing future releases of the ODMG Standard.
Parametric Polymorphism and Orthogonal Persistence
Abstract
Parametric classes come with non-trivial subtleties even in the paradigm of orthogonal persistence. Orthogonal persistence guarantees that objects of any type, including class objects, may persist. But a parametric class is not a Java type, and its class object does not exist. Further subtleties in the Java technology extended with orthogonal persistence are caused by the exist ence of both the persistent store and Java class files. Neither store was designed with parametric classes in mind. This paper presents a technique for implementing parametric classes in the Java technology extended with orthogonal persistence. The technique is based on a suitable representation of a parametric class as a Java class file, an extended class loader which handles instantiation of such a class, and an extension of the Java Core Reflection classes. Extending these final classes is a non-trivial experiment and requires complete re-compilation of the Java system. The overall effect amounts to a new Java Virtual Machine that extends the standard one. However, this extension does not affect correct performance of Java programs.
ACID Java Transactions
Abstract
A model of ACID Java transactions is presented, the basic formal properties of this model with respect to database integrity are proved, and an elaborate implementation technique is developed. No model of ACID Java transactions exists at present and certainly no implementation either. The most critical reason is that no existing model of Java transactions is capable of enforcing database integrity constraints that are specified in a declarative, possibly logic-based style, as customary in data models. The model of ACID Java transactions developed in this paper is based on the subtle interplay of constraints, bounded parametric polymorphism and orthogonal persistence. The approach is based on a correct solution for extending Java with parametric polymorphism along with a technique for integrating logic-based constraints into Java class files and class objects. The Java Core Reflection is extended accordingly. The technique for enforcing database integrity constraints is based on different levels of consistency and isolation, and it combines static and dynamic checking to attain reasonable performance.
Integrating Objects, XML and Databases
Abstract
A general model theory based on institutions is proposed as a formal framework for investigating typed object-oriented, XML and other data models equipped with integrity constraints. A major challenge in developing such a unified model theory is in the requirement that it must be able to handle major structural differences between the targeted models as well as the significant differences in the logic bases of their associated constraint languages. A distinctive feature of this model theory is that it is transformation-oriented. It is based on structural transformations within a particular category of models or across different categories with a fundamental requirement that the associated constraints are managed in such a way that the database integrity is preserved.
Behavioral Compatibility of Self-typed Theories
Abstract
The notion of self-typing is extended with the semantic constraints expressed as sentences. Specifying these behavioral properties is far beyond the expressiveness of type systems. The cornerstone of the approach is the view of classes as theories. The inheritance of class constraints is viewed as a theory morphism. The validity of the results across various possible logics for expressing class constraints is based on the object-oriented view of the notion of an institution. This view ties together the inheritance of class constraints and semantically correct object substitutability. The developed formal system is termed behavioral matching and it is proved to be an institution. Implications of this result are also analyzed.