Rule-based optimizers and optimizer generators use rules to specify query transformations. Rules act directly on query representations, which typically are based on query algebras. But most algebras complicate rule formulation, and rules over these algebras must often resort to calling to externally defined bodies of code. Code makes rules difficult to formulate, prove correct and reason about, and therefore compromises the effectiveness of rule-based systems. In this paper we present KOLA; a combinator-based algebra designed to simplify rule formulation. KOLA is not a user language, and KOLA's variable-free queries are difficult for humans to read. But KOLA is an effective internal algebra because its combinatorstyle makes queries manipulable and structurally revealing. As a result, rules over KOLA queries are easily expressed without the need for supplemental code. We illustrate this point, first by showing some transformations that despite their simplicity, require head and body rou...

The AQUA [16] query algebra allows user-defined equivalence relations as arguments to query operators that generalize standard set operations. These predicates determine what objects are included in the query result, and the duplicates that must be removed. While an expressive enhancement, the use of arbitrary equivalence relations to decide set membership can result in sets with counterintuitive behavior, and therefore can make queries return unreasonable results. In this paper, we show that equality predicates assume two roles with respect to sets. Distinguishers differentiate between set members and implicitly give meaning to standard set properties such as set equality. Constructors determine which object from input sets contribute to the query result. The requirements of distinguishers and constructors differ. AQUA's set operators are problematic because they use constructors where distinguishers are required. We propose alternatives to AQUA's set operators that address this limit...

In [CZ96], we argue that a combinator (i.e., variable-free) query algebra simplifies correctness proofs and implementations of query optimizers. But combinators make for poor query languages, and therefore translations from standard query languages (such as OQL [Cat93]) into some combinator form is required. In this paper, we present our translator that maps queries written in a variant of OQL (OQLdeB) into KOLA [Che95a]; our combinator-based query algebra. We introduce a denotational semantics for OQLdeB and define KOLA using an operational semantics that rewrites KOLA queries into OQLdeB . We then proceed to show the correctness of our translator by showing that translation produces a KOLA query whose OQLdeB equivalent has the same semantics as the original query. The significance of our work lies in its implications for the design of efficient and simply formalized query optimizers. With respect to formalization, we have used the Larch [GHG + 92] specification tool LSL to formally...

Object-oriented database systems began developing in the mid-80’s out of a necessity to meet the requirements of applications beyond the data processing applications which were [are] served by relational database systems. This paper serves as an overview on the achievements of object-oriented database technology so far, and also discusses the weaknesses that have to be yet resolved by the object-oriented database community before object-oriented database technology can become as widespread as relational databases. 1

Query optimizers generate plans to retrieve data specified by queries. Query optimization for object databases (i.e., object-oriented and object-relational databases) is an immature field, and stands to benefit from adaptation of techniques that have proved useful for relations. One technique uses query-to-query transformations to rewrite queries into queries that are potentially more amenable to plan generation. For transformations to be useful, they must preserve the semantics of the queries they rewrite (correctness) and usually result in queries that generate better plans (effectiveness). Object databases complicate the expression of correct and effective transformations. Transformation correctness is problematic even for relational queries. Especially error-prone are transformations that rewrite complex nested queries (queries containing other queries) or queries that return duplicates. Objects make correctness more difficult because object queries can be far more compl...