An object-oriented, declarative, statically typed and temporal language system is presented. What makes this system very different from the currently prevailing strongly typed procedural object-oriented language systems is that methods are specified in a high-level, constraint sublanguage. The constraint sublanguage is based on a particular temporal paradigm, which has an execution model as well as the formal, initial model semantics. This constraint language system is seen as a non-traditional component of a sophisticated, typed object-oriented programming environment. It complements the procedural object-oriented languages in the areas of prototyping, simulation and databases. The paper covers the core ideas, the programming methodology, the type system, and the implementation techniques. Possible concurrent extensions and the limitations of the system are also discussed.

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 Java cannot be a viable database programming language unless extended with parametric polymorphism. This is why type-checking 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 collectgions 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, 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 for overcoming this mismatch.

A number of inadequacies of existing implementation techniques for extending Java™ with parametric polymorphism are revealed. Homogeneous translations are the most space-efficient but they are not compatible with reflection, some models of persistence, and multiple dispatch. Heterogeneous translations, on the other hand, can potentially produce large amounts of redundant information. Implementation techniques that address these concerns are developed. In languages that support run-time reflection, an adequate implementation of parametric, bounded and F-bounded polymorphism is shown to require (reflective) run-time support. In Java, extensions to the core classes are needed. This is in spite of the fact that parametric polymorphism is intended to be managed statically.

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.

The modification of Pascal proposed in the paper is based on the relation type which combines the properties of the set type and the file type of Pascal and includes properly these two Pascal types. The relation type is equipped with both high level (set oriented) relational operations and low level primitives for operating on particular tuples of relations. Within the relational framework a novel and unified treatment of images and base relations is given. This approach permits isolation of those issues in optimisation and decomposition which can be treated independently of the details of the procedural decomposition, clarifies and simplifies the decomposition problem. The proposed programming language is smaller and simpler than Pascal and still very powerful in handling relational data bases. Examples of nonprocedural and procedural decomposition are presented in order to demonstrate the suitability of the proposed features and their implications on the architecture of the supporting system.