Introduction This chapter gives an overview on multilevel transactions and its generalization toward open nested transactions. The main features of these transaction models are the following: first, semantic properties of operations can be exploited to relax the isolation of concurrent transactions; second, as a consequence, atomicity is achieved by compensation rather than state-based undo; and third, subtransactions can be made persistent independently of their commit state, that is, global visibility of their updates. Advanced transaction models and new correctness criteria for transaction executions have been proposed for the following reasons (and possibly further reasons that are not mentioned here): 1. to provide better support for long-lived activities in advanced DBMS applications, 2. to relax the classical ACID paradigm, for example, provide more flexibility as to when updates are made visible to concurrent transactions, 3. to support cooperation between the members

The concept of nested transactions offers more decomposable execution units and finer grained control over concurrency and recovery than `flat' transactions. Furthermore, it supports the decomposition of a `unit of work' into subtasks and their appropriate distribution in a computer system as a prerequisite of intra-transaction parallelism. However, to exploit its full potential, suitable granules of concurrency control as well as access modes for shared data are necessary. In this paper, we investigate various issues of concurrency control for nested transactions. First of all, the mechanisms for cooperation and communication within nested transactions should not impede parallel execution of transactions, neither among parent and children nor among siblings. Therefore,a model for nested transactions is proposed allowing for effective exploitation of intra-transaction parallelism. Starting with a set of basic locking rules, we introduce the concept of `downward inheritance of locks' to make data manipulated by a parent available to its children. To support supervised and restricted access, this concept is refined to `controlled downward inheritance'. The initial concurrency control scheme was based upon S-X locks for `flat', non-overlapping data objects. In order to adjust this scheme to the needs of practical applications, a set of concurrency control rules is derived for generalized lock modes described by a compatibility matrix. Moreover, these rules are combined with a hierarchical locking scheme to improve selective access to data granules of varying sizes. After having tied together both types of hierarchies (transaction and object hierarchies) it could be shown how `controlled downward inheritance' for hierarchical objects may be achieved in nested transactions...

Multi--level transactions have received considerable attention as a framework for high--performance concurrency control methods. An inherent property of multi--level transactions is the need for compensating actions, since state--based recovery methods do no longer work correctly for transaction undo. The resulting requirement of operation logging adds to the complexity of crash recovery. In addition, multi--level recovery algorithms have to take into account that high--level actions are not necessarily atomic, e.g., if multiple pages are updated in a single action. In this paper, we present a recovery algorithm for multi--level transactions. Unlike typical commercial database systems, we have striven for simplicity rather than employing special tricks. It is important to note, though, that simplicity is not achieved at the expense of performance. We show how a high--performance multi--level recovery algorithm can be systematically developed based on few fundamental principles. The pr...

The semantics of objects and transactions in database systems are investigated. User-defined predicates called consistency assertions are used to specify user programs. Three new correctness criteria are proposed. The first correctness criterion consistency is based solely on the users’ specifications and admits nonsenalizable executions that are acceptable to the users. Integrity constraints of the database are maintained through consistency assertions. The second correct-ness criterion orderabdlty is a generalization of view serializability and represents a weak notion of eqmvalence to a serial schedule. Finally, the third correctness criterion strong order-abzlity is introduced as a generalization of conflict serializabihty. Unlike consistency, the notions of orderability allow users to operate in isolation as maintenance of the integrity constraints now becomes the responsibility of the database system,

This paper discusses issues raised by providing disconnected operation in the Thor object-oriented database system. Disconnected operation in such a system poses new challenges because of the small size of objects, the richness and complexity of their interconnections, the huge number of them, and the fact that they are accessed within atomic transactions. We propose three techniques to address these challenges: (1) using the database query language for hoarding; (2) using dependent commits to tentatively commit transactions at the disconnected client; (3) using the high-level semantic of objects to avoid transaction aborts.

This paper presents a new locking protocol for object-oriented database systems (OODBSs). The protocol can exploit the semantics of methods invoked on encapsulated objects. Compared to conventional page-oriented or recordoriented concurrency control protocols, our protocol greatly improves the possible concurrency because commutative method executions on the same object are not considered as a conflict. data types (ADTs), the protocol takes care of the fact that ADTs can be implemented in terms of other ADTs. Therefore, methods on ADT objects can in turn invoke methods on other ADT objects or even the same object. To ensure that each method execution appears as an indivisible action, the dynamic method invocation hierarchies that result from transaction executions are treated as open nested transactions. In an open nested transaction, the locks of a subtransaction are released when the subtransaction completes and only a semantic lock is held further by the parent of the subtransaction.

Multi-level transactions are a variant of open-nested transactions in which the subtransactions correspond to operations at different levels of a layered system architecture. They allow the exploitation of semantics of high-level operations to increase concurrency. As a consequence, undoing a transaction requires compensation of completed subtransactions. In addition, multi-level recovery methods must take into consideration that high-level operations are not necessarily atomic if multiple pages are updated in a single subtransaction. This article presents algorithms for multi-level transaction management that are implemented in the database kernel system (DASDBS). In particular, we show that multi-level recovery can be implemented in an efficient way. We discuss performance measurements using a synthetic benchmark for processing complex objects in a multi-user environment. We show that multi-level transaction management can be extended easily to cope with parallel subtransactions within a single transaction. Performance results are presented with varying degrees of inter- and intratransaction parallelism.

Abstraction mappings are one of the major tools used to construct correctness proofs for concurrent algorithms. Several examples axe given of situations in which it is useful to allow the abstraction mappings to be multivalued, The examples involve algorithm optimization, algorithm distribution, and proofs of time bounds.

Two operations commute if executing them serially in either order results in the same change of state. In a system in which commands may be issued simultaneously by di#erent users, lack of commutativity can result in unpredictable behaviour, even if the commands are serialized, because one user's command may be preempted by another's, and thus executed in an unanticipated state.

In this paper, we present a study on the concurrency control and recovery algorithms in nested transaction environment. We have reviewed the work done in the area of nested transaction modelling, its applications in object-oriented and mobile databases, and in workflow models. We have contrasted various nested transaction models by discussing their advantages and disadvantages. We have outlined some important future research directions in the area of nested transaction processing. 1.