Abstract only given, as follows. A variety of parallel approaches have been used to support database processing across a spectrum of machine architectures. We begin by describing areas where parallelism is potentially important in dealing with very large databases, including loading, query/update, and database administration. We then discuss hardware tradeoffs, including multicomputers versus multiprocessors, distributed versus centralized memory, and specialised versus general-purpose architectures. At the software level, we cover a number of approaches, including running multiple transactions in parallel, decomposing queries into parallel subqueries, executing low-level query operations in parallel, running multiple instances of the DBMS, and partitioning data over disks. We characterise the impact of these approaches on performance, scalability, and ease of use, for both decision support and transaction processing. Finally, the approaches taken in several commercial DBMSs are described, as well as extensions such as the Kendall Square Query Decomposer.>

We describe the tools and theory of a comprehensive system for database design, and show how they work together to support multiple conceptual and logical design processes. The Database Design and Evaluation Workbench (DDEW) system uses a rigorous, information-content-preserving approach to schema transformation, but combines it with heuristics, guess work, and user interactions. The main contribution lies in illustrating how theory was adapted to a practical system, and how the consistency and power of a design system can be increased by use of theory. First, we explain why a design system needs multiple data models, and how implementation over a unified underlying model reduces redundancy and inconsistency. Second, we present a core set of small but fundamental algorithms that reaarange a schema without changing its information content. From these reusable components, we easily built larger tools and transformations that were still formally justified. Third, we describe heuristic tools that attempt to improve a schema, often by adding missing information. In these tools, unreliable techniques such as normalization and relationship inference are bolstered by system-guided user interactions to remove errors. We present a rigorous criterion for identifying unnecessary relationships, and discuss an interactive view integrator. Last, we examine the relevance of database theory to building these practically motivated tools and contrast the paradigms of system builders with those of theoreticians.

The Kendall Square Research high performance computer (KSR1) provides a spectrum of parallel database processing techniques to achieve scalability and performance in a shared memory environment. The techniques include running multiple transactions in parallel, decomposing queries into parallel subqueries, running multiple instances of the DBMS and partitioning data over disks. These techniques enable on-line transactions to be run in parallel at high throughput rates and decision-support queries to be parallelized and executed very rapidly.This paper focuses upon two of the parallel database processing techniques used on the KSR1—the Kendall Square Query Decomposer and the Oracle Parallel Server. The Query Decomposer intercepts costly decision support queries and decomposes them into subqueries which are executed in parallel. Parallel Server enables multiple ORACLE instances to run simultaneously on the same database.

We describe an optimizer for relational queries to databases stored as flat files and Codasyl networks. We include sophisticated manipulations on a broad range of direct access structures (DAS's). To achieve this with minimum additional code, we allow operations like sort, scan, and join to apply to DAS's, and categorize indexes and other DAS's in terms of the operations which can be performed on them. Our storage model, based on indivisible units of access and a small set of associated physical operators, provides a uniform interface to both relational and Codasyl storage mechanisms. The optimizer derives a sequence of internal data structures at successively more detailed levels. For a given query, a graph representing an overview of alternative joins is constructed, and then used to derive a physical graph which considers the physical attributes (location and sort order) of the data objects involved. Using cost predictions and other heuristics, the optimizer prunes the physical graph to produce a final access strategy tree. This layered approach and reliance on primitive operators make explicit (and permit changes to) the universe of possible strategies for the query at hand, and ease extension of the optimizer to new storage structures.

This paper presents a method for dynamic modification of operating system control parameters to improve system performance. Improved parameter settings are learned by experimenting on the system. The experiments compare the performance of alternative parameter settings in each region of a partitioned load-performance space associated with the system. The results are used to modify important control parameters periodically, responding to fluctuations in system load and performance. The method can be used to implement adaptive tuning, to choose between alternative algorithms and policies, or to select the best fixed settings for parameters which are not modified.