Ludger Becker

Rule-based optimization and query processing in an extensible geometric database system

Gral is an extensible database system, based on the formal concept of a many-sorted relational algebra. Many-sorted algebra is used to define any applications query language, its query execution language, and its optimiztion rules. In this paper we describe Grals optimization component. It provides (1) a sophisticated rule language—rules are transformations of abstract algebra expressions, (2) a general optimization framework under which more specific optimization algorithms can be implemented, and (3) several control mechanisms for the application of rules. An optimization algorithm can be specified as a series of steps. Each step is defined by its own collection of rules together with a selected control strategy. The general facilities are illustrated by the complete design of an example optimizer—in the form of a rule file—for a small nonstandard query language and an associated execution language. The query language includes selection, join, ordering, embedding derived values, aggregate functions, and several geometric operations. The example shows in particular how the special processing techniques of a geometric database systems, such as spatial join methods and geometric index structures, can be integrated into query processing and optimization of a relational database system. A similar, though larger, optimizer is fully functional within the geometric database system implemented as a Gral prototype.

A new algorithm for computing joins with grid files

The BR/sup 2/-directory representation, a directory structure for grid files, and a join algorithm for the evaluation of general n-ary joins on grid files are presented. It is shown that the CPU cost of the join algorithm is successfully reduced by introducing an inner join. A comparison with the hash join algorithm and a join algorithm on k-d trees for equijoins is based on a cost model developed for query processing with grid files. The join algorithm outperforms the hash join, a specialized join method for equijoins, and the join algorithm on k-d trees for equijoins.<<ETX>>

Algorithms for Performing Polygonal Map Overlay and Spatial Join on Massive Data Sets

We consider the problem of performing polygonal map overlay and the refinement step of spatial overlay joins. We show how to adapt algorithms from computational geometry to solve these problems for massive data sets. A performance study with artificial and real-world data sets helps to identify the algorithm that should be used for given input data.

A hierarchical model for multiresolution surface reconstruction

Abstract The approximation of topographical surfaces is required in a variety of disciplines, for example, computer graphics and geographic information systems (GIS). The constrained Delaunay pyramid is a hierarchical model for approximating 2 1 2 -dimensional surfaces at a variety of predefined resolutions. Basically, the topographical data are given by a set of three-dimensional points, but an additional set of nonintersecting line segments describing linear surface features like valleys, ridges, and coast lines is required to constrain the representation. The approximation is obtained by computing a constrained Delaunay triangulation for each resolution. The model generalizes the constraints at coarse resolutions. Due to its structure, the constrained Delaunay pyramid efficiently supports browsing and zooming in large data sets stored in database systems underlying the GIS. For very large data sets, a divide-and-conquer approach allows the computation of the constrained Delaunay pyramid on secondary storage.

Temporal Support for Geo-Data in Object-Oriented Databases

We review OOGDM, an extensible, object-oriented data model for geographic information systems. This model is intended to be a general base for the development of geo-information systems. Currently we are implementing a prototype GIS-kernel GOODAC which realizes OOGDM. In this paper, we describe recent extensions to incorporate time.

SECONDO/QP: Implementation of a Generic Query Processor

In an extensible database system, evaluation of a query plan is done in cooperation between a collection of operator implementation functions and a component of the DBMS that we call the query processor. Basically, the query processor constructs an operator tree for the query plan and then calls an evaluator function which traverses the tree, calling the operator functions in each node. This seemingly simple strategy is complicated by the fact that operator functions must be able to call for the evaluation of parameter expressions (e.g. predicates), and must be able to process streams of objects in a pipelined manner. Although query processing along these lines is implemented in most database systems, and certainly in all extensible database systems, the details of programming the parameter passing, organizing the interaction between stream operators, etc. are tricky, and seem to be buried in the code of the respective systems. We are not aware of any simple, crisp, clear published exposition of how one could implement such a query processor. This is what the paper offers. Moreover, we feel the solution presented here is particularly simple, elegant, and general. For example, it is entirely independent from the data model being implemented, admits arbitrary parameter functions, and allows one to mix freely stream operators and other operators. The construction of the operator tree, shown in the paper, includes complete type checking and resolution of overloading. The query processor has been implemented within the Secondo system; the source code is available.

A Framework for Representing Moving Objects

We present a framework for representing the trajectories of moving objects and the time-varying results of operations on moving objects. This framework supports the realization of discrete data models of moving objects databases, which incorporate representations of moving objects based on non-linear approximation functions.

Constraints and triggers in an object-oriented geo database kernel

A concept to integrate constraints and triggers into the object-oriented geo database kernel GOODAC is presented. The authors propose an extension of GOODACs object definition language to include the definition of constraints and triggers within the class definitions. To reduce the number of constraints, triggers, and possibly affected objects which must be inspected after an update of the database, they provide a mechanism to determine all objects which are subject to constraints and triggers. The basic information needed for this mechanism is obtained by analyzing the class definitions.

Design and implementation of an interoperable GIS-interface for grid data

The paper describes experiences gained during the design and implementation of the VirGIS interface for spatio-temporal applications using grid data. The interface is designed to offer a high degree of interoperability. There are two implementations of the interface. This paper primarily considers the one that is based on the Object-Oriented Geo-Data Model OOGDM.

Constraints and triggers: a method for ensuring data quality in an object-oriented geo database kernel

We present a concept to integrate constraints and triggers into an object-oriented geo database kernel and propose an extension of the underlying object definition language to specify constraints and triggers. To reduce the number of constraints, we provide a mechanism to determine all objects which are subject to constraints and triggers.