Compensation methods to support generic graph editing: A case study in automated verification of schema requirements for an advanced transaction model

Compensation plays an important role in advanced transaction models, cooperative work, and workflow systems. However, compensation operations are often simply written as a^−1 in transaction model literature. This notation ignores any operation parameters, results, and side effects. A schema designer intending to use an advanced transaction model is expected (required) to write correct method code. However, in the days of cut-and-paste, this is much easier said than done. In this paper, we demonstrate the feasibility of using an off-the-shelf theorem prover (also called a proof assistant) to perform automated verification of compensation requirements for an OODB schema. We report on the results of a case study in verification for a particular advanced transaction model that supports cooperative applications. The case study is based on an OODB schema that provides generic graph editing functionality for the creation, insertion, and manipulation of nodes and links

Compensation methods to support cooperative applications: A case study in automated verification of schema requirements for an advanced transaction model

Compensation plays an important role in advanced transaction models, cooperative work and workflow systems. A schema designer is typically required to supply for each transaction another transaction to semantically undo the effects of . Little attention has been paid to the verification of the desirable properties of such operations, however. This paper demonstrates the use of a higher-order logic theorem prover for verifying that compensating transactions return a database to its original state. It is shown how an OODB schema is translated to the language of the theorem prover so that proofs can be performed on the compensating transactions

Exploiting method semantics in client cache consistency protocols for object-oriented databases

PhD ThesisData-shipping systems are commonly used in client-server object-oriented databases. This is in- tended to utilise clients' resources and improve scalability by allowing clients to run transactions locally after fetching the required database items from the database server. A consequence of this is that a database item can be cached at more than one client. This therefore raises issues regarding client cache consistency and concurrency control. A number of client cache consistency protocols have been studied, and some approaches to concurrency control for object-oriented datahases have been proposed. Existing client consistency protocols, however, do not consider method semantics in concurrency control. This study proposes a client cache consistency protocol where method se- mantic can be exploited in concurrency control. It identifies issues regarding the use of method semantics for the protocol and investigates the performance using simulation. The performance re- sults show that this can result in performance gains when compared to existing protocols. The study also shows the potential benefits of asynchronous version of the protoco

An integrated concurrency control in object-oriented database systems.

First, the dissertation discusses three important issues of concurrency control in OODBs. These include conflict among methods, class hierarchy locking, and nested method invocations. The previous works for each issue are presented, and their advantages and disadvantages are also discussed. Then, an integrated concurrency control which addresses all three issues is proposed. For conflict among methods, a finer locking granularity, such as an attribute and an individual class object, is adopted for instance access and class definition access so that higher concurrency is achieved. Especially, for instance access, higher concurrency is obtained using run-time information. Also, locks are required for instance method invocations instead of atomic operation invocations so that locking overhead is reduced. For class hierarchy locking, locking overheads are reduced using special classes which are based on access frequency information on classes. Finally, for nested method invocations, semantic information is used in order to provide higher concurrency among methods. Also, parent/children parallelism is adopted for better performance.Finally, a performance study is conducted by means of simulation using the 007 benchmark. The simulation results show that, in terms of transaction response time and lock waiting time, the proposed scheme performs the best, Malta the second best, and Orion the worst.Object-oriented databases (OODBs) have been adopted for non-standard applications requiring advanced modeling power, in order to handle complex data and relationships among such data. One of the important characteristics in database system is manipulation of shared data. That is, database systems, including OODBs, allow shared data to be accessed by multiple users at the same time. Concurrency control is a mechanism used to coordinate access to the multi-user databases so that the consistency of the database is maintained. In order to provide good performance, it is very important that concurrency control schemes incur low overhead and increase concurrency among users. This dissertation presents a concurrency control scheme in OODBs that meets those requirements.Secondly, an analytical model is constructed to measure the performance of concurrency control in an OODB system. Using this model, the proposed technique is then compared with the two existing techniques, Orion and Malta. The analytical results show that the proposed scheme gives the best transaction response time, Malta the second best, and Orion the worst