Martin L. Kersten

MIL primitives for querying a fragmented world

Abstract. In query-intensive database application areas, like decision support and data mining, systems that use vertical fragmentation have a significant performance advantage. In order to support relational or object oriented applications on top of such a fragmented data model, a flexible yet powerful intermediate language is needed. This problem has been successfully tackled in Monet, a modern extensible database kernel developed by our group. We focus on the design choices made in the Monet interpreter language (MIL), its algebraic query language, and outline how its concept of tactical optimization enhances and simplifies the optimization of complex queries. Finally, we summarize the experience gained in Monet by creating a highly efficient implementation of MIL.

Flattening an object algebra to provide performance

Algebraic transformation and optimization techniques have been the method of choice in relational query execution, but applying them in object-oriented (OO) DBMSs is difficult due to the complexity of OO query languages. This paper demonstrates that the problem can be simplified by mapping an OO data model to the binary relational model implemented by Monet, a state-of-the-art database kernel. We present a generic mapping scheme to flatten data models and study the case of straightforward OO model. We show how flattening enabled us to implement a query algebra, using only a very limited set of simple operations. The required primitives and query execution strategies are discussed, and their performance is evaluated on the 1-GByte TPC-D (Transaction-processing Performance Councils Benchmark D), showing that our divide-and-conquer approach yields excellent results.

Monet And Its Geographic Extensions: A Novel Approach to High Performance GIS Processing

We describe Monet, a novel database system, designed to get maximum performance out of todays workstations and symmetric multiprocessors.

Application of an optimistic concurrency control method

This paper illustrates the implementation feasibility of an optimistic approach to concurrency control. After reviewing the approach and clarifying the underlying algorithms and assumptions, it is applied to the design of a multi‐user version of an existing relational database management system. Two different system architectures for a UNIX UNIX is a trademark of Bell Laboratories. ‐based environment are presented and prototype implementations have been constructed. We also provide some performance statistics on the optimistic approach to concurrency control and compare it with a traditional locking protocol.

High-level programming features for improving the efficiency of a relational database system

This paper discusses some high-level language programming constructs that can be used to manipulate the relations of a relational database system efficiently. Three different constructs are described: (1) tuple identifiers that directly reference tuples of a relation; (2) cursors that may iterate over the tuples of a relation; and (3) markings, a form of temporary relation consisting of a set of tuple identifiers. In each case, attention is given to syntactic, semantic, and implementation considerations. The use of these features is first presented within the context of the programming language PLAIN, and it is then shown how these features could be used more generally to provide database manipulation capabilities in a high-level programming language. Consideration is also given to issues of programming methodology, with an important goal being the achievement of a balance between the enforcement of good programming practices and the ability to write efficient programs.

The architecture of the PLAIN data base handler

The programming language PLAIN has been designed to support conversational access to a data base, and incorporates relations as a built‐in data type. This paper describes the architecture of the data base handler for PLAIN, emphasizing the separation of the data base handler from other aspects of the language processor, and the modularization of the data base architecture to support modifications to the language and its implementation with minimal difficulty. The data base architecture is layered in order to provide the greatest possible degree of information hiding and separation of functionality. The paper shows the structure of the data base handler and the functions of the various modules of the system.

The Acoi Algebra: a Query Algebra for Image Retrieval Systems

Content-based image retrieval systems rely on a query-by-example technique often using a limited set of global image features. This leads to a rather coarse-grain approach to locate images. The next step is to concentrate on queries over spatial relations amongst objects within the images. This calls for a small collection of image retrieval primitives to form the basis of an image retrieval system. The Acoi algebra is such an extensible framework built on the relational algebra. New primitives can be added readily, including user-defined metric functions for searching. We illustrate the expressive power of the query scheme using a concise functional benchmark for querying image databases.

DO-SELECT reconsidered

This article is a further investigation into the usefulness of a DO-SELECT as proposed by Hill [Hill82]. The DO-SELECT construct claims to improve understandability and reduce the complexity of deeply nested IF-THEN-ELSE statements. However, the presentation does not address the limitations of the approach. A better structure is indicated.

High performance OO traversals in monet

In this paper we discuss how Monet, a novel multimodel database system, can be used to efficiently support OODB applications. We show how Monets offbeat view on key issues in database architecture provided both challenges and opportunities in building a high-performance ODMG-93 compliant Runtime System on top of it.

Privacy and security in information systems using programming language features

Abstract This paper describes a specification and implementation scheme for providing an integrated approach to security and privacy rules and shows how they may be achieved with a formal specification language that permits the association of operations with logical conditions. The implementation of these rules is shown in the programming language PLAIN. In this way, the access and notification control that has typically been performed by operating systems, database management systems, and programming languages is brought together in an integrated programming environment.