This paper describes the Query Rewrite facility of the Starburst extensible database system, a novel phase of query optimization. We present a suite of rewrite rules used in Starburst to transform queries into equivalent queries for faster execution, and also describe the production rule engine which is used by Starburst to choose and execute these rules. Examples are provided demonstrating that these Query Rewrite transformations lead to query execution time improvements of orders of magnitude, suggesting that Query Rewrite in general --- and these rewrite rules in particular --- are an essential step in query optimization for modern database systems. 1 Introduction In traditional database systems, query optimization typically consists of a single phase of processing in which access methods, join orders and join methods are chosen to provide an efficient plan for executing a user's declarative query. We refer to this phase as plan optimization. In this paper we present a distinct ph...

Abstract not found

We present constructs for computing aggregate functions over sets of tuples and along paths in a database graph. We show how Datalog can be extended to compute a large class of queries with aggregates without incurring the large expense of a language with general set manipulation capabilities. In particular, we aim for queries that can be executed efficiently in parallel, using the class nc and its various subclasses as formal models of low parallel complexity. Our approach retains the standard relational notion of relations as sets of tuples, not requiring the introduction of multisets. In the case where no rules are recursive, the language is exactly as expressive as Klug's first order language with aggregates. We show that this class of non-recursive programs cannot express transitive closure (unless logspace=nlogspace), thus providing evidence for a widely believed but never proven folk result. We also study the expressive This work has been supported by the Informat...

Much recent work has focussed on the bottomup evaluation of Datalog programs. One approach, called magic-sets, is based on rewriting a logic program so that bottom-up fixpoint evaluation of the program avoids generation of irrelevant facts ([BMSU86, BR87, Ram88]). It is widely believed that the principal application of the magicsets technique is to restrict computation in recursive queries using equijoin predicates. We extend the magic-sets transformation to use predicates other than equality (X ? 10, for example). This Extended Magic-Set technique has practical utility in "real" relational databases, not only for recursive queries, but for non-recursive queries as well; in ([MFPR90]) we use the results in this paper and those in [MPR90] to define a magic-set transformation for relational databases supporting SQL and its extensions, going on to describe an implementation of magic in Starburst ([HFLP89]). We also give preliminary performance measurements. In extending magic-sets, we des...

. Queries commonly perform much better if they manage to avoid duplicate elimination operations in their execution plans. In this paper, we report on a technique that provides a necessary and sucient condition for removing such operators from object relational conjunctive queries under the standard duplicate semantics. The condition is fully captured as a membership problem in a dialect of description logic called CFD, which is capable of expressing a number of common constraints implicit in object relational database schemas. We also present a PTIME algorithm for arbitrary membership problems in CFD. 1 Introduction The paper presents a combination of two techniques to provide a very powerful tool for reasoning about duplicate semantics of conjunctive object relational queries, in particular about elimination operations and situations in which these operations can be completely removed. The query language studied in the paper contains many other practical query languages, in ...

We present an incremental evaluation algorithm for materialized views in relational and deductive database systems. The algorithm computes, in an incremental fashion, the changes to the materialized view in response to changes (insertions, deletions, and updates) to the base relations. The view may be defined in SQL or in Datalog, and may use UNION , negation, aggregation (e.g. SUM, MIN), linear recursion, and general recursion. The algorithm is optimal in that it computes exactly those view tuples that are inserted or deleted. The algorithm works by tracking the number of derivation trees ([Mum91, MS92]) for each tuple in the view. The number of derivation trees for a tuple corresponds to the count of a tuple in the duplicate semantics used in relational systems such as those based on SQL. For deductive databases using set semantics, we show that the number of derivation trees for nonrecursive queries can be computed at little or no cost above the cost of evaluating the quer...

this paper we will write database queries in datalog [Ull89]. Datalog is the language of horn clause logic rules, written as "if-then" rules. A datalog rule is required to be range-restricted: it must define a finite relation for the predicate in the head of the rule. In this paper we will concentrate on nonrecursive queries. Mumick [Mum91] shows that nonrecursive datalog programs can be expressed in SQL using views, and that SQL queries can be expressed in datalog extended with duplicates and grouping with aggregation. Thus, the algorithms developed in this paper can be mapped to relational database systems having SQL as their query language. We will use dependency graphs to represent the dependence between predicates in a datalog program.

One of the recently proposed techniques for the efficient evaluation of OLAP aggregate queries is the usage of clustering access methods. These methods store the fact table of a data warehouse clustered according to the dimension hierarchies using special attributes called hierarchical surrogate keys. In the presence of these access methods new processing and optimization techniques have been recently proposed. One important such optimization technique, called Hierarchical Pre-Grouping, uses the hierarchical surrogate keys in order to aggregate the fact table tuples as early as possible and to avoid redundant joins. In this paper, we study the Pre-Grouping transformation, attempting to generalize its applicability and identify its relationship to other similar transformations. Our results include a general algebraic definition of the Pre-Grouping transformation along with the formal definition of sufficient conditions for applying the transformation. Using a provided theorem we show that Pre-Grouping can be applied in the presence of functional and inclusion dependencies without the explicit usage of hierarchical surrogate keys. An additional result of our study is the definition of the Surrogate-Join transformation that can modify a join condition using a number of dependencies. To our knowledge, Surrogate-Join does not belong to any of the Semantic Query Transformation types discussed in the past. 1.

Declarative languages for deductive and object-oriented databases require some high-level mechanism for specifying semantic control knowledge. This paper proposes user-supplied subsumption information as a paradigm to specify desired, prefered or useful deductions at the meta level. For this purpose we augment logic programming by subsumption relations and succeed to extend the classical theorems for least models, fixpoints and bottom-up evaluation accordingly. Moreover, we can provide a differential fixpoint operator for efficient query evaluation. This operator discards subsumed tuples on the fly. We also exemplify the ease of use of this programming methodology. In particular, we demonstrate how heuristic AI search procedures can be integrated into logic programming in this way.

SWORD is a declarative object-oriented database being built at AT&T Bell Laboratories. SWORD provides both procedural and declarative data manipulation languages. SWORD is integrated with the O++ language (an extension of C++) of the ODE database system. The data definition and procedural data manipulation in SWORD are done in the O++ sublanguage. In addition, SWORD provides a declarative sublanguage to express queries. Declarativeness yields benefits in reduced programming time and automatic optimization in response to changing database characteristics. The declarative sublanguage is based on the Noodle language of [MR93], modified for integration with C++/O++ to avoid the impedance mismatch problem. The declarative sublanguage models object-identity, classes, relations, views, inheritance, complex objects, and methods, in addition to logical rules. In this paper we discuss the design and implementation of the declarative sublanguage of SWORD. Our work bridges the gap between deduct...