Multidatabase Transactions Research Articles

Enhancing an Application Server to Support Available Components

Three-tier middleware architecture is commonly used for hosting enterprise-distributed applications. Typically, the application is decomposed into three layers: front end, middle tier, and back end. Front end (Web server) is responsible for handling user interactions and acts as a client of the middle tier, while back end provides storage facilities for applications. Middle tier (application server) is usually the place where all computations are performed. One of the benefits of this architecture is that it allows flexible management of a cluster of computers for performance and scalability; further, availability measures, such as replication, can be introduced in each tier in an application-specific manner. However, incorporation of availability measures in a multitier system poses challenging system design problems of integrating open, nonproprietary solutions to transparent failover, exactly once execution of client requests, nonblocking transaction processing, and an ability to work with clusters. This paper describes how replication for availability can be incorporated within the middle and back-end tiers, meeting all these challenges. This paper develops an approach that requires enhancements to the middle tier only for supporting replication of both the middleware back-end tiers. The design, implementation, and performance evaluation of such a middle-tier-based replication scheme for multidatabase transactions on a widely deployed open source application server (JBoss) are presented.

A reliable global atomic commitment protocol for distributed multidatabase systems

Many works on multidatabase transaction processing have been made in the past with the assumption of the absence of failures. This is because it has been shown that correct executions of multidatabase transactions cannot be achieved in the presence of failures without certain tradeoffs. In this paper, we first review the problems of preserving the global atomicity of multidatabase transactions in the presence of failures, while preserving local autonomy. Then, we propose a reliable global atomic commitment protocol that solves those problems. We show that the proposed protocol is correct and guarantees the global atomicity. We also present a practical approach that allows easy integration of existing local database systems into our multidatabase system environment. The most elegant feature of our protocol is that it guarantees global atomicity, even in the presence of failures, while the protocol preserves maximal local autonomy, and does not place any restriction on the multidatabase transactions that are often assumed in the literature.

A reliable global atomic commitment protocol for distributed multidatabase systems

Many works on multidatabase transaction processing have been made in the past with the assumption of the absence of failures. This is because it has been shown that correct executions of multidatabase transactions cannot be achieved in the presence of failures without certain tradeoffs. In this paper, we first review the problems of preserving the global atomicity of multidatabase transactions in the presence of failures, while preserving local autonomy. Then, we propose a reliable global atomic commitment protocol that solves those problems. We show that the proposed protocol is correct and guarantees global atomicity. We also present a practical approach that allows easy integration of existing local data base systems into our multidatabase system environment. The most elegant feature of our protocol is that it guarantees global atomicity even in the presence of failures while the protocol preserves maximal local autonomy, and does not place any restriction on the multidatabase transactions that are often assumed in the literature.

Using tickets to enforce the serializability of multidatabase transactions

To enforce global serializability in a multidatabase environment the multidatabase transaction manager must take into account the indirect (transitive) conflicts between multidatabase transactions caused by local transactions. Such conflicts are difficult to resolve because the behavior or even the existence of local transactions is not known to the multidatabase system. To overcome these difficulties, we propose to incorporate additional data manipulation operations in the subtransactions of each multidatabase transaction. We show that if these operations create direct conflicts between subtransactions at each participating local database system, indirect conflicts can be resolved even if the multidatabase system is not aware of their existence. Based on this approach, we introduce optimistic and conservative multidatabase transaction management methods that require the local database systems to ensure only local serializability. The proposed methods do not violate the autonomy of the local database systems and guarantee global serializability by preventing multidatabase transactions from being serialized in different ways at the participating database systems. Refinements of these methods are also proposed for multidatabase environments where the participating database systems allow schedules that are cascadeless or transactions have analogous execution and serialization orders. In particular, we show that forced local conflicts can be eliminated in rigorous local systems, local cascadelessness simplifies the design of a global scheduler, and that local strictness offers no significant advantages over cascadelessness.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Concurrency control and recovery of multidatabase work flows in telecommunication applications

In a research and technology application project at Bellcore, we used multidatabase transactions to model multisystem work flows of telecommunication applications. During the project a prototype scheduler for executing multi-database transactions was developed. Two of the issues addressed in this project were concurrent execution of multi-database transactions and their failure recovery. This paper discusses our use of properties of the application and the telecommunication systems to develop simple and efficient solutions to the concurrency control and recovery problems.

TOWARDS A MODEL FOR MULTIDATABASE TRANSACTIONS

In many application areas the information that may be of interest to a user is stored under the control of multiple, autonomous database systems. To support global transactions in a multidatabase environment, we must coordinate the activities of multiple Database Management Systems that were designed for independent, stand-alone operation. The autonomy and heterogeneity of these systems present a major impediment to the direct adaptation of transaction management mechanisms developed for distributed databases. In this paper we introduce a transaction model designed for a multidatabase environment. A multidatabase transaction is defined by providing a set of (local) sub-transactions, together with their precedence and dataflow requirements. Additionally, the transaction designer may specify failure atomicity and execution atomicity requirements of the multidatabase transaction. These high-level specifications are then used by the scheduler of a multidatabase transaction to assure that its execution satisfies the constraints imposed by the semantics of the application. Uncontrolled interleaving of multidatabase transactions may lead to the violation of interdatabase integrity constraints. We discuss the issues involved in a concurrent execution of multidatabase transactions and propose a new concurrency control correctness criterion that is less restrictive than global serializability. We also show how the multidatabase SQL can be extended to allow the user to specify multidatabase transactions in a nonprocedural way.