Applying formal methods to semantic-based decomposition of transactions (original) (raw)
Related papers
Transaction decomposition using transaction semantics
Distributed and parallel databases, 1996
Serializability has been widely accepted as the correctness criterion for databases subject to concurrent access. However, in a number of the newer and most challenging application areas, serializable execution may not be feasible.
Using semantic knowledge of transactions to increase concurrency
1989
Abstract When the only information available about transactions is syntactic information, serializability is the main correctness criterion for concurrency control. Serializability requires that the execution of each transaction must appear to every other transaction as a single atomic step (ie, the execution of the transaction cannot be interrupted by other transactions). Many researchers, however, have realized that this requirement is unnecessarily strong for many applications and can significantly increase transaction response time.
Logical Transactions and Serializability
1998
The concept of logic databases can serve as a clear and expressive foundation of various kinds of information systems. However, classical logic languages refer to a single database state, whereas in modern information systems it is necessary to take dynamic behaviour into account. For this purpose, several update languages have been proposed, among them [1,5,6,9,16,17,18,23], which allow to specify complex transitions from one database state to another. From the evaluation point of view, a complex state transition can and should be considered as a transaction. Up to now, the isolation property of transactions has been poorly addressed in the context of logic update languages, although it is an important problem even for classical, sequential transactions (see
2021
Almost every database management system (DBMS) supporting transactions created in the last decade implements multi-version concurrency control (MVCC). But these systems rely on physical data structures (e.g., B+trees, hash tables) that do not natively support multi-versioning. As a result, there is a disconnect between the logical semantics of transactions and the DBMS’s underlying implementation. System developers must invest in engineering efforts to coordinate transactional access to these data structures and nontransactional maintenance tasks. This burden leads to challenges when reasoning about the system’s correctness and performance and inhibits its modularity. In this paper, we propose the Deferred Action Framework (DAF), a new system architecture for scheduling maintenance tasks in an MVCC DBMS integrated with the system’s transactional semantics. DAF allows the system to register arbitrary actions and then defer their processing until they are deemed safe by transactional ...
Concurrency and Communication in Transaction Logic
Iclp, 1996
In previous work, we developed Transaction Logic or T R , which deals with state changes in deductive databases. T R provides a logical framework in which elementary database updates and queries can be combined into complex database transactions. T R accounts not only for the updates themselves, but also for important related problems, such as the order of update operations, non-determinism, and transaction failure and rollback. In the present paper, we propose Concurrent Transaction Logic or CTR, which extends Transaction Logic with connectives for modeling the concurrent execution of complex processes. Concurrent processes in CTR execute in an interleaved fashion and can communicate and synchronize themselves. Like classical logic, CTR has a Horn" fragment that has both a procedural and a declarative semantics, in which users can program and execute database transactions. CTR is thus a deductive database language that integrates concurrency, communication, and updates. All this is accomplished in a completely logical framework, including a natural model theory and a proof theory. Moreover, this framework is exible enough to accommodate many di erent semantics for updates and deductive databases. For instance, not only can updates insert and delete tuples, they can also insert and delete null values, rules, or arbitrary logical formulas. Likewise, not only can databases have a classical semantics, they can also have the well-founded semantics, the stable-model semantics, etc. Finally, the proof theory for CTR has an e cient SLD-style proof procedure. As in the sequential version of the logic, this proof procedure not only nds proofs, it also executes concurrent transactions, nds their execution schedules, and updates the database. A main result is that the proof theory is sound and complete for the model theory.
Semantic concurrency control in object-oriented database systems
Proceedings of IEEE 9th International Conference on Data Engineering, 1993
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.
Database Programming in Transaction Logic
Workshops in computing, 1994
This paper presents database applications of the recently proposed Transaction Logic-an extension of classical predicate logic that accounts in a clean and declarative fashion for the phenomenon of state changes in logic programs and databases. It has a natural model theory and a sound and complete proof theory, but, unlike many other logics, it allows users to program transactions. In addition, the semantics leads naturally to features whose amalgamation in a single logic has proved elusive in the past. Finally, Transaction Logic holds promise as a logical model of hitherto non-logical phenomena, including so-called procedural knowledge in AI, and the behavior of object-oriented databases, especially methods with side effects. This paper focuses on the applications of T R to database systems, including transaction definition and execution, nested transactions, view updates, consistency maintenance, bulk updates, nondeterminism, sampling, active databases, dynamic integrity-constraints, hypothetical reasoning, and imperative-style programming.
Partial Re-Execution: Complex Reconciliation of Transactions to Increase Concurrency in Objectbases
Some recent work on enhancing concurrency in database systems has focused on using semantic information [Wei91]. One problem with this approach is that application designers must be sufficiently knowledgeable to determine, 'a priori, how the application semantics interact with the transaction model. Our approach exploits an object-oriented world and places this load on the transaction system which must be able to determine by static analysis how to maintain database consistency. We adopt an optimistic approach whereby each transaction is given its own copy (version) of all of the objects it needs to execute to completion without interruption from other processes. Within the context of concurrency, this paper uses the information from static analysis to develop algorithms which allow the compiler to generate reconciliation procedures automatically from the initial transaction specification. 1 Introduction Multiversioning for the purpose of enhancing concurrency and reliability is...
A framework for transactional consistency models with atomic visibility
Modern distributed systems often rely on databases that achieve scalability by providing only weak guarantees about the consistency of distributed transaction processing. The semantics of programs interacting with such a database depends on its consistency model, defining these guarantees. Unfortunately, consistency models are usually stated informally or using disparate formalisms, often tied to the database internals. To deal with this problem, we propose a framework for specifying a variety of consistency models for transactions uniformly and declaratively. Our specifications are given in the style of weak memory models, using structures of events and relations on them. The specifications are particularly concise because they exploit the property of atomic visibility guaranteed by many consistency models: either all or none of the updates by a transaction can be visible to another one. This allows the specifications to abstract from individual events inside transactions. We illus...