A model for concurrency in nested transactions systems

  title={A model for concurrency in nested transactions systems},
  author={Catriel Beeri and Philip A. Bernstein and Nathan Goodman},
  journal={J. ACM},
Today's standard model for database concurrency control, called serializability theory, represents executions of transactions as partial orders of operations. The theory tells when an execution is serializable, that is, when the set of operations of a transaction execute atomically with respect to those of other transactions. It has been used successfully to prove correctness of most database concurrency control algorithms. Its most serious limitation is its inability to represent nested… 

Figures from this paper

Formal model of correctness without serializabilty
This paper defines a transaction model that allows for several alternative notions of correctness without the requirement of serializability, and investigates classes of schedules for transactions that are richer than analogous classes under the classical model.
Transaction Synchronisation in Object Basesy
An analogue to the classical serialisability theorem is established and used to derive simple proofs of correctness of two concurrency control algorithms for object bases, namely Nested Two-Phase Locking (Moss' algorithm) and Nested Timestamp Ordering (Reed's algorithm).
A new formal model is presented for studying concurrency and resiliency properties for nested transactions and its use in stating and proving correctness conditions for two variations of a well-known algorithm of Moss is used.
Formal aspects of concurrency control in long-duration transaction systems using the NT/PV model
This work presents a new transaction model which allows correctness criteria more suitable for new database applications which require long-duration transactions, and combines three enhancements to the standard model: nested transactions, explicit predicates, and multiple versions.
Concurrency control issues in nested transactions
A model for nested transactions is proposed allowing for effective exploitation of intra-transaction parallelism, and it can be shown how “controlled downward inheritance” for hierarchical objects is achieved in nested transactions.
Formalization and Proof of Correctness of the Crash Recovery Algorithm for an Open and Safe Nested Transaction Model
This paper presents, formalize and proves the correctness of recovery algorithm for the authors' open and safe nested transaction model using I/O automaton model, which uses the notion of a recovery point subtransaction in the nested transaction tree to increase the potential concurrency.
A recovery model for cooperative computations
This chapter provides a formal model extending the notion of commit to the idea of commit-correctness that reflects the possibility of interactions between different actions by enabling them to commit together in the world of cooperative computations.
Transactional Tasks: Parallelism in Software Transactions
Transactional tasks have several useful properties: they are coordinated, they maintain serializability, and they do not introduce non-determinism, allowing the potential parallelism of a program to be fully exploited, while preserving the properties of the separate models where possible.
Concurrency control and recovery in transactional process management
The extended unified theory of concurrency control and recovery is extended by applying it to generalized process structures, i.e., arbitrary partially ordered sequences of transaction invocations, to provide a more flexible handling of concurrent processes while allowing as much parallelism as possible.


A concurrency control theory for nested transactions (Preliminary Report)
Serializability theory provides a method for modelling and analyzing the correctness of concurrency control algorithms and the concept of nested transaction has recently received much attention.
Nested Transactions: An Approach to Reliable Distributed Computing
The method for implementing nested transactions is novel in that it uses locking for concurrency control and the necessary algorithms for locking, recovery, distributed commitment, and distributed deadlock detection for a nested transaction system are presented.
Concurrency control for resilient nested transactions
A formal framework is developed for proving correctness of algorithms which implement nested transactions. In particular, a simple "action tree" data structure is defined, which describes the
Nested transactions and read-write locking
This proof extends earlier work on exclusive locking to prove that Moss's algorithm generates serially correct executions in the presence of concurrency and transaction aborts.
The serializability of concurrent database updates
Several efficiently recognizable subclasses of the class of senahzable histories are introduced and it is shown how these results can be extended to far more general transaction models, to transactions with partly interpreted functions, and to distributed database systems.
Formal Aspects of Serializability in Database Concurrency Control
It is shown why locking mechanisms lead to correct operation, it is shown that two proposed mechanisms for distributed environments are special cases of locking, and a new version of lockdng is presented that alows more concurrency than past methods.
Multiversion concurrency control—theory and algorithms
This paper presents a theory for analyzing the correctness of concurrency control algorithms for multiversion database systems and uses the theory to analyze some new algorithms and some previously published ones.
The implementation of an integrated concurrency control and recovery scheme
An efficient garbage collection algorithm for reclaiming storage space used by old versions of data objects that will no longer be accessed is presented and an on-line backup algorithm that will permit the backup procedure to run in parallel with regular transactions is proposed.
A theoretical foundation of multi-level concurrency control
Until recently concurrency control theory has focussed on one-level systems, I. 8. regarding schedules simply as sequences of read and write operatlons on objects of one particular abstractlon level
Efficient and correct execution of parallel programs that share memory
The analysis finds a minimal set of delays that enforces sequential consistency in the execution of parallel programs on shared-memory multiple-instruction-stream, multiple-data-stream (MIMD) computers and uses a conflict graph similar to that used to schedule transactions in distributed databases to do without locks.