Object-oriented Database Applications Research Articles

Generating application-specific data layouts for in-memory databases

Database applications are often developed with object-oriented languages while using relational databases as the backend. To accelerate these applications, developers would manually design customized data structures to store data in memory, and ways to utilize such data structures to answer queries. Doing so is brittle and requires a lot of effort. Alternatively, developers might automate the process by using relational physical design tools to create materialized views and indexes instead. However, the characteristics of object-oriented database applications are often distinct enough from traditional database applications such that classical relational query optimization techniques often cannot speed up queries that arise from such applications, as our experiments show. To address this, we build Chestnut, a data layout generator for in-memory object-oriented database applications. Given a memory budget, Chestnut generates customized in-memory data layouts and query plans to answer queries written using a subset of the Rails API, a common framework for building object-oriented database applications. Chestnut differs from traditional query optimizers and physical designers in two ways. First, Chestnut automatically generates data layouts that are customized for the application after analyzing their queries, hence Chestnut-generated data layouts are designed to be efficient to answer queries from such applications. second, Chestnut uses a novel enumeration and verification-based algorithm to generate query plans that use such data layouts, rather than rule-based approaches as in traditional query optimizers. We evaluated Chestnut on four open-source Rails database applications. The result shows that it can reduce average query processing time by over 3.6X (and up to 42X), as compared to other in-memory relational database engines.

Формальное представление моделей прикладных предметных областей в понятиях унифицированной метамодели объектно-ориентированных приложений баз данных

This article presents a formal description of object models in terms of a unified object-oriented metamodel for database applications, developed by the author and independent of the domain. Described metamodel is implemented by the author in own development environment which called SharpArchitect RAD Studio. In the beginning of the article the available works of similar subjects are thoroughly analyzed. Analysis have revealed that most authors use the set theory and predicate calculus for representation of the elements of object-oriented programming languages and design of object models. The same approach is used in this article. This article presents a metamodel, developed by the author for the design and implementation for object-oriented database applications. Attention is paid to the hierarchy of the classes presented in the application domains. Also the composition and structure of classes that allows to present both atomic literal types and classes of attributes which values are the instances of classes and collection of copies are described in detail. Attention is paid to the implementation of the dynamic component by description of methods (with support of the parameters) and present classes events. The formal approach to the description of the models for any application domains are proposed on the basis of the metamodel with using of set theory. The unified model of testing of objectoriented applications development tools was developed for the analysis of the applicability of the proposed approach. Optimality criteria of this model as well as its implementation in C# with the representation of all main classes presented in it are described. The proposed formal approach has been tested on the described model. Domain classes, attributes, associations and whole hierarchies have been described. It allowed to confirm the validity of the proposed formal solution. In conclusion the assumptions about the directions of further development of the proposed approach are made.

Teallach — a flexible user-interface development environment for object database applications

The Teallach project has adapted model-based user-interface development techniques to the systematic creation of user-interfaces for object-oriented database applications. Model-based approaches aim to provide designers with a more principled approach to user-interface development using a variety of underlying models, and tools which manipulate these models. Here we present the results of the Teallach project, describing the tools developed and the flexible design method supported. Distinctive features of the Teallach system include provision of database-specific constructs, comprehensive facilities for relating the different models, and support for a flexible design method in which models can be constructed and related by designers in different orders and in different ways, to suit their particular design rationales. The system then creates the desired user-interface as an independent, fully functional Java application, with automatically generated help facilities.

The Goql Graphical Query Language

The authors present a graphical query language, GOQL (Graphical Object Query Language), for object-oriented data base systems, in general, and the object model of ODMG 2.0, in particular. A detailed literature survey of related work is given, and an analysis methodology that allows the evaluation of such languages is proposed. Moreover, the user's view of GOQL is presented. The user's view provides a graphical schema that does not contain any of the perplexing details of an object-oriented database schema; it also provides a graphical interface that supports ad hoc queries for object-oriented database applications. Because there is a direct correspondence between the features of GOQL and OQL (GOQL supports all the features of OQL), the language can be used as an alternative graphical interface to OQL. Thus, GOQL allows users to express queries graphically ranging from simplistic to complicated ones. Among the features provided/supported by the language are: a 2D colour interface, methods, predicates, Boolean and set operators, arithmetic expressions, existential/universal quantifiers, aggregate functions, group by and sort operators, functions, and subqueries. In this article, we illustrate through examples both the user's view and the query mechanism of GOQL. This work represents the completion of work that was partially presented in earlier articles.

MGA: Rule-based specification of active object-oriented database applications

This paper describes a model for developing applications of active object-oriented databases based on three orthogonal concepts; methods, guards and actions and a tool which implements these ideas called MGA. MGA objects are active; they have guards which constrain the object's state, actions which maintain database integrity when the object's state changes, and methods through which the object provides other services. These active components are implemented as (collections of) rules and rules are in turn modelled as objects.

From structured documents to novel query facilities

Structured documents (e.g., SGML) can benefit a lot from database support and more specifically from object-oriented database (OODB) management systems. This paper describes a natural mapping from SGML documents into OODB's and a formal extension of two OODB query languages (one SQL-like and the other calculus) in order to deal with SGML document retrieval. Although motivated by structured documents, the extensions of query languages that we present are general and useful for a variety of other OODB applications. A key element is the introduction of paths as first class citizens. The new features allow to query data (and to some extent schema) without exact knowledge of the schema in a simple and homogeneous fashion.

Concurrency control for object bases

This paper presents concurrency control techniques suitable for engineering design environments. Design environments are quite different from conventional business applications for which databases have been traditionally used. Transactions in a design application are usually very long compared with those in traditional applications, necessitating new concurrency control techniques. We present the Dynamic Validation concurrency control scheme, an optimistic concurrency control scheme that avoids locking data items for extended periods of time. Dynamic validation is designed specifically for low-contention object-oriented database applications with long-duration transactions, such as engineering design applications. We prove that dynamic validation enforces executions that are “serializable with respect to the database state”. This correctness criterion relaxes the classical serializability criterion, and allows schedules that are equivalent, i.e. produce the same effect, to a serial execution of transactions starting from the same initial database state.

DBDesigner

DBDesigner is a graphical front end tool for ONTOS, a commercial object-oriented database system. Through its graphical user interface, DBDesigner allows an application developer to design, browse, and modify a database schema, and to generate C++ header files from the schema. For the purpose of testing and prototyping, DBDesigner permits the user to create, modify, and delete objects in a database. DBDesigner can be a stand alone tool for the design of object-oriented databases or as a library module that can be linked into an application program. The unique approach of DBDesigner is to integrate these activities into a working environment for the development of object-oriented database applications.