In this paper we present a simple and efficient method, called ARIES ( Algorithm for Recouery and Isolation Exploiting Semantics), which supports partial rollbacks of transactions, finegranularity (e.g., record) locking and recovery using write-ahead logging (WAL). We introduce the paradigm of repeating history to redo all missing updates before performing the rollbacks of the loser transactions during restart after a system failure. ARIES uses a log sequence number in each page to correlate the state of a page with respect to logged updates of that page. All updates of a transaction are logged, including those performed during rollbacks. By appropriate chaining of the log records written during rollbacks to those written during forward progress, a bounded amount of logging is ensured during rollbacks even in the face of repeated failures during restart or of nested rollbacks We deal with a variety of features that are very Important in building and operating an industrial-strength transaction processing system ARIES supports fuzzy checkpoints, selective and deferred restart, fuzzy image copies, media recovery, and high concurrency lock modes (e. g., increment /decrement) which exploit the semantics of the operations and require the ability to perform operation logging. ARIES is flexible with respect to the kinds of buffer management policies that can be implemented. It supports objects of

E is an extension of C++ designed for writing software systems to support persistent applications. Originally designed as a language for implementing database systems, E has evolved into a general persistent programming language E was the first C++ extension to support transparent persistence, the first C++ implementation to support generic classes, and remains the only C++ extension to provide general-purpose lterators, In addition to its contributions to the C + + programming domain, work on E has made several contributions to the field of persmtent languages in general, including several distinct implementations of persistence. Thm paper describes the main features of E and shows through examples how E addresses many of the problems that arise in building persistent systems.

We present SECONDO, a new generic environment supporting the implementation of database systems for a wide range of data models and query languages. On the one hand, this framework is more flexible than common extensible and object-relational systems, offering the full extensibility of second-order signature, the formal basis for data and query language definitions in SECONDO. On the other hand, it is much more complete and structured than database system toolkits. Extensibility is provided by the concept of algebra modules defining and implementing new types (type constructors, in fact) and operators. Support functions are used to register them with the system frame. After a review of second-order signature essentials, this paper presents the system functionality, given by a uniform set of user commands valid for all data models, and the extensible system architecture. All common DBMS features are implemented in the system frame; only purely data model dependent functionality is coded in algebra modules, supported by a variety of tools. Furthermore, we describe the key strategies for extensible query processing in the SECONDO environment and explain the structure of algebra modules.

this paper. However, these automatic or semi-automatic warping algorithms are extremely important for this application. It is precisely this technology that permits anatomic structure-based access to acquired medical images as well as comparisons among studies, even of different patients, as long as they have been warped to the same atlas. Furthermore, it enables the database to grow, and be queryable, without time-consuming manual segmentation of the data.

Data Types New base types can be added to the EXTRA data model via the EXTRA abstract data type facility. To add a new ADT, the person responsible for adding the type begins by writing (and debugging) the code for the type in the E programming language. E is an extension of C++ [Stro86] that was developed as part of the EXODUS project. E serves as the implementation language for access methods and operators for systems developed using EXODUS. It is also the target language for the query compiler, and (most importantly for our purposes here) the language in which base type extensions will be defined. E extends C++ with a number of features to aid programmers in data- 89 base system programming, including "dbclasses" for persistent storage, class generators for implementing "generic" classes and functions, iterators for use as a control abstraction in writing set operations, and built-in class generators for typed files and variable-length arrays [Rich87]. Suppose that we wanted to add...

Abstract. In recent years the deployment of embedded systems has increased dramatically, e.g. in the domains of sensor networks or ubiquitous computing. At the same time the amount of data that have to be managed by embedded systems is growing rapidly. For this reason an adequate data management support is urgently needed. Current database technologies are not able to cope with the requirements specific to embedded environments. Especially the extreme resource constraints and the diversity of hardware plattforms and operating systems are challenging. To overcome this tension we argue that embedded database functionality has to be tailored to the application scenario as well as to the target platform. This reduces the resource consumption and customizes the data management to the characteristices of the plattform and the application scenarion. We show that component techniques and feature-oriented programming help to face the mentioned limitations without focusing on special-purpose software. We present the design and the implementation of a database storage manager family. We discuss how feature-oriented domain analysis and feature-oriented programming help to do this task. Our evaluation criteria are the number of features and the flexibility to combine these features in different valid variants. 1

From our experience, current rule-based query optimizers do not provide a very intuitive and well-defined framework to define rules and actions. To remedy this situation, we propose an extensible and structured algebraic framework called Prairie for specifying rules. Prairie facilitates rule-writing by enabling a user to write rules and actions more quickly, correctly and in an easy-to-understand and easy-to-debug manner. Query optimizers consist of three major parts: a search space, a cost model and a search strategy. The approach we take is only to develop the algebra which defines the search space and the cost model; we do not propose a search engine (i.e., search strategy) to drive the rules. We have chosen the Volcano optimizer generator as our search engine, because it is publicly available, and also because it has an efficient branch-and-bound search strategy. Using Prairie as a front-end, we translate Prairie rules to Volcano to validate our claim that Prairie makes it easier to write rules. We describe our algebra and present experimental results which show that using a high-level framework like Prairie to design large-scale optimizers does not sacrifice efficiency. 1

system that supports an extensible set of data types, profile types, and optimization metrics. XPORT efficiently implements a generic tree-based overlay network, which can be customized per application using a small number of methods that encapsulate application-specific data filtering, profile aggregation, and optimization logic. The clean separation between the “plumbing ” and “application ” enables the system to uniformly support disparate dissemination-based applications. We first provide an overview of the basic XPORT model and architecture. We then describe in detail an extensible optimization framework, based on a two-level aggregation model, that facilitates easy specification of a wide range of commonly used performance goals. We discuss distributed tree transformation protocols that allow XPORT to iteratively optimize its operation to achieve these goals under changing network and application conditions. Finally, we demonstrate the flexibility and the effectiveness of XPORT using real-world data and experimental results obtained from both prototype-based LAN emulation and deployment on PlanetLab. 1.

Customizable operating systems, database systems, and communication subsystems have demonstrated many advantages of customization, including considerable performance improvements. One common approach for constructing customizable software is to implement it as a collection of modules that can be configured in different combinations to provide customized variants of the software. Typically, ad hoc methods are used to determine which modules may be combined. Such methods require intimate knowledge of the modules and their interactions or the configuration will not behave as expected. In this paper, we present a methodology that simplifies the difficult task of constructing correct custom variants of highly-customizable software. The methodology is based on identifying relations between software modules that dictate which combinations are correct. We also introduce a configuration support tool that, based on these relations, allows only correct configurations to be created. 1 In...

This paper describes a framework for query optimization for KBMSs based on the knowledge representation language Telos. The developed framework involves temporal and syntactic simplifications and semantic modification of the queries. Temporal simplification attempts to select parts of a knowledge base that are relevant to a query from a temporal viewpoint. Syntactic simplification exploits structural properties of the data model and attempts to transform the query into an equivalent and more efficient one. Semantic transformation uses knowledge specific to the application domain i.e, integrity constraints and rules, in order to transform a user specified query into another form which gets the same answer and it is processed efficiently. The above three steps are integrated into a global algorithm for query optimization, that utilizes all features of the considered KBMS.