Carol Small

Algebraic query optimisation for database programming languages

Abstract. A major challenge still facing the designers and implementors of database programming languages (DBPLs) is that of query optimisation. We investigate algebraic query optimisation techniques for DBPLs in the context of a purely declarative functional language that supports sets as first-class objects. Since the language is computationally complete issues such as non-termination of expressions and construction of infinite data structures can be investigated, whilst its declarative nature allows the issue of side effects to be avoided and a richer set of equivalences to be developed. The language has a well-defined semantics which permits us to reason formally about the properties of expressions, such as their equivalence with other expressions and their termination. The support of a set bulk data type enables much prior work on the optimisation of relational languages to be utilised.In the paper we first give the syntax of our archetypal DBPL and briefly discuss its semantics. We then define a small but powerful algebra of operators over the set data type, provide some key equivalences for expressions in these operators, and list transformation principles for optimising expressions. Along the way, we identify some caveats to well-known equivalences for non-deductive database languages. We next extend our language with two higher level constructs commonly found in functional DBPLs: set comprehensions and functions with known inverses. Some key equivalences for these constructs are provided, as are transformation principles for expressions in them. Finally, we investigate extending our equivalences for the set operators to the analogous operators over bags. Although developed and formally proved in the context of a functional language, our findings are directly applicable to other DBPLs of similar expressiveness.

Manipulation operations for an interval-extended relational model

Abstract We identify semantic problems associated with the querying and updating of spatio-temporal interval data and propose operations which alleviate these problems. We first motivate two key requirements for the manipulation of such data, namely that no two tuples of a relation should intersect or be mergeable. We then examine the properties of two operations, unfold and fold, and show how they can be used to define three further operations which, respectively: eliminate intersecting or mergeable data from a relation incorporating interval attributes, yielding a so-called canonical relation: add data to a canonical relation while preserving the canonicity property; and remove data from a canonical relation while also preserving canonicity. We formally show the correctness of all these operations. An examination of their space and time requirements then leads us to define an equivalent set of optimised operations. We formally show the equivalence of the non-optimised and optimised operations, and discuss the performance gains of the latter.

Extending Functional Database Languages to Update Completeness

This paper discusses the update operators currently implemented in the functional database programming language PFL and the linear type system which regulates their use.

Extending a Functional DBPL with ECA-rules

We describe how a functional database programming language can be extended with transactions and EGA-rules. Fundamental requirements of such an extension are that the declarative semantics of the language not be compromised, that the syntax of the language not be disrupted unduly, and that impedance mismatch problems be avoided. We define what we mean by events, conditions and actions and describe the semantics of EGA-rules with reference to event detection, parameter-binding, transaction scheduling and abort handling. We define the execution semantics for the EGA System in the language itself. These semantics form the basis of our implementation of the EGA System.

PFL: An Active Functional DBPL

This chapter describes the active subsystem of PFL, a functional database programming language (DBPL). We discuss how PFL has been extended with transactions and ECA rules without compromising the confluence of expression evaluation. We describe the support for primitive and composite events, the definition and semantics of ECA rules, and the execution model. To our knowledge, this is the first time that an active subsystem has been added to a functional DBPL.

A formal semantics for an active functional DBPL

We describe how the functional database programming language PFL is extended with an active component without compromising either its declarative semantics or its syntax. We give a formal specification of the active component using PFL itself, including event specification and detection, parameter-binding, reaction scheduling and abort handling. We describe how a user-specified function can be cast as a primitive event, and discuss the expressiveness of events and the optimisation of event detection.

Formal Foundations for Optimising Aggregation Functions in Database Programming Languages

This paper investigates the optimisation of aggregation functions in the context of computationally complete database programming languages and aims to generalise and provide a unifying formal foundation for previous work. We define a ‘fold’ operator φ over collection types in terms of which operations such as selection, projection, join and group-by can be defined, as well as aggregation functions such as sum, max and min. We introduce two equivalences for φ which respectively govern the commuting and coalescing of applications of φ. From these two equivalences we then formally derive equivalences governing the commuting and coalescing of iteration operations over collections, the mapping of aggregation functions over grouped collections, the introduction and elimination of aggregation functions, and the promotion of aggregation functions through iteration operations. We also show how some of these equivalences can be used to optimise comprehensions, a high-level query construct supported by many database languages.

A functional approach to database updates

Abstract PFL is a functional database language in which functions are defined equationally and bulk data is stored using a special class of functions called selectors. It is a lazy language, supports higher-order functions, has a strong polymorphic type inference system, and allows new user-defined data types and values to be declared. All functions, types and values persist in a database. Functions can be written which update all aspects of the database: by adding data to selectors, by defining new equations, and by introducing new data types and values. PFL is “semi-referentially transparent”, in the sense that whilst updates are referentially opaque and are executed destructively, all evaluation is referentially transparent. Similarly, type checking is “semi-static” in the sense that whilst updates are dynamically type checked at run time, expressions are type checked before they are evaluated and no type errors can occur during their evaluation. In this paper we examine the expressiveness of PFL with respect to updates, and illustrate the language by developing a number of general purpose update functions, including functions for restructuring selectors, for memoisation, and for generating unique system identifiers. We also provide a translation mechanism between Datalog programs and equations, and show how different Datalog evaluation strategies can be supported.