Object-oriented Query Language Research Articles

Cyclone: java-based querying and computing with Pathway/Genome databases

Cyclone aims at facilitating the use of BioCyc, a collection of Pathway/Genome Databases (PGDBs). Cyclone provides a fully extensible Java Object API to analyze and visualize these data. Cyclone can read and write PGDBs, and can write its own data in the CycloneML format. This format is automatically generated from the BioCyc ontology by Cyclone itself, ensuring continued compatibility. Cyclone objects can also be stored in a relational database CycloneDB. Queries can be written in SQL, and in an intuitive and concise object-oriented query language, Hibernate Query Language (HQL). In addition, Cyclone interfaces easily with Java software including the Eclipse IDE for HQL edition, the Jung API for graph algorithms or Cytoscape for graph visualization. Cyclone is freely available under an open source license at: http://sourceforge.net/projects/nemo-cyclone. For download and installation instructions, tutorials, use cases and examples, see http://nemo-cyclone.sourceforge.net.

A system for information management in simulation of manufacturing processes

A system has been developed to manage simulation information of manufacturing processes, such as mesh information, boundary conditions and process parameters. The goal is to enable information sharing and exchange to make it possible to simulate a whole chain of manufacturing processes, and thereby predict how a modification in one manufacturing process affects the characteristics of the final product. The system has been used to predict successful simulation of a cutting process using mesh information and process parameters. An object-relational database management system is embedded in the system that uses a conceptual EXPRESS schema as database schema. The database management system is lightweight main-memory resident and incorporates an extensible and object-oriented query language. Uniform storage using database technology enables information manipulation independently of any specific simulation tool.

Adding inclusion dependencies to an object-oriented data model with uniqueness constraints

We study an object-oriented data model that allows to express both uniqueness constraints and inclusion dependencies as semantic constraints. The data model is based on a subset of F-logic. Uniqueness constraints comprise path functional dependencies which generalise functional dependencies and reflect the navigational power of object-oriented query languages. As inclusion dependencies, we consider explicit class inclusion constraints, besides inclusions required by class hierarchies, and onto constraints that enforce reachability of objects. For these classes of semantic constraints we present an axiomatisation and prove its inference rules to be correct and complete with respect to general logical implication, leaving the decision problem open. The completeness proof combines the known construction for path functional dependencies alone with a possibly infinite model generation process to enforce onto constraints. The results prepare the grounds for normal forms in object-oriented data models and subsequently for computer aided object-oriented database design, following the decomposition approach for the relational data model. Beyond the application for schema design, the achievements could also be exploited for related tasks like semantic query optimisation and mediated data integration within a variety of graph based data models.

Using an extensible object-oriented query language in multibody system analysis

Since modern software tools produce large amounts of engineering data, the demand for efficient data management may be met by integrating database technology with engineering applications. This approach is taken in MECHAMOS, which is a previously reported system for symbolic and numeric multibody system (MBS) analysis. This work focuses on the high level analysis performed with the available query language in MECHAMOS. The data management is considerably improved in this system compared to a traditional MBS analysis tool. For instance, MECHAMOS can easily combine and compare MBS data not only within the same MBS model but also over several MBS models, each governing different equations of motion. To avoid redundant computations in such analyses a simplified materialisation mechanism is implemented. Examples are given of combining and comparing both symbolic and numeric MBS data

Query language approach based on the deductive object-oriented database paradigm

The integration of data-oriented (structural), behavioral and deductive aspects is necessary in next generation information systems. The deductive object-oriented database paradigm offers a very promising starting point for the implementation of these kinds of information systems. So far in the context of this paradigm a big problem has been the lack of a query language suitable to an ordinary end user. Typically in existing proposals for deductive object-oriented databases the user has to master well both logic-based rule formulation and object-oriented programming. In this paper we introduce a set of high-level querying primitives which increases the degree of declarativeness compared to the deductive object-oriented query languages proposed so far. In terms of these primitives it is possible to offer for end users such application-specific concepts and structures whose interpretation is obvious to users but whose specification is too demanding for them. By combining these primitives in queries the user can integrate data-oriented, behavioral and deductive aspects with each other in a concept-oriented way. Our query language approach is based on the incorporation of deductive aspects to object-orientation. Among others this means that deductive aspects of objects are inherited in the specialization/generalization hierarchy like any other properties of objects.

The CCUBE constraint object-oriented database system

Constraints provide a flexible and uniform way to represent diverse data capturing spatio-temporal behavior, complex modeling requirements, partial and incomplete information etc, and have been used in a wide variety of application domains. Constraint databases have recently emerged to deeply integrate data captured by constraints in databases. This paper reports on the development of the first constraint object-oriented database system, CCUBE, and describes its specification, design and implementation. The CCUBE system is designed to be used for the implementation and optimization of high-level constraint object-oriented query languages as well as for directly building software systems requiring extensible use of constraint database features. The CCUBE data manipulation language, Constraint Comprehension Calculus, is an integration of a constraint calculus for extensible constraint domains within monoid comprehensions, which serve as an optimization-level language for object-oriented queries. The data model for the constraint calculus is based on constraint spatio-temporal (CST) objects that may hold spatial, temporal or constraint data, conceptually represented by constraints. New CST objects are constructed, manipulated and queried by means of the constraint calculus. The model for the monoid comprehensions, in turn, is based on the notion of monoids, which is a generalization of collection and aggregation types. The focal point of our work is achieving the right balance between the expressiveness, complexity and representation usefulness, without which the practical use of the system would not be possible. To that end, CCUBE constraint calculus guarantees polynomial time data complexity, and, furthermore, is tightly integrated with the monoid comprehensions to allow deeply interleaved global optimization.

Mediator languages—a proposal for a standard

The DARPA Intelligent Integration of Information (I 3 ) effort is based on the assumption that systems can easily exchange data. However, as a consequence of the rapid development of research, and prototype implementations, in this area, the initial outcome of this program appears to have been to produce a new set of systems. While they can perform certain advanced information integration tasks, they cannot easily communicate with each other.With a view to understanding and solving this problem, there was a group discussion at the DARPA Intelligent Integration of Information/Persistent Object Bases (I 3 /POB) meeting in San Diego, in January, 1996; and a further workshop was held on this topic at the University of Maryland in April, 1996. The list of participants is in Appendix A. The idea emerging from these meeting a was not to force all systems to communicate according to specified standards, but to agree on the following:• A minimal core language, or Level 1 option, which would be a restriction of the object-oriented query language OQL, such that it will accept queries for relational databases. We recommend that all system components be able, at a minimum, to accept queries in this syntax, provided they address concepts (e.g., relations or classes, attributes or instance variables) known to that component. There must be a simple protocol to determine the schema of a system (its set of supported concepts).• A simple format for representing answers. This could also be a fragment of OQL and will be included in the core language specification.• A set of extensions, one of which could be full OQL, and would handle complex structures and abstract types (with methods). Other extensions will be needed to support rules (e.g., definitions of terms that can be shared among components), semistructured data (for self-describing objects), and shared code. A system component could support one or more of these extensions, independently, and there should be some simple protocol to determine the particular extensions that are supported.

A processing framework for object comprehensions

In order to execute database queries efficiently, they are usually translated into an algebra: a small set of operations together with some equivalences. The operations are implemented very efficiently by the database engine, and the equivalences are used to optimise the query. Since query languages for object-oriented databases are more complex than their relational counterparts, the algebra and translation, or processing framework, is more elaborate. This paper describes the processing framework for object comprehensions, a powerful object-oriented query language. Both operations and equivalences of the algebra are defined, together with a translation into it. The framework is illustrated by translating and optimising an example object comprehension query.

The CCUBE constraint object-oriented database system

Constraints provide a flexible and uniform way to represent diverse data capturing spatio-temporal behavior, complex modeling requirements, partial and incomplete information etc, and have been used in a wide variety of application domains. Constraint databases have recently emerged to deeply integrate data captured by constraints in databases. This paper reports on the development of the first constraint object-oriented database system, CCUBE, and describes its specification, design and implementation. The CCUBE system is designed to be used for the implementation and optimization of high-level constraint object-oriented query languages as well as for directly building software systems requiring extensible use of constraint database features. The CCUBE data manipulation language, Constraint Comprehension Calculus, is an integration of a constraint calculus for extensible constraint domains within monoid comprehensions, which serve as an optimization-level language for object-oriented queries. The data model for the constraint calculus is based on constraint spatio-temporal (CST) objects that may hold spatial, temporal or constraint data, conceptually represented by constraints. New CST objects are constructed, manipulated and queried by means of the constraint calculus. The model for the monoid comprehensions, in turn, is based on the notion of monoids, which is a generalization of collection and aggregation types. The focal point of our work is achieving the right balance between the expressiveness, complexity and representation usefulness, without which the practical use of the system would not be possible. To that end, CCUBE constraint calculus guarantees polynomial time data complexity, and, furthermore, is tightly integrated with the monoid comprehensions to allow deeply interleaved global optimization.

A data model for processes based on relative time

Advanced database applications such as automated manufacturing, scheduling, and computer-aided software engineering, demand an explicit representation of processes, including their decomposition into subprocesses, where subprocesses may be repeated or shared. Temporal information on these processes is inherently relative to particular temporal frames of reference, that may be different from that of a complex process containing them. We suggest the Rtime object-oriented data model in which processes are first-class citizens and complex processes are built, using standard type constructors, from their component processes. The relative timing of component processes is a key feature of the suggested model. It allows for a modular construction of complex process objects that may be repeated and shared. Standard object-oriented query languages can be used for temporal queries on processes, by providing an operator for translating timing information between different temporal frames of reference.

A computer aided system for systematic production and revision of sequence patterns.

We used two complementary fields, object-oriented databases and machine learning, to produce and revise a set of protein sequence patterns. In a first stage, we show that object-oriented query languages are well suited for the production of patterns as well as for the interpretation of the biological function of new (uncharacterized) sequences. In a second stage, a classification is built from the set of sequences according to the pattern matches. This classification may be criticized by a specific analysis method, which yields back to revise sequences and patterns. In our application, we have used concept lattices as a classification method and sequence multiple alignment for criticism.

An interface between object-oriented databases and relational databases

Currently relational databases are widely used, while object-oriented databases are emerging as a new generation of database technology. This paper presents a methodology to provide effective sharing of information in object-oriented databases and relational databases. The object-oriented data model is selected as a common data model to build an integrated view of the diverse databases. An object-oriented query language is used as a standard query language. A method is developed to transform a relational data definition to an equivalent object-oriented data definition and to integrate local data definitions. Two distributed query processing methods are derived. One is for general queries and the other for a special class of restricted queries. Using the methods developed, it is possible to access distributed object-oriented databases and relational databases such that the locations and the structural differences of the databases are transparent to users.

Object-oriented query language access to relational databases: A semantic framework for query translation

This research investigates and approach to query processing in a multidatabase system that uses an objectoriented model to capture the semantics of other data models. The object-oriented model is used to construct a global schema, defining an integrated view of the different schemas in the environment. The model is also used as a self-describing model to build a meta-database for storing information about the global schema. A unique aspect of this work is that the object-oriented model is used to describe the different data models of the multidatabase environment, thereby extending the meta database with semantic information about the local schemas. With the global and local schemas all represented in an object-oriented form, structural mappings between the global schema and each local schema are then easily supported. An object algebra then provides a query language for expressing global queries, using the structural mappings to translate object algebra queries into SQL queries over local relational schema. The advantage of using an object algebra is that the object-oriented database can be viewed as a blackboard for temporary storage of local data and for establishing relationships between different databases. The object algebra can be used to directly retrieve temporarily-stored data from the object-oriented database or to transparently retrieve data from local sources using the translation process described in this paper.

Towards an effective calculus for object query languages

We define a standard of effectiveness for a database calculus relative to a query language. Effectiveness judges suitability to serve as a processing framework for the query language, and comprises aspects of coverage, manipulability and efficient evaluation. We present the monoid calculus, and argue its effectiveness for object-oriented query languages, exemplified by OQL of ODMG-93. The monoid calculus readily captures such features as multiple collection types, aggregations, arbitrary composition of type constructors and nested query expressions. We also show how to extend the monoid calculus to deal with vectors and arrays in more expressive ways than current query languages do, and illustrate how it can handle identity and updates.

Implementation aspects of an object-oriented DBMS

This paper describes the design and implementation of an OODBMS, namely the METU Object-Oriented DBMS (MOOD). MOOD [Dog 94b] is developed on the Exodus Storage Manager (ESM) [ESM 92] and therefore some of the kernel functions like storage management, concurrency control, backup and recovery of data were readily available through ESM. In addition ESM has a client-server architecture and each MOOD process is a client application in ESM. The kernel functions provided by MOOD are the optimization and interpretation of SQL statements, dynamic linking of functions, and catalog management. SQL statements are interpreted whereas functions (which have been previously compiled with C++) within SQL statements are dynamically linked and executed. A query optimizer is implemented by using the Volcano Query Optimizer Generator. A graphical user interface, namely Mood-View [Arp 93a, Arp 93b], is developed using Motif. MoodView displays both the schema information and the query results graphically. Additionally it is possible to update the database schema and to traverse the references in query results graphically.The system is coded in GNU C++ on Sun Sparc 2 workstations. MOOD has a SQL-like object-oriented query language, namely MOODSQL [Ozk 93b, Dog 94c]. MOOD type system is derived from C++, thus eliminating the impedance mismatch between MOOD and C++. The users can also access the MOOD Kernel from their application programs written in C++. For this purpose MOOD Kernel defines a class named UserRequest that contains a method for the execution of MOODSQL statements. The MOOD source code is available both for anonymous ftp users from ftp.cs.wisc.edu and for the WWW users from the site http://www.srdc.metu.edu.tr along with its related documents.In MOOD, each object is given a unique Object Identifier (OID) at object creation time by the ESM which is the disk start address of the object returned by the ESM. Object encapsulation is considered in two parts, method encapsulation and attribute encapsulation. These encapsulation properties are similar to the public and private declarations of C++.Methods can be defined in C++ by users to manipulate user defined classes and after compilation, they are dynamically linked and executed during the interpretation of SQL statements. This late binding facility is essential since database environments enforce run-time modification of schema and objects. With our approach, the interpretation of functions are avoided thus increasing the efficiency of the system. Dynamic linking primitives are implemented by the use of the shared object facility of SunOS [Sun 90]. Overloading is realized by making use of the signature concept of C++.

Development of object-oriented database management system: OOIM

This paper describes two focal issues: visual query optimization and concurrency control in designing OOIM, which is an object-oriented database management system being developed at KAIST. The basic principles for optimization are to build a framework on a formal algebraic basis and to operate directly with graph-based query specifications. The philosophy behind these principles is to utilize existing relational technology in supporting a graph-based object-oriented query language. For concurrency control, the principles of modeling method hierarchy as a nested transaction, exploiting semantics of methods, and dynamic determination of conflicts resulting from referential sharing are used. The basic idea is to enhance the degree of concurrency without allowing a non-serializable schedule.

An Experimental Study of Object-Oriented Query Language and Relational Query Language for Novice Users

This study compares object-oriented query language (OQL) and relational query language (SQL) for novice users. The comparison focuses on the effects of different query languages on user performance for query writing task and query reading task in terms of time, confidence and accuracy. To accomplish this objective, a laboratory experiment was conducted. The results indicate that OQL subjects performed significantly better than SQL subjects for query writing in terms of time and accuracy and for query reading in terms of time, confidence and accuracy.

A heterogeneous, active database architecture for engineering data management

Abstract This paper presents an architecture for engineering data management that incorporates current work on engineering product standards as well as current work in database research. In particular, we present a framework that views an engineering design environment as an integrated, heterogeneous database system. Our integrated view of data makes use of PDES/STEP, presenting a framework for the representation of meta data that describes an object-oriented view of data and supports an object-oriented query language for the retrieval of data from multiple data sources. We also describe how the architecture makes use of active database technology to support n rule-based approach to constraint propagation and change notification. An additional aspect of the architecture presented in this paper is the design history component. We conclude by presenting an extended data management architecture that addresses the requirements for capturing information about the design process as part of the engineering data ...

On the expressive power of query languages

Two main topics are addressed. First, an algebraic approach is presented to define a general notion of expressive power. Heterogeneous algebras represent information systems and morphisms represent the correspondences between the instances of databases, the correspondences between answers, and the correspondences between queries. An important feature of this new notion of expressive power is that query languages of different types can be compared with respect to their expressive power. In the case of relational query languages, the new notion of expressive power is shown to be equivalent to the notion used by Chandra and Harel. In the case of nonrelational query languages, the versatility of the new notion of expressive power is demonstrated by comparing the fixpoint query languages with an object-oriented query language called FQL. The expressive power of the Functional Query Language FQL is the second main topic of this paper. The specifications of FQL functions can be recursive or even mutually recursive, FQL has a fixpoint semantics based on a complete lattice consisting of bag functions. The query language FQL is shown to be more expressive than the fixpoint query languages. This result implies that FQL is also more expressive than Datalog with stratified negation. Examples of recursive FQL functions are given that determine the ancestors of persons and the bill of materials.

A pattern-based object calculus

Several object-oriented database management systems have been implemented without an accompanying theoretical foundation for constraint, query specification, and processing. The pattern-based object calculus presented in this article provides such a theoretical foundation for describing and processing object-oriented databases. We view an object-oriented database as a network of interrelated classes (i.e., the intension) and a collection of time-varying object association patterns (i.e., the extension). The object calculus is based on first-order logic. It provides the formalism for interpreting precisely and uniformly the semantics of queries and integrity constraints in object-oriented databases. The power of the object calculus is shown in four aspects. First, associations among objects are expressed explicitly in an object-oriented database. Second, the nonassociation operator is included in the object calculus. Third, set-oriented operations can be performed on both homogeneous and heterogeneous object association patterns. Fourth, our approach does not assume a specific form of database schema. A proposed formalism is also applied to the design of high-level object-oriented query and constraint languages.