0 Stimmen dafür0 Stimmen dagegen

1 Aufrufe22 SeitenConcurrency control

Nov 17, 2018

© © All Rights Reserved

PDF, TXT oder online auf Scribd lesen

Concurrency control

© All Rights Reserved

Als PDF, TXT **herunterladen** oder online auf Scribd lesen

1 Aufrufe

Concurrency control

© All Rights Reserved

Als PDF, TXT **herunterladen** oder online auf Scribd lesen

- Db2 Luw Useful Commands
- NATURAL Programming
- BANKING SYSTEM Presentation made by NITIN, CHANDRA SHEKHER
- BEA_FORR_InformationFabric2_0
- Transport Synopis
- STU0018_PK
- dbfarm
- RC1801A12
- Pengantar Basis Data
- Data File (Autosaved)
- 2002 Replication Techniques in Distributed Systems Advances in Database Systems.9780792398004.29706
- HRM
- 4 - SM7 IE Class Slides, Module 4 (System-Wide Config) as of 10-28
- Test+Unit+2+Mod+2+Objective+1+ +6
- 2007
- Setting up Material Status Control
- Untitled
- POSMAN
- PGM 1
- What is Pragma Autonomous Transaction_ Plz Can u Let Me Know It in a Simple Understandable Way.thanks in Advance

Sie sind auf Seite 1von 22

Systems?

1 2 2

1304 W. Springeld Avenue, Urbana, IL 61801, USA

2 Lucent Technologies, 600 Mountain Ave, Murray Hill, NJ 07974, USA

Abstract. Over the past decade, signicant research has the execution of the global transactions. These systems

been done towards developing transaction management were designed to only provide read accesses to remote

algorithms for multidatabase systems. Most of this work data. However, even if each global transaction is read-

assumes a monolithic architecture of the multidatabase only, it can be shown Mehrotra et. al. 1992a, that the

system with a single software module that follows a sin- resulting schedule may be non-serializable and the read-

gle transaction management algorithm to ensure the con- only global queries may retrieve inconsistent data. Trans-

sistency of data stored in the local databases. This mono- action management issues, and the diculty in support-

lithic architecture is not appropriate in a multidatabase ing updates in a MDBS environments were subsequently

environment where the system spans multiple dierent discussed in Gligor et. al., 1984, 1985, 1986; Brietbart et.

organizations that are distributed over various geograph- al., 1988, 1990; Mehrotra et. al. 1992d; Elmagarmid et.

ically distant locations. In this paper, we propose an al- al., 1989. The diculty arises due to the following two

ternative multidatabase transaction management archi- characteristics of MDBS environments:

tecture, where the system is hierarchical in nature. Hi- { Heterogeneity. Each local DBMS may follow dif-

erarchical architecture has consequences on the design ferent concurrency control protocols and recovery al-

of transaction management algorithms. An implication gorithms.

of the architecture is that the transaction management { Autonomy. The participation of a local DBMS in

algorithms followed by a multidatabase system must be the MDBS must not result in a loss of control by the

composable{ that is, it must be possible to incorporate local DBMS over its data and its local transactions.

individual multidatabase systems as elements in a larger

multidatabase system. We present a hierarchical archi- Over the past decade, signicant research has been

tecture for a multidatabase environment and develop done to identify mechanisms for eectively dealing with

techniques for concurrency control in such systems. the problems that arise due to the heterogeneity and

the autonomy of the local systems, E.g., Pu 1988; Bre-

Key words: Database Management { Concurrency Con- itbart et. al., 1988, 1990; Wolski et. al., 1990; Mehrotra

trol { Distributed Databases { Multidatabase Manage- et. al., 1992a, 1992b; Elmagarmid et. al., 1990; Batra

ment et. al., 1992. This research has resulted in transaction

management algorithms that ensure correctness without

sacricing the autonomy of the individual systems. A

large number of these proposed solutions have, however,

considered the MDBS as a centralized software mod-

1 Introduction ule. Clearly, if the local DBMSs are geographically dis-

tributed over dierent nodes of a world-wide computer

A multidatabase system (MDBS) is a facility, developed network, then having a centralized MDBS will result in

on top of local database management systems (DBMSs), numerous undesirable consequences. For example, un-

that provides users of a DBMS access to data located der high global transaction load, the site at which the

in other heterogeneous data sources. Early prototype MDBS software resides will become a bottleneck result-

MDBSs built Templeton 1983; Breitbart et. al. 1985; ing in the degradation of the system performance. More

Landers et. al. 1982 ignored the transaction management importantly, a failure of the site at which the MDBS re-

problem and did not support any scheme to coordinate sides will result in the MDBS being unavailable for pro-

? Work partially supported by NSF grants IRI-8805215, IRI- cessing global transactions even though the transactions

9003341 and IRI-9106450, and by a grant from the IBM were to execute at only the sites that are operational.

corporation. Some of the above problems will be alleviated if

Correspondence to : Sharad Mehrotra the MDBS follows a distributed transaction manage-

2 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

ment algorithm for concurrency control. A distributed architecture. In Sections 4-6, we describe our mechanism

mechanism for concurrency control in MDBSs have been for concurrency control in hierarchical MDBSs. Section 7

suggested in Batra et. al. 1992. However, developing the is on related work. Finally, in Section 8, we oer con-

MDBS as a monolithic system in which the MDBS uses a cluding remarks and present directions for future work.

single transaction management algorithm, whether dis- Proofs of the theorems developed in the paper are in-

tributed or centralized, may still be undesirable. To cluded in the appendix.

see this, let us consider a typical MDBS environment

in which users wish to execute transactions that span

database systems belonging to multiple branches of an 2 Transaction Management in MDBSs

organization. Additionally, users also wish to execute

transactions that span dierent autonomous organiza-

tions. One way to provide such a service is to develop The transaction management problem in MDBSs con-

a single monolithic MDBS system which integrates all sists of developing a software module to facilitate the

the branches of all the organizations. However, depend- execution of transactions that may span multiple het-

ing upon the nature of transactions that execute within erogeneous and autonomous local DBMSs. If each lo-

an organization, the computing resources available, and cal DBMS follows the two-phase locking protocol Bern-

the reliability of the network, dierent organizations may stein et. al., 1987, is capable of participating in a two-

prefer dierent MDBS transaction management algo- phase commit protocol Bernstein et. al. 1987, and con-

rithms for processing transactions local within the or- forms to the X/Open DTP standard Gray et. al. 1993,

ganization. For example, if a high degree of concurrency then, from the perspective of transaction management,

is critical for good performance in a certain organiza- the local DBMSs can be integrated using existing trans-

tion, that organization may prefer a centralized MDBS action processing monitors (e.g., Encina by Transarc)

transaction management algorithm for processing trans- Gray et. al. 1993. There are three major reasons why

actions local within the organization. On the other hand, this approach is unacceptable. These reasons collectively

if databases belonging to various branches of another or- have motivated the research on transaction management

ganization are geographically distant and the network is in MDBSs.

not reliable, the organization may prefer a fully decen- First, the local DBMSs may be pre-existing legacy

tralized MDBS transaction management algorithm for systems that may have been developed independently,

processing transactions that execute within its dierent without any regard that these systems will be integrated

branches. Thus, it is preferable to develop the MDBS as into an MDBS on a later date. Legacy DBMSs may not

a hierarchical system{ each organization (or a set of or- adhere to current standards and may not even support

ganizations) has its own MDBS to control the execution an interface for the execution of the two-phase commit

of transactions within the organization. Furthermore, an protocol. Requiring that the data from these pre-existing

inter-organization MDBS controls the execution of trans- systems be migrated to a new system that is capable of

actions that access data belonging to branches of dier- interoperation may not be a feasible cost-eective solu-

ent organizations. Note that using a single monolithic tion to integration. Second, it is possible that the lo-

MDBS system, whether distributed or centralized, will cal DBMSs are highly specialized data management sys-

adversely impact the performance of transactions that tems (as contrasted to general-purpose systems) which

execute within an organization. In contrast, in a hier- have been developed for a specic application domain

archical MDBS, each organization can use a specialized and they use special-purpose concurrency control and

transaction management algorithm suited for their envi- recovery algorithms. For example, a local DBMS may

ronment. be a full-text database system used within an organiza-

The above scenario illustrates why it is desirable for tion for storage and retrieval of oce documents. Such

the MDBS architecture to be hierarchical. If the archi- a system may use a special-purpose transaction process-

tecture of the MDBS is hierarchical, dierent component ing scheme to preserve consistency of the document in-

MDBSs may follow dierent transaction management al- dex. It may not be possible to integrate such specialized

gorithms for ensuring consistency of the data they inte- \home-brewed" local DBMSs into an MDBS using exist-

grate. However, the transaction management algorithms ing transaction processing monitors. Another compelling

followed by individual MDBSs must be such that it is reason why existing transaction processing software does

feasible to compose the MDBSs into a larger MDBS. not suce for the task of MDBS integration is that

In this paper, we present a hierarchical architecture for the usage of standard transaction management proto-

multidatabase systems. We adopt serializability as the cols (viz., the two-phase commit protocol) results in the

correctness criterion and study how existing techniques violation of the local autonomy Breitbart et. al., 1990,

for ensuring global serializability in MDBS environments 1992a, 1992b; Vaijalainen et. al., 1990; Mehrotra et. al.,

can be extended to ensure serializability in hierarchical 1992b. This is due to the fact that a two-phase commit

MDBSs. protocol requires transactions to hold onto their locks

The rest of the paper is organized as follows. In Sec- (even at remote sites) for an unbounded period of time

tion 2, we discuss the motivation behind the transaction under certain adverse conditions Bernstein et. al. 1987;

management problem in MDBSs and provide a summary Gray et. al. 1993. This can be viewed as a violation of

of the progress that has been made over the last decade the local autonomy since it results in a local system los-

in this area. In Section 3, we formally dene our MDBS ing control over its data and its applications.

Concurrency Control in Hierarchical Multidatabase Systems 3

Most of the approaches developed for transaction other executes concurrently with a transaction that reads

management in MDBSs treat local DBMSs as \black both the accounts, then it is possible that the transac-

boxes" that cannot be modied for the sake of inte- tion that reads both the accounts sees a sum that diers

gration. Furthermore, in keeping with the autonomy re- from the true balance of the two accounts which may be

quirement, which dictates that the applications local to unacceptable. Thus, even though each transaction sees

a DBMS execute completely under its control, transac- a consistent state (that is, a state in which no data in-

tions are classied into two classes: local transactions tegrity constraints are violated) and the nal state of the

that execute at a single DBMS; and global transactions database is consistent, the execution is still undesirable.

that accesses more than one DBMS. While global trans- The reason why preservation of data integrity con-

actions execute under the control of the MDBS soft- straint may not be sucient consistency guarantee is

ware, local transactions execute outside its control. Each that it is impossible to capture all the consistency re-

local DBMS is assumed to support an interface using quirements of the executions using integrity constraints

which operations belonging to subtransactions of global over the data. This is a surprising observation since

transactions can be submitted for execution to the lo- most standard text on databases and concurrency con-

cal DBMS. The nature of the interface supported aects trol Bernstein et. al. 1987; Papadimitriou 1986; Gray et.

the transaction management mechanism, including the al., 1993 motivate the need for serializability using the

mechanism developed in this paper, and we will discuss preservation of data integrity constraints as the theoret-

its impact after we have developed our scheme. Further- ical basis of correctness.

more, it is assumed that each local DBMS ensures ACID Another signicant body of research exists on mech-

properties of (sub)transactions that access data at the anisms to ensure serializability in MDBS environments

DBMS. That is, each local DBMS ensures serializabil- Breitbart et. al., 1988, 1990; Wolski et. al., 1990; Pu

ity of the schedule local to it, and atomicity of the local 1988; Mehrotra et. al., 1992a; Elmagarmid et. al., 1990.

transactions and the subtransactions of the global trans- One of the rst signicant approaches developed was in

actions that access data at its site. Pu 1988 where a notion of o-element was introduced.

Research on transaction management in MDBSs has An o-element corresponding to a transaction is one of

been done along two complementary directions. A sig- its operations that satises the following property| if a

nicant amount of work has been done to develop cor- transaction T1 is serialized before transaction T2, then

rectness criteria that are weaker than serializability, but the o-element of T1 occurs before the o-element of T2 .

nonetheless, can be implemented relatively eciently in Using the notion of o-elements, the authors developed a

an environment where local DBMSs may follow hetero- validation based protocol that ensures serializability in

geneous transaction management protocols. These ap- an MDBS environment. Similarly, in Elmagarmid et. al.

proaches are based on the assumption that the data in- 1990, the authors developed a scheme based on conserva-

tegrity constraints in an MDBS environment are of a tive timestamp ordering using the notion of o-elements

restricted nature. For example, it may be reasonable to (they refer to the o-element as the the serialization

assume that there are no data integrity constraints be- event). In Mehrotra et. al. 1992a, it was shown that a no-

tween data residing at two autonomous local DBMSs. tion similar to o-elements can be used to reduce the prob-

Such a restriction on the nature of data integrity con- lem of ensuring serializability in MDBSs to that of ensur-

straints can be exploited to develop correctness crite- ing serializability in traditional DBMSs. Using the reduc-

ria, weaker than serializability, that preserve the con- tion, any of the concurrency control schemes developed

straints. Two examples of this approach are the no- for traditional DBMSs can be used to ensure serializabil-

tion of quasi-serializability (QSR) Du et. al. 1989 and ity in MDBSs. This is a signicant step in understanding

two-level serializability (2LSR) Mehrotra et. al. 1991. In the concurrency control problem in MDBSs since it ef-

Mehrotra et. al. 1991, besides developing the correct- fectively overcomes the problems resulting from hetero-

ness criterion 2LSR, a spectrum of MDBS models for geneity without jeopardizing the autonomy of the local

which 2LSR ensures data integrity constraints is ex- DBMSs. It provides a framework for design and devel-

plored. Protocols for ensuring 2LSR have been developed opment of the concurrency control schemes for MDBSs,

in Mehrotra et. al. 1992c;Ouzzani et. al. 1995. and facilitates comparison between previously published

The limitation of the above mentioned approaches schemes that were developed in an ad-hoc fashion.

lies not only in their inapplicability in domains where the Much of the previous work on MDBS transaction

restrictions on data integrity constraints are not valid, management discussed above has not considered the im-

but as argued in Mehrotra et. al. 1992c, preservation of pact of the MDBS architecture on the design of the trans-

the data integrity constraint may itself not be a su- action management software. As discussed in the intro-

cient consistency guarantee{ that is, executions that pre- duction, there are compelling reasons for MDBSs to be

serve all data integrity constraints may still be incorrect developed as hierarchical systems. In the remainder of

from the perspective of the user. To see this, consider the paper, we describe a hierarchical transaction man-

an MDBS consisting of two banking databases located agement architecture for MDBSs and study how existing

at sites s1 and s2 . Further, let A1 and A2 be two ac- techniques for ensuring serializability in MDBSs can be

counts belonging to banking databases at sites s1 and extended to ensure serializability in hierarchical MDBSs.

s2 respectively such that there is no data integrity con- Concurrency control techniques for hierarchical MDBSs

straint that relates the two accounts. In such a case, if a have previously been studied in Pu 1988 in the context of

transaction that transfers money from one account to the the superdatabase architecture. However, the developed

4 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

hierarchical architecture. We will provide a detailed com-

parison of our scheme with the superdatabase approach

in Section 7.

Notice that in this paper, we will only study how

approaches to ensuring serializability can be extended DBMS2 DBMS3 DBMS4

to ensure serializability in hierarchical MDBSs. Concur-

rency control schemes and the consistency guarantees Fig. 1. An Example MDBS Environment

that results in hierarchical MDBSs in which dierent

MDBSs in the hierarchy may follow dierent correct- D1 D2

ness criteria (e.g., 2LSR, QSR) is not addressed and is

an interesting avenue for future work. Furthermore, we

did not consider the issue of failure-resilience in this pa-

per. Failure-resilience is complicated since the require-

ment of autonomy preservation renders the usage of two-

phase commit protocol Bernstein et. al. 1987 unsuitable DB1 DB2 DB3 DB4

for MDBS environments. In the absence of two-phase Fig. 2. Domain Ordering for Figure 1

commit protocol, it is possible that certain subtrans-

actions of a multi-DBMS transaction commit, whereas

others abort, thereby violating the atomicity property. of read (denoted by ri ) and write (denoted by wi) oper-

The problem of ensuring atomicity in MDBS environ- ations. This assumption is not central to the approach,

ments has been studied in Breitbart et. al., 1990; Wolksi and is made only for pedagogical reasons for develop-

et. al., 1990; Mehrotra et. al., 1992b, 1992d; Zhang et. ment of the examples. Further, each transaction Ti has

al., 1994. These approaches can be suitably adapted to begin (denoted by bi), and commit (denoted by ci) or

achieve fault-tolerance in hierarchical MDBSs. However, abort (denoted by ai ) operations. A transaction that

due to space limitations, we do not further address this executes at multiple DBMSs may have multiple begin

issue. and commit (or abort) operations1 , one for each DBMS

at which it executes. We denote by bik and cik (aik ), the

begin and commit (abort) operations of a transaction Ti

3 Hierarchical MDBS Architecture in DBMSk respectively.

A transaction Ti is said to execute in a domain D 2

An MDBS is an integrated collection of pre-existing local , if there exists a DBj , DBj v D, such that Ti accesses

databases: DBMS1 , DBMS2 , : : :, DBMSm , that permits data items in DBj . A transaction Ti may execute in mul-

users to execute transactions that access multiple local tiple domains subject to the restriction that if Ti accesses

DBMSs. Each DBMSi contains a set of data items that data items in DB1 ; DB2 ; : : :; DBk , then there must ex-

are denoted by DBi . To describe the architecture of the ist a domain D 2 such that DBj v D, j = 1; 2; : : :; k.

MDBS, we associate with the MDBS environment a set Such a domain D is denoted by Dom(Ti ). Thus, if Ti

of domains denoted by with an ordering relation @. A accesses data item in DBj , then DBj v Dom(Ti ). A

domain D 2 is either transaction Ti is said to be global with respect to a do-

D 2 , denoted by global(Ti ; D), if Ti executes in

{ a set of data items in DBi , for some i = 1; 2; : : :; m, main D and there exists a domain D0 , D0 6v D and D 6v D0

or that Ti executes in D0 . A transaction Ti is local

{ a union of the set of data Sitems in other domains such with respect to a domain D, denoted by local(Ti ; D), if

D1 ; D2 ; : : :; Dn , denoted by fD1 ; D2 ; : : :; Dn g, where Ti executes in D and :global(Ti ; D). We illustrate the

Di 2 , i = 1; 2; : : :; n, above dened notations by the following example.

The ordering relation @, referred to as the domain or-

dering relation, is such that Di @ Dj i Di Dj . We Example 1: Consider an MDBS environment con-

use Di v Dj to denote that either Di @ Dj or Di = Dj . sisting of four local DBMSs as illustrated in Figure 1.

Let Di and Dj be domains in . We refer to Di as the The set of domains, =S fDB1 ; DB2 ; DB3 ; DB4 ; D1; D2g,

child of Dj , denoted by child(Di ; Dj ), if Di @ Dj and where Sdomain D1 = fDB1 ; DB2 ; DB3 g and domain

for all Dk 2 , either Di 6@ Dk or Dk 6@ Dj . We refer D2 = fDB3 ; DB4 g. The domain ordering relation for

to Dj as a parent of Di , denoted by parent(Dj ; Di ), if the MDBS environment depicted in Figure 1 is illus-

child(Di ; Dj ). We refer to a domain Dj as a simple do- trated in Figure 2.

main if for all Di such that parent(Dj ; Di ), Di = DBk Suppose a transaction T1 accesses data items in do-

for some local DBMS. That is, a simple domain is sim- mains DB1 and DB2 . Then,

ply a collection of local DBMSs. We denote the set of Dom(T1 ) = D1 , global(T1 ; DB1 ), global(T1 ; DB2 ), and

domains fDj for all Dk 2 ; D 6@ Dk g by TOP. contrast, the ri and wi operations of the transaction on each

A transaction Ti = (OTi ; Ti ), where OTi is the set dataInitem

1

of operations and Ti is a partial order over operations problem ofare unique. Since, in this paper, we do not consider the

replica control, we consider dierent copies of the same

in OTi . We assume that a transaction Ti that executes at data item as independent data items with an equality constraint

a local DBMS (or a set of local DBMSs) consists of a set between them.

Concurrency Control in Hierarchical Multidatabase Systems 5

data in domains DB3 and DB4 . Then, global(T2 ; D1 ),

global(T2 ; D2 ) and Dom(T2 ) = D2 . Finally, suppose a

transaction T3 wishes to access data in DB1 and DB4 .

T3 will not be permitted to execute since there does

not exist any domain D 2 such that DB1 @ D

as wellSas DB4 @ D. However, if there was a domain DB1 DB2 DB3 DB4

D3 = fD1 ; D2g, then the transaction T3 would be per-

mitted and Dom(T3 ) = D3 . T1 T2 T2 T3 T4 T1 T3 T4

Fig. 3. Example of a Non-serializable Execution

Let S = (S ; S ) be a schedule, where S is a set of

transactions and S is a partial order over the operations to ensure global serializability.

belonging to transactions in S . The partial order S

satises the property that Ti S , for each Ti 2 S . Example 2: Consider an MDBS environment con-

Let d be a set of data items. S d denotes the projection sisting of local databases: DBMS1 with data item a,

of S onto data items in d. Formally, schedule S d is a DBMS2 with data item b, DBMS3 with data item c,

restriction2 of the schedule S over the set of data items and DBMS4 with data item d. Let the domain order-

in d. For notational brevity, we denote the projection of ing relation be as illustrated in Figure 3. The set of

S over the set of data items in DBk ; that is, S DBk , by

Sk . domainsS = fDB1 ; DB2 ; DB3 ; DBS4 ; D1; D2 g, where

In a schedule S = (S ; S ), transactions Ti ; Tj 2 S D1 = fDB1 ; DB2 ; DB3 g, and D2 = fDB2 ; DB3 ; DB4 g.

are said to con ict, denoted by Ti S Tj , if there exists Consider the following transactions T1 , T2 , T3, and T4:

operations oi in Ti and oj in Tj such that oi and oj T1 : b11 w11(a) b13 w13(c) c11 c13

con ict in S and oi S oj . Operations oi and oj are said T2 : b22 w22(b) b21 w21(a) c21 c22

to con ict if they access the same data item and at least T3 : b34 w34(d) b32 w32(b) c32 c34

one of them is a write operation. We denote the transitive T4 : b43 w43(c) b44 w44(d) c44 c43

closure of the con ict relation S among transactions in

a schedule S by the relation S . Note that Dom(T1 ) = D1, Dom(T2 ) = D1 , Dom(T3 ) =

With each domain Di a domain manager DM(Di ) is D2 and Dom(T4 ) = D2. Consider a schedule S resulting

associated. The domain manager for a domain Di , along from the concurrent execution of transactions T1, T2 , T3 ,

with the domain managers of each domain Dj , Dj @ Di , and T4 such that the local schedules at DBMS1 , DBMS2 ,

controls the concurrent execution of transactions that DBMS3 and DBMS4 are as follows:

execute in Di in such a way that the consistency of data S1 : b11 w11(a) b21 w21(a) c11 c21

within a domain is preserved. Let D be a domain such S2 : b22 w22(b) b32 w32(b) c22 c32

that DBj @ D, j = 1; 2; : : :; k. The domain managers of S3 : b43 w43(c) b13 w13(c) c43 c13

the domains D0 v D, in our architecture, constitute the S4 : b34 w34(d) b44 w44(d) c34 c44

MDBS software for an MDBS that integrates DBMS1 ,

DBMS2 , : : :, DBMSk . Note that if there exists a simple Note that the above schedule S is not serializable, even

domain D 2 such that for each DBk , k = 1; 2; : : :; m, though for each domain D 2 , the schedules S D are

parent(D; DBk ), then our MDBS architecture reduces serializable.

to a single monolithic system. In this case, the existing

solutions for transaction management developed for such To ensure global serializability, besides ensuring se-

systems in Mehrotra et. al., 1992a; Elmagarmid et. al., rializability of S D , for each D 2 , we need to impose

1990; Brietbart et. al., 1990 can be used by the domain certain restrictions on the domain hierarchy . In Sec-

manager for D to control the concurrent execution of the tion 5, we develop a concurrency control mechanism for

transactions. ensuring serializability of the schedule S D . In Section 6,

we identify the required restrictions on such that the

mechanism for ensuring serializability of S D (developed

4 Concurrency Control in Hierarchical MDBSs in Section 5) is sucient to ensure global serializability.

The remainder of this section is devoted to developing a

In this section, we present a framework for the de- design framework on which our mechanism for ensuring

sign of concurrency control mechanisms for hierarchical serializability of the schedule S D (in Section 5) is based.

MDBSs. In a hierarchical MDBS, for the global schedule Before we discuss how serializability of the schedule

S to be serializable, the projection of S onto data items S D can be ensured for an arbitrary domain in the domain

in each domain D 2 (that is, S D ) must be serializable. hierarchy, let us rst consider how it can be ensured for

However, as illustrated in the following example, ensur- a simple domain. Since a simple domain consists of a col-

ing serializability of S D , for each D 2 , is not sucient lection of local DBMSs, serializability of S D can be en-

sured using the techniques developed for ensuring global

2 A set P with a partial order

P on its elements is a restric-

serializability in monolithic MDBSs. Below, we develop

1

tion of a set P2 with a partial order P on its elements if P1 P2 ,

1

a mechanism for ensuring serializability of S D for simple

and for all e1 ; e2 2 P1 , e1 P e2 if and only if e1 P e2 .

1

2

2 domains which is based on the technique for ensuring

6 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

global serializability in monolithic MDBSs developed in denote its projection to its serialization function values

Mehrotra et. al. 1992a. Crucial to the mechanism is the over the local DBMSs as a transaction T~iD . Formally, T~iD

notion of serialization functions Mehrotra et. al. 1992a, is dened as follows.

which is similar to the notion of o-element developed in

Pu 1988 and that of the serialization event introduced Denition 1: Let Ti be a transaction and D be a

in Elmagarmid et. al. 1990. simple domain such that global(Ti ; DBk ) for some DBk ,

Let S = (S ; S ) be a serializable schedule. Let 0 where child(DBk ; D). T~iD is a restriction of Ti consisting

S . A serialization function of a transaction Ti 2 0 in of all the operations in the set

a schedule S with respect to the set of transactions 0, fserSk (Ti ) j Ti executes in DBk ;

denoted by serS; 0 (Ti ) is a function that maps Ti 2 0 to and child(DBk ; D)g

some operation in Ti such that the following holds:

Further, for the global schedule S, we dene a sched-

For all Ti ; Tj 2 0 , if Ti S Tj , then serS; 0 (Ti ) S ule S~D to be the restriction of S consisting of the

serS; 0 (Tj ) set of operations belonging to transactions T~iD . Thus,

In the remainder of the paper, we will denote the func- S~D = (S~D ; S~D ), where

tion serS; 0 by serS . The set of transactions 0 will be S~D = fT~iD j global(Ti ; DBk ) for some DBk ;

clear from the context. For numerous concurrency con- where child(DBk ; D)g,

trol protocols that generate serializable schedules, it is

possible to associate a serialization function with trans- and for all operations oq ; or in S~D , oq S~D or , i

actions Ti in the schedule S such that the above property oq S or . In the schedule S~D the con
ict between oper-

is satised. ations is dened as follows:

For example, if the timestamp ordering (TO) concur-

rency control protocol is used to ensure serializability of Denition 2: Let S be a global schedule. Opera-

S and the scheduler assigns timestamps to transactions tions serSk (Ti ) and serSl (Tj ) in schedule S~D , Ti 6= Tj ,

when they begin execution, then the function that maps are said to con
ict if and only if k = l.

every transaction Ti 2 S to Ti 's begin operation is a se-

rialization function for transaction Ti in S with respect It is not too dicult to show that the serializabil-

to the set of transactions S . ity of the schedule S D can be ensured by ensuring the

For a schedule S, there may be multiple serialization serializability of the schedule S~D . Essentially, ensuring

functions. For example, if S is generated by a two-phase serializability of S~D enforces a total order over global

locking (2PL) protocol, then a possible serialization func- transactions (with respect to the local DBMSs), such

tion for transactions in S maps every transaction Ti 2 S that if Ti occurs before Tj in the total order, then serSk

to the operation that results in Ti obtaining its last lock. operation of Ti occurs before serSk operation of Tj for all

Alternatively, the function that maps every transaction sites sk at which they execute in common, thereby en-

Ti 2 S to the operation that results in Ti releasing its suring serializability of S D (see Mehrotra et. al. 1992a

rst lock is also a serialization function for Ti in S. for a detailed explanation).

It is possible that for transactions in a schedule gen- Notice that operations in the schedule S~D consist of

erated by certain concurrency control protocols, no se- only global transactions. Thus, since global transactions

rialization function may exist. For example, in a sched- execute under the control of the MDBS software, the

ule generated by serialization-graph testing (SGT) sched- MDBS software can control the execution of the opera-

uler, it may not be possible to associate a serialization tions in S~D to ensure its serializability thereby ensuring

function with transactions. However, in such schedules, serializability of S D . How this can be achieved| that

serialization functions can be introduced by forcing di- is, how the MDBS software can ensure serializability of

rect con
icts between transactions Georgakopoulos et. S~D is a topic of the next section. Recall that the above

al., 1991. Let 0 be a set of transactions in a sched- described mechanism for ensuring serializability of S D

ule S. If each transaction in 0 executed a con
icting has been developed under the assumption that D is a

operation (say a write operation on data item ticket) in simple domain. In the remainder of this section, we ex-

S, then the functions that maps a transaction Ti 2 0 tend the mechanism suitably to ensure serializability of

to its write operation on ticket is the serialization func- the schedule S D for an arbitrary domain D. One way we

tion for the transactions in S with respect to the set of can extend the mechanism to arbitrary domain in hier-

transactions 0 . archical MDBSs is by suitably extending the notion of

Associating serialization functions with global trans- the serialization function to the set of domains.

actions makes the task of ensuring serializability of S D

relatively simple. Since at each local DBMS, the order Denition 3: Let D be any arbitrary domain in .

in which transactions that are global with respect to the An extended serialization function is a function sf(Ti ; D)

local DBMSs are serialized is consistent with the order that maps a given transaction Ti , and a domain D, to

in which their serSk operations execute, serializability of some operation of Ti that executes in D such that the

S D can be ensured by simply controlling the execution following holds:

order of the serSk operations belonging to the transac-

tions global with respect to the local DBMSs. To see how For all Ti ; Tj , if global(Ti ; D), global(Tj ; D), and

this can be achieved, for a global transaction Ti let us Ti S D Tj , then sf(Ti ; D) S D sf(Tj ; D).

Concurrency Control in Hierarchical Multidatabase Systems 7

transaction Ti with respect to the domain D. To see D3

how such a serialization function will aid us in ensur- #l

ing serializability within a domain, consider a domain #

# l

D 6= DBk , k = 1; 2; : : :; m. To develop the intuition, let D1 # ll D2

us assume that the above dened serialization function T A

exists for transactions in every child domain of D; that T A

is, for every Dk , where child(Dk ; D). If such a serializa- T A

tion function can be associated with the child domains, T AA

we can simply use the mechanism developed for simple DB1 DB2 DB3 DB4

domains to ensure serializability of S D . We will, how-

ever, have to appropriately extend our denitions of the Fig. 4. Domain Ordering for Example 3

transaction T~iD , and the schedule S~D with respect to the

newly dened serialization function. This is done below.

Denition 4: Let Ti be a transaction and D be and by assumption the schedule at each local DBMS is

a domain such that global(Ti ; Dk ) for some Dk , where serializable. Thus, if we can associate an appropriate se-

child(Dk ; D). T~iD is a restriction of Ti consisting of all rialization function sf with transactions in each domain

the operations in the set fsf(Ti ; Dk ) j Ti executes in Dk , D 2 , we can ensure serializability of S D , by ensur-

and child(Dk ; D) g. ing serializability of S~D for all domains D 2 . Note

As before, schedule S~D is simply the schedule con- that for a domain D = DBk , the function sf is simply

sisting of the operations in the transactions T~iD . That is, the function serSk introduced earlier. We now dene the

function sf for an arbitrary domain D 2 , which is

S~D = (S~D ; S~D ), where done recursively over the domain ordering relation.

S~D = fT~iD j global(Ti ; Dk ) Denition 6: Let D be a domain and Ti be a trans-

for some Dk , where child(Dk ; D)g, action such that global(Ti ; D). The serialization function

and for all operations oq ; or in S~D , oq S~D or , i for transaction Ti in domain D is dened as follows:

oq S or . Similar to the case of simple domain, two op- ser (T ); if forsf(T i ; D) =

erations in S~D , where D is an arbitrary domain, con ict Sk i some DBk , D = DBk :

if they are both serialization function values of dierent serS~D (T~iD ); if for all DBk , D 6= DBk

transactions over the same child domain:

Denition 5: Let S be a global schedule. Operations

sf(Ti ; Dk ) and sf(Tj ; Dl ) in schedule S~D , Ti 6= Tj , are Let us illustrate the above denition of the serializa-

said to con ict if and only if k = l. tion function using the following example.

It it not dicult to see that similar to the case of sim- Example 3: Consider an MDBS environment con-

ple domains, serializability of S D can be ensured, where sisting of local databases: DBMS1 with data item a,

D is an arbitrary domain, by ensuring the serializabil- DBMS2 with data item b, DBMS3 with data item c, and

ity of the schedule S~D under the assumption that for all DBMS4 with data item d. Let the domain ordering rela-

child domains Dk of D, the schedule S Dk is serializable tion be as illustrated in Figure 4. The set of domains:

and further a serialization functions sf can be associ- = fDB1 ; DB2 ; DB3 ; DB4 ; D1 ; D2; D3g;

ated with transactions that are global with respect to SfDB ; DB g, D = SfDB ; DB g, and

Dk (see Lemma 1 in the appendix for a formal proof). where D S 1 = 1 2 2 3 4

In fact this result can be applied recursively over the do- D3 = fD1 ; D2g. Consider the following transactions

main hierarchy to ensure serializability of the schedules T1, T2 , and T3 that execute:

S D for arbitrary domains D in hierarchical MDBSs. To T1 : b11 w11(a) b13 b14 w13(c) w14(d) c11 c13 c14

see this, consider a hierarchical MDBS shown in Figure 4. T2 : b22 w22(b) b24 b23 w23(c) w24(d) c22 c24 c23

To ensure serializability of S D , it suces to ensure se-

3

T3 : b31 w31(a) b32 w32(b) c31 c32

rializability of the schedule S~D , under the assumption

3

1 2 Note that Dom(T1 ) = D3 , Dom(T2 ) = D3 , and Dom(T3 ) =

appropriate serialization function sf can be associated D1 . Further, global(T1 ; D1), global(T2 ; D1 ) and local(T3 ; D1).

with transactions that are global with respect to D1 and Similarly, global(T1 ; D2 ), global(T2 ; D2 ). Consider the

D2 . In turn, serializability of S D (S D ) can be ensured

1 2 global schedule S resulting from the concurrent execu-

by ensuring that the schedule S~D (S~D ) is serializable,

1 2 tion of transaction T1 , T2 and T3 such that the local

under the assumption that S DB and S DB (S DB and

1 2 3 schedules at DBMS1 , DBMS2 , DBMS3 and DBMS4 are

S DB ) are serializable and further that an appropriate

4 as follows:

serialization function sf can be associated with trans- S1 : b11 w11(a) b31 w31(a) c11 c31

actions that are global with respect to DB1 and DB2 S2 : b32 w32(b) b22 w22(b) c32 c22

(DB3 and DB4 ). The recursion ends when D is a sim- S3 : b13 b23 w13(c) c13 w23(c) c23

ple domain since the child domains are local DBMSs S4 : b24 b14 w14(d) w24(d) c14 c24

8 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

Let the functions serSi , i = 1; 2; 3; 4 be dened. Let serS 1 To see the implication of Theorem 1 consider again

and serS be functions that map transactions to their be- the execution in Example 3. In Example 3, the schedules

S~D , S~D and S~D are as follows:

2

gin operation. Furthermore, let serS and serS be func- 1 2 3

3 4

By Denition 6, sf(T1 ; DB1 ) = b11, sf(T2 ; DB2 ) = b22, S~D : b11 b31 b32 b22 S~D : c13 c24 c14 c23

1 2

sf(T3 ; DB1 ) = b31, sf(T3 ; DB2 ) = b32, sf(T1 ; DB3 ) = S~D : b11 b22 c13 c24

3

c13, sf(T1 ; DB4 ) = c14. sf(T2 ; DB3 ) = c23, and Theorem 1 states that serializability of the schedule

sf(T2 ; DB4 ) = c24. As a result, transactions T~iD , and 1 S D can be ensured if the domain managers of domains

3

2 D1 ; D2 and D3 ensure the serializability of the schedules

S~D , S~D and S~D respectively. Thus, our task of ensur-

1 2 3

T~1D : b11

1

T~2D : b22 T~1D : c13 c14

1 2 ing serializability of the schedule S D reduces to that of

T~2 : c24 c23

D 2

T~3 : b31 b32

D 1 developing a mechanism using which the domain man-

ager DM(D) can ensure serializability of the schedule

The schedules S~D and S~D are as follows:

1 2 S~D . We develop such a mechanism in the following sec-

tion.

S~D : b11 b31 b32 b22

1

S~D : c13 c14 c24 c23 2

5 Ensuring Serializability of S D

~T1D and T~2D . Let serS~D be a function that maps the

2 2

2

2 2

Before we describe how a domain manager DM(D) for

serS~D (T~1D ) = c13 and serS~D (T~2D ) = c24. The func-

2 2

an arbitrary domain D 2 ensures serializability of the

schedule S~D , let us rst discuss how the domain man-

2 2

tion serS~D satises the requirement of the serializa-

tion function for the schedule S~D . To see this, note ager for a simple domain can ensure serializability of S~D .

2

2

2 Later we will extend the described mechanism to the do-

con icts with c24. As a result, transaction T~1 is se- 2 main managers for an arbitrary domain.

rialized before T~2D in S~D . Since serS~D (T~1D ) = c13

2 2 2

2

2

2

satises the requirement of the serialization function

2

5.1 Ensuring Serializability in Simple Domains

for S~D . Thus, by Denition 6, sf(T1 ; D2) = c13 and

2

Recall that since the operations in S~D belong only

sf(T2 ; D2 ) = c24. Finally, consider the schedule S~D that 1

to global transactions, the domain managers do not

contains transactions T~1D and T~2D and T~3D . Let serS~D

1 1 1

need access to operations belonging to local transactions

be a function that maps the transaction T~iD to its

1

1

(which execute outside the control of the MDBS soft-

rst operation in S~D . That is, serS~D (T~1D ) = b11 and

1 1

ware) in order to ensure serializability of S~D . The con-

serS~D (T~2D ) = b22. Note that the function serS~D satis-

1

1 currency control mechanism works as follows.

1

es the requirements of the serialization function for the

1

Before submitting an operation belonging to a global

schedule S~D . Hence, by Denition 6, sf(T1 ; D1 ) = b11

1 transaction Ti for execution at the local DBMS, the do-

and sf(T2 ; D1) = b22. main manager for DBk (that is, DM(DBk )) determines

whether or not the operation is a serSk (Ti ) operation

Using the above described function sf, serializability for some transaction Ti . If it is a serSk (Ti ) operation,

of the the schedule S D , D 2 can be ensured by simply DM(DBK ) forwards the operation to DM(D), else, it

ensuring the serializability of the schedules S~D . We state submits the operation for execution to the local DBMS.

this formally in the following theorem. On receipt of the serSk (Ti ) operation, DM(D) submits

Theorem 1: Consider an MDBS environment with the operation to the local DBMS at site sk for execution

the set of domains. Let S be a global schedule and D (via DM(DBk )). DM(D) controls the order in which

be an arbitrary domain in . Schedule S D is serializable, serSk operations corresponding to global transactions

if the following three conditions hold: execute at the local DMBSs by controlling the order in

which it submits these operations for execution to the

{ For each DBk such that DBk @ D, Sk is serializ- local DBMSs. In particular, it ensures serializability of

able and further there exists a function serSk such S~D (which consists of the serSk operations) by using a

that for all transactions Ti ; Tj , if global(Ti ; DBk ), concurrency control protocol (e.g., TO, 2PL, SGT) to

global(Tj ; DBk ), and Ti Sk Tj , then serSk (Ti ) S control the order in which it submits the operations to

serSk (Tj ). the local DBMS for execution.

{ For all domains D0 2 such that D0 @ D and D0 6= To see how the approach works consider the execu-

0

DBk , k = 1; 2; : : :; m, S~ is serializable and further

D tion in Example 3. Let us assume that the domain man-

there exists a function serS~D0 such that for all trans- ager DM(D1 ) follows the 2PL protocol to control the

actions Ti ; Tj ,0 if global(Ti ; D0 ), global(Tj ; D0), and submission order of the serSk operations to the local

DBMS for execution. Assume that T1 requests execu-

D 0

T~i S~D0 T~jD , then serS~D0 (T~iD0 ) S serS~D0 (T~jD0 ). tion b11 operation rst. Recall that the begin operations

{ S~D is serializable. of transactions are the serSk operations at DBMS1 and

DBMS2. Thus, the domain manager DM(DB1 ) forwards

Concurrency Control in Hierarchical Multidatabase Systems 9

the operation b11 to DM(D1 ). Since no other transaction of the global transaction (and not the read and write op-

holds a a con
icting lock, DM(D1 ) submits the opera- erations that constitute the application). Alternatively,

tions b11 for execution to the local DBMS for execution a local DBMS may support an SQL interface, that per-

(via DM(DB1 )). Let us assume that next T3 requests a mits DM(DBk ) to request multiple SQL statements (or

b31 operation. Since b31 operation is the serS (T3 ) oper-

1 expressions in the local data manipulation language) as

ation, the domain manager DB(DB1 ) forwards the op- part of the global subtransaction, the execution of each

eration to DM(D1 ). The submission of the operation being acknowledged by the local DBMS. The submit-

will be delayed since T~1D holds a con
icting lock. Once ted SQL query (or the service request in the case of the

T~1D releases the lock (according to the 2PL protocol), service interface) may result in multiple read and write

DM(D1 ) may submit b31 for execution. operations over the data and the index structures (e.g.,

B-trees) maintained by the local DBMS. The domain

manager DM(DBk ) may be unaware of these resulting

5.2 Assumptions behind the Approach operations, as well as of the mechanisms used by the

local DBMS for processing the SQL queries (e.g., pro-

The above description of the concurrency control mech- tocol for B-tree traversal Mohan et. al. 1989, key range

anism to ensure serializability of the schedule S~D implic- locking for phantom protection Lomet 1993.

itly makes the following two assumptions: If the local DBMSs do not support an operation inter-

1. The serSk (Ti ) operations can be associated with each face, DM(DBk ) does not have direct control over when

global transaction Ti for all local DBMSs. serSk (Ti ) operations execute at the local DBMSs. How-

2. The interface supported by the local DBMSs for ever, the relative order in which serSk operations exe-

the global transactions is such that the MDBS soft- cute can still be controlled by controlling the submission

ware submits each database operation, including the of operations that cause the execution of the serSk (Ti )

serSk (Ti ) operations, explicitly for execution to the operation at the local DBMS. To see this, consider a

local DBMSs, and the local DBMSs acknowledge the local DBMS at site sk that supports an SQL interface.

execution of the submitted operation. We refer to Furthermore, assume that the local DBMS at sk follows

such an interface as the operation interface. a TO protocol that assigns timestamps to transactions

when they begin execution. That is, serSk (Ti ) is the rst

Below, we argue that the assumption 1 is reasonable database operation belonging to Ti at site sk . DM(D)

in practice. Furthermore, we argue that if assumption can control the relative order in which serSk (Ti ) opera-

2 does not hold for a particular MDBS, it remains possi- tions execute at sk by controlling the order in which it

ble to use our approach with only a minor changes, and submits the rst SQL query for each global transaction

some loss of concurrency. Ti to the local DBMS at site sk (via the domain manager

The basis of the rst assumption has been discussed DM(DBk )). This is possible since serSk (Ti ) for a global

earlier. Depending upon the concurrency control pro- transaction Ti executes only after DM(D) submits the

tocol followed by the local DBMS, it may or may not rst SQL query of Ti for execution to, and before re-

be possible to associate a serialization function with ceiving an acknowledgment from, the local DBMS at sk

the transactions. If the concurrency control scheme fol- (via DM(DBk )). Thus, if local DBMSs do not support

lowed by the local DBMS is such that serialization func- an operation interface, our scheme can still be used to

tion cannot be associated with transactions, serialization ensure serializability for S~D with the following modica-

functions can be articially introduced for global trans- tion: DM(DBk ) forwards the operation that will cause

actions by forcing every two global transactions that ex- the execution of serSk (Ti ) at the local DBMS to DM(D)

ecute at some common sites to con
ict directly at those for processing. DM(D), in turn forwards the operation

sites. This can be accomplished by augmenting global for execution to the local DBMS (via DM(DBk )). As be-

transactions to execute a write operation on a common fore, DM(D) uses a concurrency control protocol (e.g.,

data item ticket at the site. It should always be possi- TO, 2PL, SGT) to control the order in which it submits

ble to add a data item to the local DBMS, but in the the operations to the local DBMS for execution, thereby

case that neither the concurrency control protocol used ensuring serializability of S~D .

by the local DBMS supports a serialization function, and Notice that the nature of the interface supported

nor does the local DBMS provide a mechanism for den- by the local DBMS aects the degree of concurrency

ing a new data items, the scheme developed in this pa- aorded by the developed approach. For example, in

per, as well as other approaches to concurrency control the case of a service interface, the entire service or the

in MDBSs developed previously will not be usable to en- subtransaction is considered as a single operation by

sure global serializability. Such a situation is extremely DM(DBk ), and it forwards the request for service in-

unlikely to occur in practice and, thus, the rst assump- vocation to DM(D) for execution. Since DM(D) uses a

tion is reasonable from the practical standpoint. concurrency control protocol (e.g., 2PL) to control the

Unfortunately, the second assumption may not be order in which it forwards the service request to the lo-

valid since some existing local DBMSs do not support an cal DBMS for execution, the service request at the local

operation interface. Instead, a local DBMS may support DBMS causes the execution of the serSk operation for

a service interface Breitbart et. al. 1992a in which the lo- the transaction, and the serSk operations of two dier-

cal DBMS only permits DM(DBk ) to submit a request ent transactions at the same site con
ict, only a single

for execution of an existing local application on behalf service request is allowed to execute at the same DBMS

10 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

domain managersof parent domainsof D to DM3 (D). The component DM3 (D) is responsible

for ensuring serializability of S~D .

exec(sf (Ti ; D)) ack(sf (Ti ;D)) { DM2 (D): The component DM2 (D) receives requests

DM (D) for the execution of the operations o = sf(Ti ; D)

(that is, exec(sf(Ti ; D)) requests) from the domain

sf (Ti ;D) DM2 (D) managers of the domains D0 , where parent(D0 ; D).

ack(sf (Ti; D)) In case there are multiple domains D0 such that

exec(sf (Ti ; D)) parent(D0 ; D), DM2 (D) waits until it receives re-

quests exec(sf(Ti ; D)) from each domain D0 , where

DM1 (D) exec(sf (Ti ; Dk )) DM 3 (D ) parent(D0 ; D). On receipt of the request from each

of the parent domains, it submits the operation for

execution to the component DM3 (D). On receipt of

sf (Ti ;Dk ) exec(sf (Ti ; D)) ack(sf (Ti;Dk )) the acknowledgement for the successful execution of

domain managersof child domainsof D

the operation sf(Ti ; D) (denoted by ack(sf(Ti ; D)))

from DM3 (D), DM2 (D), in turn, forwards the ac-

Fig. 5. Components of a Domain Manager knowledgement to the domain managers of each of

the domains D0 , where parent(D0 ; D).

{ DM3 (D): The component DM3 (D) is responsible for

at a given time. Thus, the scheme essentially results in scheduling the operations of the transactions T~iD to

global transactions executing sequentially at each local the local DBMSs for execution (via the domain man-

DBMS. In contrast, in the case of the operation inter- agers of the child domains of D) in such a fashion that

face, multiple global transactions may execute concur- the schedule S~D is serializable. DM3 (D) receives re-

rently at a given time at each local DBMS as long as the quest for the execution of operations o = sf(Ti ; Dk ),

concurrently executing operations are not the serSk (Ti ) where child(Dk ; D) from DM1 (D) (if either o be-

operations. longs to a transaction Ti such that local(Ti ; D), or

For the remainder of the paper, we will assume that if o 6= sf(Ti ; D)) and from the component DM2 (D)

the local DBMSs support an operation interface. This (if global(Ti ; D) and furthermore the operation o =

assumption is made only for the sake of simplicity of the sf(Ti ; Dk ) is also the operation sf(Ti ; D)). DM3 (D),

presentation and does not compromise the generality of in turn, submits the request for the execution of

our solution as explained above. the operation sf(Ti ; Dk ), to the domain manager of

the domain Dk , where child(Dk ; D). Further, on re-

ceipt of the acknowledgement for the operation o =

5.3 Ensuring Serializability in Arbitrary Domains sf(Ti ; Dk ) (that is, ack(sf(Ti ; Dk ))) from the domain

manager of the domain Dk , in case the operation

Recall that our discussion so far has considered only is also the serialization function of Ti with respect

the design of the domain manager DM(D), for sim- to D (that is, sf(Ti ; D)), DM3 (D) forwards the ac-

ple domains. We now turn our attention to the de- knowledgement to the component DM2 (D) which, as

sign of the domain manager for an arbitrary domain mentioned previously, acknowledges the execution of

D 2 such that D 62 TOP and D 6= DBk , for all the operation to the domain managers of each of the

k = 1; 2; : : :; m. DM(D) consists of the following three parent domains of D. DM3 (D) controls the submis-

components DM1 (D), DM2 (D) and DM3 (D) as illus- sion order of the operations sf(Ti ; Dk ) to the domain

trated in Figure 5: managers of the domains Dk , where child(Dk ; D), in

such a fashion that the schedule S~D is serializable.

{ DM1 (D): The component DM1(D) receives the

sf(Ti ; Dk ) operations belonging to transactions T~iD mainAbove, we have described the components of the do-

manager for a domain D, where D 62 T OP and

from the domain manager of each domain Dk at further D 6= DB

which Ti executes, where child(Dk ; D). DM1 (D), on ager for the domain k , k = 1; 2; : : :; m. The domain man-

receipt of the operation sf(Ti ; Dk ), determines if the that it does not contain D 2 TOP diers from the above in

transaction Ti is local to D. If Ti is local to D (that that if D 2 TOP , then there the component DM2 (D). Note

is, local(Ti ; D)), then DM1 (D) forwards the opera- such that parent(D0 ; D). Thus, does not exist a domain D0

tion sf(Ti ; Dk ) to DM3 (D) for processing. Else, if of the domain manager for a the component DM1 (D)

domain D 2 TOP, on

Ti is global to D (that is, global(Ti ; D)) and fur- receipt of the any operations o = sf(T

ther if the operation o = sf(Ti ; Dk ) is also the se- child(D ; D), submits a request for the i ;execution Dk ), where

of

rialization function value of Ti with respect to the sf(T ; Dk ) (that is, exec(sf(T ; D )) to the component

domain D; that is, o = sf(Ti ; D), then DM1 (D) sub- DM (D) directly. i k i k

mits the operation to the domain managers of every 3

0 0 3 Finally,

DB

consider the domain manager for a do-

Else, if o 6= sf(Ti ; D), then it submits the operation main manager for k , for some k = 1; 2; : : :; m. The do-

a domain D = DBk is responsible

3 Recall that a domain D , in our MDBS architecture, may have for forwarding operation sf(Ti ; DBk ) (that is, the op-

multiple domains D such that parent(D ; D).

0 0

erations serSk (Ti )), where global(Ti ; DBk ) to the do-

Concurrency Control in Hierarchical Multidatabase Systems 11

more, DM(DBk ), on request for the execution of the

sf(Ti ; DBk ) operations from the parent domains of DBk D3

submits the operation for execution to the local DBMS.

Finally, on receipt of an acknowledgement from the local

DBMS for the execution of the sf(Ti ; DBk ) operation, it

forwards the acknowledgement to the domain managers DB1 DB2 DB3 DB4

of the parent domains of D. Thus, the domain manager Fig. 6. Example of that Satises R1

for a domain D = DBk diers from the domain manager

dened above in that it does not contain a component

DM3 (D). then the resulting global schedule is serializable. That

In our design of the domain manager for a domain is, we identify the required restrictions on such that if

D, the operation o = sf(Ti ; Dk ), where child(Dk ; D), each domain manager ensures serializability of S~D , then

does not execute in S until the component DM3 (D) of the resulting global schedule S is serializable.

the domain manager for domain D submits a request To identify the appropriate restriction on , let us

for the execution of the operation sf(Ti ; Dk ); that is, reexamine the non-serializable execution in Example 2.

exec(sf(Ti ; Dk )) to the domain manager of domain Dk . Let us assume that each DBMSi , i = 1; 2; 3; 4, follows

Note that this is true since the component DM2 (Dk ) a timestamp scheme for concurrency control in which a

of the domain manager for the child domain Dk waits timestamp is assigned to a transaction when it begins ex-

to receive a request for the execution of the operation ecution. Since each local DBMS follows the timestamp

sf(Ti ; Dk ) from each parent domain of Dk . Furthermore, scheme and the timestamp is assigned to a transaction

for each operation sf(Ti ; Dk ), the component DM3 (D) when it begins execution, the serialization function for

of the domain manager for the domain D receives the a transaction with respect to DBi , i = 1; 2; 3; 4, is the

acknowledgement for the execution of sf(Ti ; Dk ), where transaction's begin operation at the local DBMSs. Thus,

child(Dk ; D), sometime after the execution of sf(Ti ; Dk ) the transactions T~i for the transactions T1 ; T2 ; T3; T4

in S. This is true since we assume that each DBMSj with respect to each of the domains D1 and D2 are as

acknowledges the execution of the operations belong- follows:

ing to the transactions that are global with respect to T~1D : b11 b13 T~2D : b22 b21 T~3D : b32

1 1

T~4D : b431 1

DBj to the domain manager of D = DBj , and the do- T~1D : b13

2

T~2D : b22 2

T~3D : b34 b32 T~4D : b43 b44

2 2

1D

The schedules S and S for the schedule S in Exam-2

the execution of the operation sf(Ti ; D), to the domain ple 2 are as follows:

managers of each of its parent domains. Thus, the op-

eration sf(Ti ; Dk ) executes in S after DM3 (D) submits S~D : b22 b43 b11 b32 b21 b13

sf(Ti ; Dk ) for execution to the domain manager of Dk ,

1

and before DM3 (D) receives the acknowledgement for S~D : b22 b43 b34 b32 b13 b44

2

the execution of sf(Ti ; Dk ) from the domain manager of In schedule S~D operations b11, b21, operations b22, b32,

Dk . Hence, to ensure that the schedule S~D is serializ-

1

able, the component DM3 (D) can use any concurrency and operations b43,D b13 Dcon ict. Thus, S~D is serializ- 1

~ ~ ~ D ~ D

able in the order T4 , T1 , T2 , T3 . Similarly, in the

1 1 1 1

control protocol that ensures serializability (e.g., 2PL, schedule S~D operations b22, b32, operations b43, b13, and

TO, SGT) to schedule the submission of the operations 2

belonging to transactions T~iD to the domain managers operations bD34, b44 con ict. Thus, S~D is serializable in 2

of the child domains. Note that since the schedule S~D the order T2 , T3 , T4 , T1 . Since both S~D and S~D

~ 2~ D ~ D ~2D 2 2 1 2

is distributed over the domains D1 ; D2 ; : : :; Dk , where are serializable, the execution in Example 2 could have

child(Dj ; D), j = 1; 2; : : :; k, DM3 (D) can follow any been generated (if, for example, the domain managers

distributed or centralized concurrency control protocol of D1 and D2 were following the SGT scheme to ensure

to ensure serializability of S~D . serializability of S~D and S~D respectively). Note that

1 2

the transaction T~1 before T~3 . In contrast, the domain

1 1

2 2

In the previous section, we developed a mechanism that there existed a domain D3 = fDB2 ; DB3 g (illustrated

the domain managers can use to ensure that the pro- in Figure 6), then the order in which the domain manager

jection of the schedule to their domains is serializable. for domain D1 serializes transaction T~iD and T~jD , and 1 1

However, as we mentioned in the beginning of Section 4, the order in which the domain manager of D2 serializes

ensuring serializability of the schedules S D , D 2 alone transactions T~iD and T~jD must be the same (identical

2 2

may not guarantee global serializability in a hierarchical to the order in which the domain manager D3 serial-

MDBS (see Example 2). To ensure global serializability, izes theS transactions). Hence, if there existed a domain

the set of domains must be restricted appropriately. In D3 = fDB2 ; DB3 g, then the non-serializable execution

the remainder of the section, we consider a restriction on in Example 2 would not result. We therefore consider the

such that if the mechanism developed in the previous following restriction on the set of domains:

section for ensuring serializability of S D , D 2 is used,

12 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

Dk 2 , such that Dk = Di \ Dj .

In the domain ordering relation illustrated in Fig-

ure 3, since DB2 @ D1 , DB2 @ D2 , and DB3 @ D1 ,

DB3 @ D2 , the domain D1 \ D2 does not exist. Thus,

the corresponding set does not satisfy R1. In contrast, DB1 DB2 DB3

in the domain ordering relation illustrated in Figure 6,

the domain D3 = D1 \ D2 . Thus, the corresponding set T1 T2 T2 T3 T3 T1

satises the restriction R1. Fig. 7. A Domain Ordering with a cyclic DG

Unfortunately, even if the set of domain satises

the restriction R1, and each domain manager ensures operations bD33, b13D con ict. Thus, S~D is serializable in

serializability of the schedule S~D , the resulting global

2

schedule may still not be serializable. To see this let us the order T2 , T3 , T1 . Similarly, in the schedule S~D

~ 2 ~ 2 ~ D 2 3

consider the following example. operations b11, b21, and operations bD33, b13Dcon
ict. Thus,

S~D is serializable in the order T~3 , T~1 , T~2D . Thus,

3 3 3 3

Example 4: Consider an MDBS environment con- each schedule S~D , S~D and S~D is serializable. How-

1 2 3

sisting of local databases: DBMS1 with data item a, ever, the global schedule S is not serializable.

DBMS2 with data item b, and DBMS3 with data item

c. Let the domain ordering be as illustrated in Figure 7. The above example illustrates that even if satis-

es the restriction R1, ensuring serializability of S~D for

S = fDB1 ; DB2S; DB3 ; D1; D2 ; D3g,

The set of domains

each domain D may not ensure global serializability. To

where DS1 = fDB1 ; DB2 g, D2 = fDB2 ; DB3 g, and

D3 = fDB1 ; DB3 g. Further, the set TOP = f D1 , identify conditions under which global serializability is

D2 ,D3 g, D1 \ D2 = DB2 , D2 \ D3 = DB3 , and ensured we need to introduce the notion of a domain

D1 \ D3 = DB1 . Hence, satises the restriction R1. graph. A domain graph (DG) for a set of domains , is

Consider the following transactions T1 , T2 , and T3 that an undirected graph whose nodes correspond to the set

execute: of domains D 2 TOP . Let Di and Dj be two nodes in

T1 : b11 w11(a) b13 w13(c) c11 c13 DG. There is an edge (Di ; Dj ) in DG if there exists a

T2 : b21 w21(a) b22 w22(b) c21 c22 domain Dk 2 such that Dk @ Di and Dk @ Dj .

T3 : b32 w32(b) b33 w33(c) c32 c34 Theorem 2: Consider an MDBS environment with

Note that Dom(T1 ) = D3 , Dom(T2 ) = D1 , and the set of domains. Let S be a global schedule. Further,

Dom(T3 ) = D2 . Suppose that each local DBMS follows let each of the following three hold:

a timestamp scheme for concurrency control in which a { For each DBk such that DBk @ D, Sk is seri-

timestamp is assigned to a transaction when it begins alizable and further there exists a function serSk

execution. Then, the serialization function for a transac- such that for all transactions Ti ; Tj , global(Ti ; DBk ),

tion with respect to DBi , i = 1; 2; 3, is the transactions' global(Tj ; DBk ), and Ti Sk Tj , then serSk (Ti ) S

begin operation at the local DBMSs. Thus, the trans- serSk (Tj ).

actions T~i for the transactions T1 ; T2; T3 with respect to

each of the domains D1 , D2 and D3 are as follows: { For all domains D 2 such that D 62 TOP, S~D is

serializable and further there exists a function serS~D

T~1D : b11

1

T~2D : b21 b22 T~3D : b32

1 1

such that for all transactions Ti ; Tj , if global(Ti ; D),

T~1 : b13

D

2

T~2D : b22

2

T~3D : b32 b33

2

global(Tj ; D), and T~iD S~D T~jD , then serS~D (T~iD ) S

T~1 : b11 b13 T~2 : b21

D

3 3 D T~3D : b33

3

serS~D (T~jD ).

Consider a schedule S resulting from the concurrent ex- { For all domains D 2 such that D 2 TOP, S~D is

ecution of transactions T1 , T2, and T3 such that the local serializable.

schedules at DBMS1 , DBMS2 , DBMS3 are as follows:

If satises R1 and the DG is acyclic, then S is serial-

S1 : b11 w11(a) b21 w21(a) c11 c21 izable.

S2 : b22 w22(b) b32 w32(b) c22 c32

S3 : b33 w33(c) b13 w13(c) c33 c13 Note that Theorem 2 states that under the hypoth-

Furthermore let the schedules S~D , S~D and S~D be as esis of Theorem 1, global serializability is ensured if the

domain hierarchy satises the restriction R1 and the do-

1 2 3

follows: main graph DG does not contain any cycles. The DG for

S~D : b11 b21 b22 b32

1

the set of domains corresponding to the domain order-

S~D : b22 b32 b33 b13

2 ing relation illustrated in Figure 6 contains nodes D1 and

S~D : b11 b21 b33 b13

3 D2 and an edge (D1 ; D2 ). Since this DG is acyclic and

the set of domains satises R1, it follows that in order

In schedule S~D operations b11, b21, and operations bD22,

1

to ensure global serializability, it suces to ensure that

b32, con
ict. Thus, S~D is serializable in the order T~1 ,

1 1

the schedules S~D , for each domain D 2 , is serializable.

T~2D , T~3D . In the schedule S~D operations b22, b32, and

1 1 2 In contrast, the DG for the set of domains corresponding

Concurrency Control in Hierarchical Multidatabase Systems 13

D3 { For each DBk such that DBk @ D, Sk is seri-

alizable and further there exists a function serSk

D2 D4 such that for all transactions Ti ; Tj , global(Ti ; DBk ),

D1 global(Tj ; DBk ), and Ti Sk Tj , then serSk (Ti ) S

serSk (Tj ).

{ For all domains D 2 , such that D 62 TOP , S~D is

serializable and further there exists a function serS~D

DB5 DB6 such that for all transactions Ti ; Tj , if global(Ti ; D),

DB1 DB2 DB3 DB4 global(Tj ; D), and T~iD S~D T~jD , then serS~D (T~iD ) S

Fig. 8. A Domain Ordering such that LDG Contains No Undesir- serS~D (T~jD ).

able Cycles

{ For all domains D 2 such that D 2 TOP, S~D is

serializable.

to the domain ordering relation illustrated in Figure 7

contains a cycle (D1 ; D2), (D2 ; D3) and (D3 ; D1). Hence, If satises R1 and LDG contains no undesirable cy-

even if for each domain D 2 , the schedule S~D is se- cles, then S is serializable.

rializable and the set of domains satises restriction

R1, loss of global serializability may result. Since the domain graph DG contains a cycle if and

The restriction imposed on the domain hierarchy in Theorem only if the labeled domain graph LDG contains a cycle,

Theorem 2 can be relaxed since not every cycle in the DG to be 3acyclic relaxes the requirement in Theorem 2 for

to the requirement that LDG does not

domain graph DG would result in a potential loss of se- contain any undesirable

rializability. Consider, for example, DG for the set of global serializability. cycles for our scheme to ensure

domains corresponding to the domain ordering relation

illustrated in Figure 8. Note that DG contains a cycle

(D2 ; D3), (D3 ; D4), (D4 ; D2). However, for the set of do-

mains corresponding to the domain ordering relation il- 7 Related Work

lustrated in Figure 8, if for each D 2 , the domain

manager for D ensures that the schedule S~D is serial- Relevant related work on transaction management in

izable, then it can be shown that the resulting global MDBSs was discussed in Section 2. As we mentioned

schedule S is serializable. Thus, certain cycles in DG do there, hierarchical transaction management architecture

not result in a potentially non-serializable global sched- for MDBSs has previously been studied in Pu 1988 where

ule. Below we formalize the nature of the cycles that can the authors proposed a superdatabase architecture for

be permitted in DG. To do so, we rst introduce the MDBSs. In this section, we compare our approach with

notion of the labeled domain graph (LDG). the concurrency control scheme developed in Pu 1988

An LDG is a domain graph in which each edge for the superdatabase architecture. Furthermore, we dis-

(Di ; Dj ) has a label, referred to as label(Di ; Dj ), where cuss the relationship of our work with the hierarchical

label(Di ; Dj ) = Di \ Dj . Let (D1 ; D2), (D2 ; D3), : : :, concurrency control schemes that been studied in the

(Dr,1 ; Dr ), (Dr ; D1 ) be a cycle in the LDG. We refer to context of multi-level transactions. Weikum et. al. 1984;

the cycle in the LDG as a undesirable cycle if and only Weikum et. al. 1991; Beeri et. al. 1988.

if for all k; l, k = 1; 2; : : :; r, l = 1; 2; : : :; r, if k 6= l, then A superdatabase can be seen as a hierarchical MDBS

with the following restriction on :

label(Dk ; D(k+1)mod r ) 6= label(Dl ; D(l+1)mod r ).

For all domains Di ; Dj 2 , if child(Di ; Dj ), then

Note that the LDG for the set of domains correspond- for all Dk 6= Dj , :child(Di ; Dk ).

ing to the domain ordering relation illustrated in Fig-

ure 8, has edges (D2 ; D3), (D3 ; D4) and (D4 ; D2), where An example of a superdatabase architecture is the do-

label(D2 ; D3) = label(D3 ; D4) = label(D4 ; D2) = D1 . main ordering illustrated in Figure 4. It is easy to see

Thus, LDG does not contain any undesirable cycles. that a superdatabase is a special instance of a hierar-

In contrast, the LDG for the set of domains corre- chical MDBS for which the set of domains satises

sponding to the domain ordering illustrated in Fig- the restriction R1 and, further, the domain graph cor-

ure 7 contains a cycle (D1 ; D2 ), (D2 ; D3), (D3 ; D1 ), responding to is acyclic. Thus, from Theorem 2, it

where label(D1 ; D2) = DB2 , label(D2 ; D3 ) = DB3 , follows that a concurrency control scheme based on en-

label(D3 ; D1) = DB1 . Hence, LDG contains a undesir- suring the serializability of S~D for each domain D 2

able cycle. If the LDG for the set of domains does not can be used in superdatabases to ensure global serializ-

contain any undesirable cycles, then ensuring that S~D , ability.

for each domain D 2 would ensure global serializabil- The concurrency control scheme for superdatabases

ity as is stated in the following theorem. developed in Pu 1988 is very dierent from our ap-

proach. In contrast to our scheme, where for each do-

Theorem 3: Consider an MDBS environment with main D, the domain manager DM(D) ensures serializ-

the set of domains. Let S be a global schedule. Further, ability of the schedule S~D , in Pu 1988 authors developed

let each of the following three hold: a protocol, referred to as the hierarchical validation, in

14 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

S S

where SD1 = fDB1 ; DB2 g, D2 = fDB3 ; DB4 g, and

cal validation protocol, the domain manager for a do- D3 = fD1 ; D2g. Note that the set of domains con-

main D, D 62 TOP, for each transaction Ti such that forms to the superdatabase architecture. Consider the

:local(Ti ; DBk ), k = 1; 2; : : :; m, (that is, transactions following transactions T1 , T2, T3 and T4 that execute:

that are not local to any local DBMS), submits the op-

erations T1 : b11 w11(a) b13 w13(c) c11 c13

T2 : b22 w22(b) b24 w24(d) c22 c24

fserSk (Ti ) j DBk v T3 : b31 w31(a) b32 w32(b) c31 c32

D and Ti accesses data item in DBk g T4 : b43 w43(c) b44 w44(d) c43 c44

to the domain manager of the domain D0 , where Note that Dom(T1 ) = D3, Dom(T2 ) = D3 , Dom(T3 ) =

parent(D0 ; D)4 . Further, the domain manager DM(D) D1 and Dom(T4 ) = D2 . Further,

of a domain D considers any two operations serSk (Ti ) global(T1 ; D1 ), global(T2 ; D1) and local(T3 ; D1). Simi-

and serSl (Tj ), belonging to transactions Ti and Tj , to larly, global(T1 ; D2), global(T2 ; D2) and local(T4 ; D2 ).

con ict if k = l, and uses SGT certication Bernstein et. Suppose that each local DBMS follows a timestamp

al., 1987 to ensure the serializability of the projection of scheme for concurrency control in which a timestamp

the schedule S to the operations is assigned to a transaction when it begins execution.

Consider a schedule S resulting from the concurrent ex-

fserSk (Ti ) j DBk v ecution of transactions T1, T2 , T3 , and T4 such that the

D and Ti accesses data item in DBk g. local schedules at DBMS1, DBMS2 , DBMS3 and DBMS4

are as follows:

Notice that unlike our approach in which dierent

domain managers could follow dierent concurrency con- S1 : b11 w11(a) b31 w31(a) c11 c31

trol protocols (centralized or distributed), in hierarchical S2 : b32 w32(b) b22 w22(b) c32 c22

validation, each domain manager follows the SGT certi- S3 : b43 w43(c) b13 w13(c) c43 c13

cation protocol. However, this is not the only dierence S4 : b24 w24(d) b44 w44(d) c24 c44

between the two approaches. A more subtle and a very Note that the above schedule S is not serializable. How-

important dierence is that in the case of the hierarchical ever, it could have been generated even if hierarchical

validation, the domain manager D submits the serSk (Ti ) validation protocol is used for concurrency control in

operations to the parent domain manager irrespective of case the domain manager DM(D1 ) does not submit op-

whether or not the transaction is local to D. For exam- erations belonging to the transaction T3 to DM(D3 ),

ple, if hierarchical validation is used to control execution and DM(D2 ) does not submit operations belonging to

in Example 3, even though the transaction T3 executes the transaction T4 to DM(D3 ) since local(T3 ; D1) and

only at DB1 and DB2 and is local to the domain D1 , local(T4 ; D2). To see this, consider that each domain

its serialization operations serS (T3 ) and serS (T3 ) will

1 2 manager follows an SGT certication protocol. Since

be forwarded to the domain manager DM(D3 ). Thus, DM(D1 ) does not submit the operations of T3 (that is,

the execution of transactions that are local to a domain serS (T3 ) and serS (T3 ) operations), and DM(D2 ) does

D1 will not only be controlled by the concurrency control 1 2

not submit the operations of T4 (that is, serS (T4 ) and

protocols followed by the domain manager of domain D1 serS (T4 ) operations) to DM(D3 ) the schedules at the

3

domain managers DM(D1 ), DM(D2 ), and DM(D3 ),

D1 at which T3 executes), but also by the concurrency denoted by S 1 , S 2 , and S 3 respectively are as follows:

control protocols followed by the domain managers of all

the ancestor domains of D1 . In particular, the domain S 1 : b11 b31 b32 b22

manager of the root domain in a superdatabase will con- S 2 : b24 b43 b44 b13

trol the concurrent execution of all the transactions that S 3 : b11 b22 b24 b13

are global with respect to any local DBMS.

If, in the hierarchical validation protocol, DM(D) In the above schedules note that operations b11, b31, op-

does not submit the operations serSk (Ti ), where erations b32, b22, operations b24, b44, and operations b43,

local(Ti ; D), to the parent domain of D, then the pro- b13 con ict. Thus, each of the schedules S 1 , S 2 and S 3

tocol may not ensure global serializability. We illustrate are serializable. Hence, the schedule S would be permit-

this in the following example. ted by the hierarchical validation protocol even though

it is not serializable.

Example 5: Consider an MDBS environment con- In contrast, in our approach, for a transaction Ti and

sisting of local databases: DBMS1 with data item a,

DBMS2 with data item b, DBMS3 with data item c, and a domain D such that local(Ti ; D), the domain manager

DBMS4 with data item d. Let the domain ordering rela- of D does not submit any information to the parent do-

tion be as illustrated in Figure 4. The set of domains: main of D and the execution of the operations of Ti is

controlled by only the domain manager for D (and its

= fDB1 ; DB2 ; DB3 ; DB4 ; D1 ; D2; D3 g; descendents on which Ti executes). For example, in the

execution in Example 5, the execution of the operation

4 Note that in the superdatabases each domain may have at b31 and b32 (which are the serialization function values

most one parent. of T3 ) will be controlled by only the domain manager of

Concurrency Control in Hierarchical Multidatabase Systems 15

D1 (and its descendents) and not by the domain man- Note that we are not claiming that the notion of

ager of D3 since T3 is local to the D1 . Similarly, since multi-leveltransactions is orthogonal to the MDBS trans-

T4 is local to D2 , the execution of the operations b43 action management problem. In fact, one of the pro-

and b44 is controlled by only the domain manager of D2 posals Sheck 1991, Weikum et. al. 1991 for concurrency

(and its descendents). Not only does this increase scala- control in MDBSs is to consider global transactions as

bility of our approach, but also preserves the autonomy two-level transactions in which each subtransaction is

of the individual MDBSs since the transactions local to considered as a lower level operation. However, such ap-

a domain D are controlled by only the domain manager proaches are based on exploiting the semantics of the

of D (and its descendants). Furthermore, since in our application domain, and do not ensure global serializ-

approach, only transactions global with respect to a do- ability. Hence, such approaches are not directly related

main D pay the overhead of the concurrency control at to the scheme developed in this paper.

the parent domain of D, our approach will have better An interesting observation is that similar to our work,

performance as compared to the hierarchical validation Section 6), recently, eorts have also been made to de-

protocol in which every transaction that is global with velop concurrency control protocols for multi-level sys-

respect to some local DBMS pays the concurrency con- tems in which the abstraction hierarchy may not neces-

trol overhead at multiple levels. sarily be a true hierarchy. Specically, in Muth et. al.,

Hierarchical concurrency control schemes have also 1993, the authors develop a technique for concurrency

been previously studied in the context of multi-level control in multi-level systems in which not every trans-

transactions Weikum et. al. 1984, Weikum et. al. 1991, action has a representation at each abstraction level. For

Beeri et. al. 1988. A multi-level transaction is a special example, consider a two-level system discussed earlier

type of a nested transaction Moss 1987, Gray et. al. 1993 in which the levels correspond to the tuples and pages.

in which levels of the transaction represent a hierarchy of The authors develop a multi-level concurrency control

abstract data types. Operations at a given level i are im- scheme for a system in which not every transaction has

plemented completely using operations at the next lower a representation at both the tuple as well as the page

level i , 1. The recursion stops at level 0, the operations abstraction level. Instead some transactions may be im-

at which are assumed to be atomic and indivisible. In plemented as operations on the pages directly. The mo-

multi-level systems, concurrency control is done hierar- tivation for their work comes from trying to map the

chically at each level. The concurrency control scheme applications in object-oriented databases to multi-level

at level i, ensures isolation of the level i operation un- transactions for the purpose of concurrency control. One

der the assumption that the level i , 1 operations are way to do so is to map the method invocation hierarchy

atomic, which are made atomic by the concurrency con- to the abstraction hierarchy of the multi-level transac-

trol scheme of level i , 1, and so on. The objective is that tion. However, it is not too dicult to see that the hier-

viewing transactions in the multi-level framework allows archy for most systems will not be a true hierarchy as is

for the exploitation of the application semantics to en- traditionally assumed in the work on multi-level transac-

hance concurrency. Two transactions, even though they tions. Similar to our work on identifying limitations that

result in operations that con
ict at the lower abstrac- must be imposed on the domain hierarchy for the de-

tion level may not con
ict at the higher level. To see veloped concurrency control approach (that is, ensuring

this, consider a two-level system in which transactions serializability of S~D ) to ensure global serializability in hi-

are implemented as a sequence of operations on tuples, erarchical MDBSs, it will be interesting to study limita-

and each tuple-level operation is implemented as a se- tions on the abstraction hierarchy that might need to be

quence of page-level operations. Two transactions that imposed for the scheme developed in Muth et. al. 1993

access/modify dierent tuples on the same page, even to ensure serializability in multi-level systems.

though they execute con
icting page-level operations, do

not con
ict at the level of the tuples. Multi-level concur- 8 Conclusions

rency control enables such transactions to execute con-

currently thereby enhancing concurrency. A multidatabase system (MDBS) is a facility, developed

Besides the fact that both our approach for MDBS on top of pre-existing local database management sys-

environments, as well as the mechanisms developed for tems (DBMSs), that provides users of a DBMS access

multi-leveltransactions, are hierarchical concurrency con- and update privileges to data located in other hetero-

trol protocols, there is not much similarity between geneous data sources. Over the past decade, substantial

them. For example, in multi-level concurrency control research has been done to identify mechanisms for eec-

schemes, each transaction is dened over a given ab- tively dealing with the problems that arise due to the

straction hierarchy, and its execution is controlled by heterogeneity and autonomy of the local systems. This

the concurrency control scheme at each level. There is research has resulted in transaction management algo-

no concept similar to local and global transactions as rithms for MDBSs that ensure correctness without sac-

is the case with transactions in MDBS environments. ricing the autonomy of the individual system. Most of

Furthermore, in the MDBS environments considered in the proposed approaches have, however, considered an

this paper, the hierarchy of MDBSs represents only a MDBS as a single monolithic system which, executing

structural hierarchy, and there is no implied hierarchy of on top of the existing local DBMSs, controls the execu-

abstractions as is the case with multi-level transactions. tion and commitment of the global transactions (trans-

16 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

actions that execute at multiple local DBMSs) in such suring global serializability in hierarchical MDBSs. Since

a way that consistency of the individual systems is not ensuring global serializability in an MDBS environment

jeopardized. is both complex and expensive, and schemes that ensure

In this paper, we proposed a hierarchical architec- serializability may not oer the desired degree of con-

ture for multidatabase systems and studied how con- currency, substantial research has been done to develop

currency control can be done in such systems. We be- correctness criteria for MDBSs that are weaker than se-

lieve that a large MDBS, that spans multiple organiza- rializability but that ensure database consistency under

tions which are geographically distributed over nodes of appropriate assumptions about the MDBS environment

a world-wide computer network will not be developed Du et. al. 1989, Mehrotra et. al. 1991. It will be interest-

as a single monolithic system. Instead, it will be devel- ing to study concurrency control schemes and the con-

oped as a hierarchical system in which an MDBS that sistency guarantee that results in hierarchical MDBSs in

integrates certain local DBMSs may itself be a part of a which dierent domains may follow dierent notions of

larger MDBS. In a hierarchical MDBS, depending upon correctness.

the nature of the transactions that execute, the comput-

ing resources available, and the reliability of the network, Acknowledgement. We wish to thank Daniel Barbara for many in-

dierent component MDBSs may follow dierent trans- spiring discussions. We would further like to thank Rajeev Rastogi

action management schemes to ensure the consistency of for his comments on an earlier draft of the paper. We would like to

the data they integrate. However, the transaction man- thank the VLDB Journal referees for their constructive criticism

agement algorithms followed by the individual MDBSs and many improvements they suggested over the original version

of the paper.

must be such that it is feasible to compose them as ele-

ments of a larger MDBS.

To describe the architecture, with an MDBS environ- A Proofs of the Theorems

ment we associate a set of domains with an ordering

relation @. A domain is either a set of data items at In this appendix, we prove Theorems 1-3 stated in the

some local DBMS, or it may consist of a union of the paper. We begin by rst proving Theorem 1. To prove

set of data items in other domains. The execution of the the theorem we rst need to develop the following two

transactions within a domain D 2 is controlled by the lemmas.

domain manager of D. We developed a mechanism using Lemma 1: Consider an MDBS environment with the

which the domain managers can ensure that the concur- set of domains. Let S be a global schedule and D be

rent execution of the transactions does not result in a loss an arbitrary domain in . Schedule S D is serializable, if

of serializability within their domains. More specically, each of the following three conditions hold:

for a global schedule S and a domain D, we identied a 1. For each domain Dk such that child(Dk ; D), schedule

schedule S~D such that0 if S~D is serializable, and for all S Dk is serializable.

domains D0 @ D S~D is serializable, then the serializ- 2. For each domain Dk , such that child(Dk ; D), there

ability of the projection of S to data items in D (that is exists a serialization function sf such that the fol-

S D ) is ensured. We developed a mechanism using which lowing holds:

the domain manager of D can control the order in which

the operations that belong to S~D execute such that S~D For all transactions Ti ; Tj , if global(Ti ; Dk ),

is serializable. In our mechanism, the domain manager global(Tj ; Dk ), and Ti S Dk Tj , then

may use any concurrency control protocol known for tra- sf(Ti ; Dk ) S sf(Tj ; Dk ).

ditional DBMSs (distributed or centralized) to ensure 3. Schedule S~ is serializable.

D

serializability of S~D . Finally, we identied restrictions

that need to be imposed on the architecture of the hi- Proof: Assume D

that S D is not serializable. Since

erarchical MDBSs such that our mechanism of ensuring by (1) each S is serializable, there exist transactions

k

serializability of S~D for each domain D 2 results in T1; T2 ; : : :; Tn such that T1 S Dk T2 , T2 S Dk T3 , : : :,

global schedules that are serializable. Tn,1 S Dkn, Tn , Tn S Dkn T1 , where child(Dki ; D),

1 2

global(Ti ; Dki ), and global(T(i+1)mod n ; Dki ), i = 1, 2, : : :

resilience. Failure-resilience in MDBSs is complicated ,n. By (2), sf(T1 ; Dk ) S sf(T2 ; Dk ), sf(T2 ; Dk ) S

since the requirement of autonomy preservation renders sf(T3 ; Dk ), : : :, sf(Tn,1 ; Dkn, ) S sf(Tn ; Dkn, ),

1 1 2

the usage of atomic commit protocols Bernstein et. al. 1987 sf(Tn ; Dkn ) S sf(T1 ; Dkn ). Thus, by the denition of

2 1 1

unsuitable for MDBS environments. In the absence of con
icts in S~D , T~1D S~D T~2D , T~2D S~D T~3D , : : :, T~nD,1

atomic commit protocols, it is possible that certain sub- D ~D T~D which is a

S~D T~n , T~n S~D T~1 . Hence, T~1

transactions of a multi-site transaction commit, whereas D D D

S 1

others abort, thereby violating the atomicity property. contradiction since S~D by (3) above is serializable. Hence

The problem of ensuring atomicity in MDBS environ- proved.

ments has been studied in Breitbart et. al., 1990; Wolksi

et. al., 1990; Mehrotra et. al., 1992b, 1992d; Zhang et. al., We next prove that the function sf dened in the

1994. We need to further study how these schemes can be paper meets the requirement of a serialization function

adapted for hierarchical MDBSs. Finally, in this paper for a domain D.

we concentrated only on developing mechanisms for en-

Concurrency Control in Hierarchical Multidatabase Systems 17

such a domain and further let D = fD1; D2 ; : : :; Dng.

set of domains. Let S be a global schedule with trans- Since level(Dk ) p, child(Dk ; D), by IH, S Dk is seri-

actions Ti , and Tj , and let D be an arbitrary domain in alizable. Further, since child(Dk ; D), Dk 62 TOP . Thus,

. If global(Ti ; D), global(Tj ; D) and Ti S D Tj , then the function serS~Dk exists. By Lemma 2, sf(Ti ; Dk ) =

sf(Ti ; D) S sf(Tj ; D). serS~Dk (Ti ) satises the property that for all Ti ; Tj , such

that global(Ti ; Dk ), global(Tj ; Dk ), Ti S Dk Tj )

In the proof of Lemma 2, we will need the following sf(Ti ; Dk ) S sf(Tj ; Dk ). Thus, by Lemma 1, since S~D

notion of a level of a domain: is serializable, S D is serializable. Hence proved.

level(D) =

1; if D = DBk for some local database DBMSk Proof of Theorems 2 and 3: Note that Theo-

maximum(level(Dk )) + 1; where child(Dk ; D) rem 2 directly follows from Theorem 3 since for a given

set of domains and a domain ordering @ if DG is

acyclic, then the corresponding LDG does not contain

Proof: The proof is by the induction over the level any undesirable cycles, We, thus, restrict ourselves to

of the domains. proving Theorem 3 which is done in the remainder of

Basis (level(D) = 1): If level(D) = 1, then for some the appendix. To do so, let us consider a schedule S

DBk , D = DBk . Hence, for all transactions Ti ; Tj , that is not serializable. Thus, there exists transactions

if global(Ti ; D), global(Tj ; D), and Ti Sk Tj , then T1; T2 ; : : :; Tn such that T1 DB T2 , T2 DB T3, : : :,

Tn,1 DBn, Tn , Tn DBn T1 .5 Let D 2 TOP such

1 2

that DB1 @ D. If for all DBi , i = 1; 2; : : :; n, DBi @ D,

1

Induction: Assume that the lemma is true for all do- then T1 S D T1 which is a contradiction since, as shown

mains D such that level(D) p. Let in Theorem 1, for each domain D 2 , our scheme en-

S sures that S D is serializable. Thus, to prove that under

D = fD1 ; D2 ; : : :; Dn g the hypothesis of Theorem 3, the resulting global sched-

be an arbitrary domain such that level(D) = p + ule S is serializable, we can restrict ourselves to the case

1. Let Ti ; Tj be transactions such that global(Ti ; D), in which there exists a DBi 6@ D. Let DBk be the rst

global(Tj ; D), and Ti S D Tj . There are two cases to such DBi , that is, for all DBi , 1 i < k, DBi @ D and

consider: further DBk 6@ D. In this case, since transaction Tk ex-

ecutes on both DBk,1 and DBk , global(Tk ; D) and fur-

{ (Ti S Dk Tj for some Dk such that child(Dk ; D)): ther, Tk S Tk . We will show that in this case it must

Since global(Ti ; D) and global(Tj ; D) and Ti , Tj exe- be the case that T~kD S~D T~kD which is a contradiction

cutes in Dk , global(Ti ; Dk ) and global(Tj ; Dk ). Thus, since S~D is serializable.

by IH, sf(Ti ; Dk ) S sf(Tj ; Dk ). Hence, by deni-

tion of a con ict in S~D , T~iD S~D T~jD . As a result, by Thus, our task of proving Theorem 3 reduces to that

the denition of sf(T; D), sf(Ti ; D) S sf(Tj ; D) of establishing that under the hypothesis of Theorem 3,

{ (There exist transactions T1 ; T2 ; : : :; Tn such that if there exists transaction Ti ; Tj , such that global(Ti ; D)

Ti S Dk T1 , T1 S Dk T2 , : : :, Tn,1 S Dkn, Tn , and global(Tj ; D), and Ti S Tj , then T~iD S~D T~jD .

1 2 1

The proof of this is a little involved. Let us rst con-

Tn S Dkn Tj , where child(Dkl ; D), l = 1; 2; : : :; n): sider the case in which the con ict Ti Tj arises

Note that global(Tl ; Dkl ), l = 1; 2; : : :; n, and due to a direct con ict between Ti and Tj at some

global(Tl+1 ; Dkl ), l = 1, 2, : : :, n , 1. Thus, by IH, DBMSk ; that is, Ti DBk Tj . In this case, there are

sf(Ti ; Dk ) S sf(T1 ; Dk ), two possibilities{ either DBk v D, or DBk 6v D. If

sf(T1 ; Dk ) S sf(T2 ; Dk ), : : :, DBk v D, then Ti S D Tj . The following lemma shows

1 1

sf(Tn,1 ; Dkn, ) S sf(Tn ; Dkn, ), sf(Tn ; Dkn ) S that if Ti S D Tj , then T~iD S~D T~jD .

2 2

sf(Tj ; Dkn ).

1 1

Hence, by denition of a con
ict in S~D , T~iD S~D T~1D , Lemma 3: Let Ti and Tj be transactions and D be

T~1D S~D T~2D , : : :, T~nD,1 S~D T~nD , T~nD S~D T~jD . a domain such that global(Ti ; D) and global(Tj ; D) and

Hence, T~iD S~D T~jD . As a result, by the denition of level(D) 2. If Ti S D Tj , then T~iD S~D T~jD .

sf(T; D), sf(Ti ; D) S sf(Tj ; D). Hence proved. Proof: Let p = level(D) The proof is by induction

on p.

Proof of Theorem 1: The proof is by the induction Basis (p = 2): Thus, D = fDB1 ; DB2 ; : : :; DBm g for

some local database DBMSk , k = 1; 2; : : :; m. Since

over the level of the domain D. Ti S D Tj , there exists transactions T1 ; T2; : : :; Tn such

Basis (level(D) = 1): If level(D) = 1, then for some

DBk , D = DBk . Since Sk is serializable, for all k = that Ti DBk T1 , T1 DBk T2, : : :, Tn,1 DBkn Tn ,

Tn DBkn Tj , where

1 2

1; 2; : : :; n, S D is serializable.

Induction: Assume that the theorem is true for each +1

each domain, D such that level(D) = p + 1. Let D be 5 For notational brevity, we denote S DBi (or Si ) by DBi .

18 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

global(Tl ; DBkl ) and global(Tl ; DBk l ), exists a D0 v D such that T~iD0 S~D0 T~jD0 , then T~iD S~D

l = 1; 2; : : :; n.

( +1)

T~jD .

Hence by denition of the serialization function sf, Proof: The proof in by induction on the level of the

domain D, where D0 v D.

sf(Ti ; DBk ) S sf(T1 ; DBk ), Basis (level(D) = level(D0 )): Since

D0 v D, it must be

sf(T1 ; DBk ) S sf(T2 ; DBk ), : : :, the case that D = D. Thus, Ti S~D T~jD .

0 ~ D

1 1

2 2

Induction:0 Assume that the lemma is true for0 all do-

sf(Tn ; DBkn ) S sf(Tj ; DBkn ). mains D, D v D such that level(D) level(D )+p. We

show that the lemma is true for all domains such that

+1 +1

Thus, by denition of T~i , T~iD S~D T~1D , T~1D S~D T~2D , level(D) = level(D0 ) + p + 1. Let D be such a domain.

: : :, T~nD,1 S~D T~nD , and T~nD S~D T~jD . Hence, T~iD S~D Since D0 v D, there exists a domain D00 , D0 v D00 ,

T~jD . where child(D00 ; D). Further, since global(Ti ; D) and

Induction: Assume that the lemma holds for all do- global(Tj ; D), and since Ti and Tj execute in D00 , it must

mains such that level(D) p. We show that it holds be the case00that global(T i ; D00 ) and00global(Tj ; D00 00 ). Thus,

~ 00 D ~D00 T~D , by de-

S~D00 Tj . Since T~i

~

by IH, Ti D D

for

SfDdomains such that level(D) = p + 1. Let D = S j

1 ; D2 ; : : :; Dm g be an arbitrary domain such that

nition of sf, sf(Ti ; D00) S sf(Tj ; D00). Thus, by deni-

level(D) = p + 1. Since Ti S D Tj , there exists trans- tion of T~i , T~iD S~D T~jD . Hence, T~iD S~D T~jD .

actions T1 ; T2 ; : : :; Tn , n 0, such that Ti S Dk T1 , Lemma 6: Let Ti ; Tj be transactions and let D be a

T1 S Dk T2, : : :, Tn,1 S Dkn Tn , and Tn S Dkn

1

2 +1

domain such that T~iD S D T~jD . For all D0 , D0 @ D, if Ti

Tj . Since child(Dkl ; D), level(Dkl ) < level(D). Thus, ~

and Tj execute in D0 , then sf(Ti ; D0) S sf(Tj ; D0 ).

by IH, T~iDk S~Dk T~1Dk, , T~1Dk S~Dk T~2Dk , : : :,

1 1 2 2

Proof: Let there exists a D0 such that sf(Tj ; D0) S

1 2

0 00

T~nD,k1n S~Dkn T~nDkn , and T~nDkn S~Dkn T~jDkn .

+1 +1 sf(Ti ; D ). Thus, there exists a domain 00D such that

Hence by denition of the serialization function sf,

+1

D00 v D, parent(D00 ; D0 ) such that T~jD S~D00 T~iD00 .

sf(Ti ; Dk ) S sf(T1 ; Dk ), sf(T1 ; Dk ) S sf(T2 ; Dk ), Hence by Lemma 5, T~jD S~D T~iD . Thus, S~D is not serial-

: : :, sf(Tn,1 ; Dkn ) S sf(Tn ; Dkn ), and sf(Tn ; Dkn ) S izable which is a contradiction. Hence, such a D0 does not

1 1 2 2

sf(Tj ; Dkn ). Thus, by denition of T~i , T~iD S~D T~1D , exist. Thus, for all D0 , D0 @ D, sf(Ti ; D) S sf(Tj ; D).

+1

T~1D S~D T~2D , : : :, T~nD,1 S~D T~nD , T~nD S~D T~jD . Hence,

+1

T~iD S~D T~jD . Hence proved. Proof of Lemma 4: There are two cases to consider.

Recall that we were considering the proof of the { (D \ D0 6= ;:) We rst show that both Ti and Tj

fact that if there exist transactions Ti ; Tj , such that execute at D \ D0 . If Ti does not execute at D \ D0 ,

global(Ti ; D) and global(Tj ; D), and Ti DBk Tj , then then since Ti executes at D, there exists a DB @ D 1

T~iD S~D T~jD . If in case, DBk v D, then the above devel- and a DB @ D0 such that Ti executes at DB and

2 1

DB , where DB 6@ D \ D0 and DB 6@ D \ D0 . Since

oped lemma shows that T~iD S~D T~jD . We next consider

2 1 2

Ti executes at DB and DB , there exists a domain

1 2

the case in which DBk 6v D. Let DBk v D0 , where D0 2 D00 2 TOP , Dom(Ti ) @ D00, such that D00 = 6 D

T OP. Note that since global(Ti ; D) and global(Tj ; D), it and D00 = 6 D0 . Consider the labeled domain00 graph

must be the case that global(Ti ; D0 ) and global(Tj ;0 D0 ). LDG. In LDG since DB @ D and DB @ D , there

1 1

S~D0 T~j . To

D is an edge (D; D00 ) such that DB @ label(D; D00 ).

1

prove that T~iD S~D T~jD , we will show that if for any Further, since DB @ D0 and DB @ D00, there is

2 2

an edge (D0 ; D00) such that DB @ label(D; D00 ).

pair of transactions Ti ; Tj and domains D;0D0 2 TOP0 , Since D \ D0 = 6 ;, there exists an edge00 (D; D

2

0 ) in

where global(Ti ; D) and global(Tj ; D), if T~iD S~D0 T~jD , LDG. Thus, LDG contains a cycle (D; D ), (D ; D0 ),

00

then T~iD S~D T~jD . (D0 ; D). Since DB 6@ D0 , DB 6@ label(D; D0 ). Fur-

1 1

ther, since DB 6@ D, DB 6@ label(D; D0 ). Hence,

2 2

00 00 0 0

the cycle (D; D ), (D ; D ), (D ; D) is a undesirable

Lemma 4: Let the set satisfy restriction R1 and cycle. Thus, it must be the case that Ti executes in

the LDG be acyclic. Further, let Ti ; Tj be transactions D \ D0 . Similarly, it is the case that Tj executes in

and D; D0 2 TOP be domains such that global(T i ; D00)

0

and global(Tj ; D0). If T~iD S~D T~jD , then T~iD S~D0 T~j .

D D \ D0 . Since T~iD S~D T~jD , by Lemma 6, we have

that sf(Ti ; D \ D0 ) S sf(Tj ; D \ D0 ). Thus, by

Lemma 5, since global(Ti0 ; D0) and global(Tj ; D0 ), we

0

have that T~iD S~D0 T~jD .

To prove Lemma 4, we rst develop the following two

lemmas that relate con
icts between transactions in do- { (D \ D0 = ;:) Since Ti executes at D as well as D0 ,

mains D; D0 , where D0 @ D. let Ti executes at DB1 , DB3 , where DB1 @ D and

DB3 @ D0 . Further since Tj executes at D as well as

Lemma 5: Let D be a domain and Ti ; Tj be transac- D0 , let Tj executes at DB2 , DB4 , where DB2 @ D

tions such that global(Ti ; D) and global(Tj ; D). If there and DB4 @ D0 . We show that there exists a domain

Concurrency Control in Hierarchical Multidatabase Systems 19

D00 such that DB1 @ D00, DB2 @ D00 , DB3 @ D00 , Since global(Ti ; D \ D00) and global(Tj ; D \ D00), and

DB4 @ D00. Say such a domain D00 does not exist. T~iD S~D T~jD , by Lemma 6, sf(Ti ; D \ D00) S

Since Ti executes at DB1 and DB3 , there exists a sf(Tj ; D \ D00). Hence by Lemma 5, and the deni-

domain D000 2 TOP , such that Dom(Ti ) @ D000 and tion of T~i , T~iD00 S~D00 T~jD00 . Since global(Ti ; D0 \ D00 )

thus DB1 @ D000 and DB3 @ D000. Further, since

Tj executes at DB2 and DB4 , there exists a do- and global(Tj ; D0 \ D00 ), and T~iD00 S~D00 T~jD00 , by

main D0000 2 TOP , such that Dom(Tj ) @ D0000 and Lemma 6, sf(Ti ; D0 \ D00 ) S sf(Tj ; D0 \0 D00 ). Hence0

thus DB2 @ D0000 and DB4 @ D0000. If D000 = D0000, by Lemma 5, and the denition of T~i , T~iD S~D0 T~jD .

then DB1 @ D000, DB2 @ D000, DB3 @ D000, and Hence proved.

DB4 @ D000 . Hence, D000 6= D0000. Thus, D 6= D0 6=

D000 6= D0000. Consider the labeled domain graph Using Lemmas 3 and 4 we can establish that if

LDG. In LDG, there is an edge (D; D000) such that there exists transaction Ti ; Tj , such that global(Ti ; D)

DB1 @ label(D; D000 ), there is an edge (D000; D0 ) such and global(Tj ; D), and Ti DBk Tj , then T~iD S~D T~jD .

that DB3 @ label(D; D000 ), there is an edge (D0 ; D0000) Recall that to prove Theorem 3 we needed to show that

such that DB4 @ label(D0 ; D0000), and there is an under the hypothesis of Theorem 3, if there exists trans-

edge (D0000; D) such that DB2 @ label(D0000; D). Thus, action Ti ; Tj , such that global(Ti ; D) and global(Tj ; D),

LDG contains a cycle (D; D000), (D000; D0 ), (D0 ; D0000), and Ti S Tj , then T~iD S~D T~jD . We have already

(D0000; D). We next show that LDG contains a unde- proved the above under the assumption that the con
ict

sirable cycle. There are two cases to consider:

{ (D000 \ D0000000= ; :) Since000 DB10000@ label(D; D000 ), Ti Tj arises as a result of a direct con
ict between

DB1 @ D . Since D \ D = ;, DB1 6@ transactions Ti and Tj ; that is, there exists a DBk such

D0000. Thus, DB1 6@ label(D0000; D) and further that Ti DBk Tj . We next relax the assumption and

DB1 6@ label(D0000; D0 ). Similarly, since DB1 6@ show that for any arbitrary con
ict Ti S Tj , the claim

D0 , DB1 6@ label(D0 ; D000). Hence label(D; D000 ) 6= holds. To do so, we will require the following lemma that

label(D0 ; D000), label(D; D000 ) 6= label(D0 ; D0000), establishes how the presence/absence of certain edges be-

and label(D; D000 ) 6= label(D; D0000). Using simi- tween the nodes in an LDG impacts the nature of the

lar reasoning, we can show that con
icts between transactions that can occur in the sys-

label(D; D000 ) 6= label(D000 ; D0 ) 6= label(D0 ; D0000) tem.

6= label(D0000; D).

Hence, the cycle (D; D000 ), (D000 ; D0 ), (D0 ; D0000), Lemma 7: Let T1; T2 ; : : :; Tn, n > 2, be transactions

(D0000; D) is a undesirable cycle. such that T1 DB T2, T2 DB T3 , : : :, Tn,1 DBn,

{ (D000 \ D0000 6= ; :) If D0000000 \000D0000 6= ;, then Tn. Let D0 and D00 , D0 2 TOP, D00 2 TOP, be domains

1 2 1

LDG contains an edge (D ; D ) and thus LDG such that DB1 v D0 and DBn,1 v D00 . There exists

besides containing the cycle (D; D000), (D000; D0 ), a path (D0 ; D1), (D1 ; D2 ), : : :, (Dr,1 ; Dr ), (Dr ; D00) in

(D0 ; D0000), (D0000; D), also contains cycles (D; D000 ), LDG such that for all Di , i = 1; 2; : : :; r, there exists a

(D000 ; D0000), (D0000; D) and (D0 ; D000), (D000 ; D0000), DBj , j = 1; 2; : : :; n , 1, such that DBj @ Di . Further,

(D0000; D0 ). Note that since D \ D0 = ;, it must be let edges (D0 ; D1 ), (D1 ; D2), : : :, (Dr,1 ; Dr ), (Dr ; D00)

the case that DB1 6@ label(D0 ; D000) and DB1 6@ have labels L1 ; L2; : : :; Lr respectively. For all Li , i =

label(D0 ; D0000). Further, DB2 6 @ label( D0 , D000) 1; 2; : : :; r, there exists a DBj , j = 1; 2; : : :; n , 1, such

and DB2 6@ that DBj @ Li .

label(D0 ; D0000). Proof: The proof is by induction on n.

Similarly, DB3 6@ label(D0 ; D000), Basis (n = 3): Thus, T1 DB T2 and T2 DB T3 ,

DB3 6@ label(D0 ; D0000), DB4 6@ label(D; D000 ) and where DB1 @ D0 and DB2 @ D00. Consider the do-

1 2

DB4 6@ label(D; D0000 ). Thus, if the cycle (D; D000), main D 2 TOP such that Dom(T2 ) v D. If D = D0 ,

(D000 ; D0), (D0 ; D0000), (D0000; D) is not a undesir- then since DB2 @ D00 and DB1 @ D0 , there is an edge

able cycle, then either label(D; D0000 ) = label(D; D000 ) (D0 ; D00) in LDG. Further, DB2 @ label(D0 ; D00 ). Else,

or label(D0 ; D0000) = label(D0 ; D000). Note that if D = D00 , then since DB1 @ D0 and DB2 @ D00 ,

label(D; D0000 ) = label(D; D000 ) and label(D0 ; D0000) = there is an edge (D0 ; D00) in LDG. Further, DB1 @

label(D0 ; D000) both cannot hold since then D3 label(D0 ; D00 ). Else, if D 6= D0 and D 6= D00, then

would be such that DB1 @ D3 , DB2 @ D3 , there are edges (D0 ; D) and (D; D00) in LDG such that

DB3 @ D3 , and DB4 @ D3 . If label(D; D0000 ) = DB1 @ label(D0 ; D) and DB2 @ label(D; D00 ).

label(D; D000 ), and label(D0 ; D0000) 6= label(D0 ; D000), Induction: Assume that the lemma holds for n = m , 1,

then the cycle (D0 ; D000), (D000 ; D0000), (D0000; D0) is m 4. We show it holds for n = m. Thus, we have

a undesirable cycle. Else, if T1 DB T2 , T2 DB T3 , : : :, Tm,1 DBm, Tm . Let

label(D0 ; D0000) = label(D0 ; D000), DBm,2 @ D000, where D000 2 TOP. If D000 = D0 , then

1 2 1

and by base case, the lemma holds. Else, if D000 = D00 , then

label(D; D0000 ) 6= label(D; D000 ), T1 DB T2 , T2 DB T3, : : :, Tm,2 DBm, Tm,1 ,

then the cycle (D; D000), (D000 ; D0000), (D0000; D) is a where DB1 v D0 and DBm,1 v D00. Hence, by IH, the

1 2 2

undesirable cycle. lemma holds. Else, D000 6= D0 and D000 6= D00 . By IH,

Hence, there must exist a domain D00 such that there exists a path (D0 ; D1 ), (D1 ; D2 ), : : :, (Dr,1 ; Dr ),

DB1 @ D00 , DB2 @ D00 , DB3 @ D00 , and DB4 @ D00 . (Dr ; D000) in LDG such that for all Di , i = 1; 2; : : :; r,

20 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

there exists a DBj , j = 1; 2; : : :; m , 2, such that DBj @ { (for0 all0 i, i = 1; 2; 3; : : :;0 m , 1, DBi 6@ D:) Let DB @0 1

Di . Further, for all Li , i = 1; 2; : : :; r, there exists a DBj , D,D = 6 D, where D 2 TOP and Dom(T ) v D . 1

j = 1; 2; : : :; m , 2, such that DBj @ Li . By the base There are two cases to consider:

case, since Tm,2 DBm, Tm,1 and Tm,1 DBm, Tm , { (DB0 m,1 v D0 :) We rst show that T~1D0 S~D0

there exists a path (D000; D10 ), (D10 ; D20 ), : : :,(Dr0 0 ,1; Dr0 0 ),

2 1

(Dr0 0 ; D00) such that for all Di0 , i = 1; 2; : : :; r0, there ex- T~mD . It will follow from Lemma 4 that T~1D S~D

ists a DBj , j = m , 2; m , 1, such that DBj @ Di0 . T~mD . Since DBm,1 v D0 , we have that T1 DB 1

Further, for all Li , i = 1; 2; : : :; r0, there exists a DBj , T2 , T2 DB T3 , : : :, Tm,1 DBm, Tm , where

DB1 ; DBm,1 @ D0 . If for all DBi , i = 1; 2; : : :; m,

2 1

s there exists a path (D0 ; D1), (D1 ; D2 ), : : :, (Ds,1; Ds ), 1, DBi @ D0 , then since T1 S D0 Tm , by Lemma 3,

(Ds ; D00) in LDG such that for all Di , i = 1; 2; : : :; s, we have that T~1D0 S~D0 T~mD0 . Thus, by Lemma 4,

there exists a DBj , j = 1; 2; : : :; m , 1, such that T~1D S~D T~mD . Else, there exists a DBk , k =

DBj @ Di . Further, for all Li , i = 1; 2; : : :; s, there ex- 2; 3; : : :; m , 2, such that DBk 6@ D0 . Let k1 be

ists a DBj , j = 1; 2; : : :; m , 1, such that DBj @ Li . such that DBk 6@ D0 and for all k = 1; 2; : : :; k1 ,

1, DBk @ D0 . Thus, Tk ,1 DBk , Tk and

1

Lemma 8: Let the set of domains satisfy the Tk DBk Tk +1 , where DBk ,1 @ D0 and

1 1 1 1

restriction R1 and let LDG be acyclic. Further, let DBk 6@ D0 . Since Tk executes both on DB0 k ,1

1 1 1 1

T~1D S~0D0

1 1 1

1

transactions such that global(T1 ; D) and global(Tn ; D). 1

0 1

0

If T1 DB T2 T2 DB T3 , : : :, Tn,1 DBn, Tn, then T~kD and T~kD S~D0 T~mD . Hence, T~1D S~D0 T~mD .

T~1D S~D T~nD . Thus, by Lemma 4, T~1D S~D T~mD .

1 2 1 1 1

Proof: The proof in by induction on n. { (DBm,1 6v D0 :) Let DBm00,1 @ D00 , where00 D00 20

Basis (n = 1): Thus, T1 DB T2. There are two cases TOP and Dom(Tm ) v D . Note that D 6= D

and further D00 6= D. Since T1 executes in both

1

to consider.

D and D0 , and Dom(T1 ) v D0 , LDG contains

{ (DB v D:) In this case, T

1 1 S D T2 . Thus, by an edge (D; D0 ). Let label(D; D0 ) = L0 . Simi-

Lemma 3, since global(T1 ; D) and global(T2 ; D), we larly, since Tm executes in both D and D00 , and

have that T~1D S~D T~2D . Dom(Tm ) v D00, LDG contains an edge (D; D00 ).

{ (DB1 6v D:) Let DB1 @ D 0 , where D0 2 TOP. By Let label(D; D00 ) = L00. We rst show that it must

0 0

Lemma 3, T~1D S~D0 T~2D . Since global(T1 ; D) and be the case that L0 = L00 .

global(T2 ; D), by Lemma 4, T~1D S~D T~nD . Assume on the contrary that L0 6= L00. Since

T1 DB T2 , T2 DB T3, : : :, Tm,1 DBm,

Tm , where DB1 @ D0 and DBm,1 @ D00 , by

1 2 1

Induction: Assume that the lemma holds for all n Lemma 7, there exists a path (D0 ; D1 ), (D1 ; D2 ),

m , 1. We show that it holds for n = m. Thus, we : : :, (Dr,1 ; Dr ), (Dr ; D00) such that for all Di , i =

have T1 DB T2 , T2 DB T3 , : : :, Tm,1 DBm, Tm . 1; 2; : : :; r, there exists a DBj , j = 1; 2; : : :; m , 1,

There are two cases to consider.

1 2 1

{ (there exists i, i = 1; 2; 3; : : :; m , 1, DBi @ D:) Let (Dl ; Dm ), there exists a DBj , j = 1; 2; : : :; m , 1,

DBk @ D, 1 k m , 1. Further, let DBk and DBj @ label(Dl ; Dm ). Since for all DBj , DBj 6@

DBk , 1 k k, and k k m , 1, be such

1 D, the path does not contain D. Hence, LDG

2 1

that for all DBi , i = k ; k + 1; : : :; k; k + 1; : : :; k ,

2 contains a cycle (D; D0 ), (D0 ; D1), (D1 ; D2), : : :,

DBi @ D, DBk , 6@ D and DBk 6@ D. If k = 1

1 1 2 (Dr,1 ; Dr ), (Dr ; D00 ), (D00 ; D). We next show, us-

and k = m , 1, then by Lemma 3, since

1 1

for all DBi ,

2 +1 1 ing induction on r, that LDG contains a undesir-

able cycle.

i = 1; 2; : : :; m , 1, DBi @ D, T~D S D T~mD . So we

2

only need to consider the case in which either 1 < k 1 (D0 ; D00 ). Let

or k < m , 1. There are two cases to consider:

2 label(D0 ; D000) = L000. Since there exists a DBj

{ (1 < k :) Consider transaction Tk . Note that

1 such that DBj @ L000, and further since L0 @ D

and L00 @ D, it is the case that L000 6= L00 and

1

Tk , DBk , Tk and further Tk DBk Tk .

1 1 +1

Since DBk , 6v D, DBk v D, and transaction L000 6= L00 . Since by assumption L0 6= L00, the cy-

1 1 1 1 1 1

1

Tk executes on DBk and DBk ,1 , global(Tk ; D). cle, (D; D0 ), (D0 ; D00), (D00 ; D) is a undesirable

1 1

1 1 1 1

cycle.

T~nD . Hence, T~1D S~D T~nD .

1 1

Induction: Assume that if there is a cycle (D; D0 ),

{ ( k2 < m,1:) Consider transaction Tk . Note that (D ; D1 ), (D1 ; D2), : : :, (Dr,2 ; Dr,1), (Dr,1 ; D00),

0

Tk DBk Tk +1 and further Tk +1 DBk

2

(D00 ; D), then LDG contains a undesirable cycle.

Tk +2 . Since DBk +1 6v D, DBk v D, and

2 2 2 2 2 +1 We next show that if there exists a cycle

2

transaction Tk +1 executes on DBk and DBk +1 ,

2 2

(D; D0 ), (D0 ; D1), (D1 ; D2), : : :, (Dr,1 ; Dr ),

global(Tk ; D). Hence, by IH, T~1D S~D T~kD+1 and

2 2 1

(Dr ; D00), (D00 ; D)

in the LDG, then LDG contains a undesirable cy-

further T~kD+1 S~D T~nD . Hence, T~1D S~D T~nD .

2 2

Concurrency Control in Hierarchical Multidatabase Systems 21

: : :, (Dr,1 ; Dr ), (Dr ; D00), (D00 ; D). Let the labels is a contradiction. Hence, the sequence of transactions

on the edges (D0 ; D1), (D1 ; D2), : : :, (Dr,1 ; Dr ), cannot exist. Thus, S is serializable.

(Dr ; D00 ) be L1 ; L2; : : :; Lr respectively. By as-

sumption L0 6= L00. Further, since for each Li ,

there exists a DBj , j = 1; 2; : : :; m , 1 such that

DBj @ Li , and since L0 @ D, L00 @ D, and since References

for all DBj , j = 1; 2; : : :; m , 1, DBj 6@ D, it is

the case that L0 6= Li and L00 6= Li , for all i = R.K. Batra, D. Georgakopoulos, and M. Rusinkiewicz. A decen-

1; 2; : : :; r. Thus, if the cycle (D; D0 ), (D0 ; D1 ), tralized deadlock-free concurrency control method for multi-

database transactions. In Proceedings of the Twelfth Interna-

(D1 ; D2), : : :, (Dr,2 ; Dr,1 ), (Dr,1 ; D00), (D00 ; D), tional Conference on Distributed Computing Systems, Yoko-

is not a undesirable cycle, then there must exist homa, Japan, 1992.

labels Lr ; Lr in the cycle such that Lr = Lr . C. Beeri, H.-J. Schek, and G. Weikum. Multi-level transaction

Consider domains Dr ,1 , Dr +1 . Since Lr @

1 2 1 2

management, theoretical art or practical need? In Interna-

Dr ,1 and Lr @ Dr +1 , there is an edge be-

1 2 1

tional Conference on Extending Database Technology, Lec-

tween Dr ,1 and Dr +1 with a label L such that

1 2 2

ture Notes on Computer Science, volume 303. Springer Verlag,

Lr @ L. Hence, there exists a cycle in LDG,

1 2

1988.

P. A. Bernstein, V. Hadzilacos, and N. Goodman. Concurrency

(D; D0 ), (D0 ; D1 ), (D1 ; D2), : : :, (Dr ,1; Dr +1 ),

1

(Dr +1 ; Dr +2 ), : : :, (Dr,1 ; Dr ), (Dr ; D00), (D00 ; D)

1 2

such that the length of the cycle is less than r. Y. Breitbart and L. Tieman. Adds- heterogeneous distributed

Thus, by IH, there exists a undesirable cycle in database system. In F.A. Schreiber and W. Litwin, editors,

LDG. Distributed Data Sharing Systems. North Holland Publishing

Hence it must be the case that L0 = L00. Since Company, 1985.

Dom(Tm ) v D00 , and Tm executes in D, Tm ex- Y. Breitbart and A. Silberschatz. Multidatabase update issues. In

Proceedings of ACM-SIGMOD 1988 International Conference

ecutes in L00 . Since L00 = L0 and L0 @ D0 , it is on Management of Data, Chicago, pages 135{141, 1988.

the case that Tm executes in D0 . Further since Y. Breitbart, A. Silberschatz,and G. R. Thompson. Reliable trans-

global(Tm ; D), it is the case that global(Tm ; D0 ). action management in a multidatabase system. In Proceedings

Hence, we have that T1 DB T2 , T2 DB T3 , of ACM-SIGMOD 1990 International Conference on Man-

: : :, Tm,1 DBm, Tm , where global(T1 ; D0 ),

1 2

agement of Data, Atlantic City, New Jersey, pages 215{224,

global(Tm ; D0 ) and DB1 @ D0 and DBm,1 @ D00 .

1

1990.

Y. Breitbart, H. Garcia-Molina, and A. Silberschatz. Overview of

Since D0 6= D00 , there exists a k such that for multidatabase transaction management. VLDB Journal, 1(2),

all i, 1 i < k, DBk @ D0 and DBk 6@ D0 . 1992.

Hence, since Tk,1 DBk, Tk , and Tk DBk Y. Breitbart, A. Silberschatz, and G. R. Thompson. Transaction

Tk+1 , where DBk,1 @ D0 and DBk 6@ D0 , we management in a failure-prone multidatabase environment.

1

have that0 global(Tk0; D0 ). Thus, by IH, we have VLDB Journal, 1(1), 1992.

W. Du and A. K. Elmagarmid. Quasi serializability: a correct-

that T~1D S~D0 T~kD and T~kD0 S~D0 T~nD0 . Thus, ness criterion for global concurrency control in InterBase. In

T~1D0 S~D0 T~nD0 . Hence, by Lemma 4, T~1D S~D Proceedings of the Fifteenth International Conference on Very

Large Databases, Amsterdam, pages 347{355, 1989.

T~nD . Hence proved. A. K. Elmagarmid and W. Du. Supporting value dependencies for

nested transactions in interbase. Technical Report CSD-TR-

Since we had reduced our task of proving Theo- 885, Purdue University, Computer Sciences Department, May

rem 3 to that of proving that under the hypothesis of 1989.

A.K. Elmagarmid and W. Du. A paradigm for concurrency control

Theorem 3, if there exists transaction Ti ; Tj , such that in heterogeneous distributed database systems. In Proceedings

global(Ti ; D) and global(Tj ; D), and Ti S Tj , then of the Sixth International Conference on Data Engineering,

T~iD S~D T~jD , the proof of Lemma 8 completes our task Los Angeles, 1990.

D. Georgakopoulos, M. Rusinkiewicz, and A. Sheth. On serializ-

of proving Theorem 3. We summarize the proof of The- ability of multidatabase transactions through forced local con-

orem 3 below.
icts. In Proceedings of the Seventh International Conference

on Data Engineering, Kobe, Japan, 1991.

Proof of Theorem 3: If S is not serializable, then V. Gligor and G. L. Luckenbaugh. Interconnecting heterogeneous

database management systems. IEEE Computer, pages 33{43,

there exists transactions T1 ; T2 ; : : :; Tn such that T1 DB January 1984.

T2 , T2 DB T3, : : :, Tn,1 DBn, Tn , Tn DBn

1

T1 . Let D 2 TOP such that DB1 @ D. If for all

2 1

distributed heterogeneous database management systems. In

DBi , i = 1; 2; : : :; n, DBi @ D, then T1 S D T1 . F.A. Schreiber and W. Litwin, editors, Distributed Data Shar-

Hence, by Lemma 3, T~1D S~D T~1D which is a contra- ing Systems, pages 43{56. North Holland PublishingCompany,

1985.

diction. Thus, there exists a DBk 6@ D. Let for all V. Gligor and R. Popescu-Zeletin. Transaction management in

DBi , 1 i < k, DBi @ D and further DBk 6@ D. distributed heterogeneous database management systems. In-

Hence, since transaction Tk executes on both DBk,1 and formation Systems, pages 287{297, 1986.

DBk , global(Tk ; D). Consider the sequence of con icts J. Gray and A. Reuter. Transaction Processing: Concepts and

Tk DBk Tk+1, Tk+1 DBk Tk+2, : : :, Tn,1 DBn, Techniques. Morgan Kaufmann, San Mateo, California, 1993.

+1

Tn , Tn DBn T1 , T1 DB T2 , : : :, Tk,1 DBk, Tk .

1

T. Landers and R. L. Rosenberg. An overview of multibase. In

H. J. Schneider,editor, Distributed Data Bases. North Holland

Since global(Tk ; D), by Lemma 8, T~kD S~D T~kD which

1 1

22 Sharad Mehrotra, Henry F. Korth, and Avi Silberschatz

D. Lomet and B. Salzberg. Access method concurrency and re- G. Weikum and H.-J. Schek. Concepts and applications of mul-

covery. In Proceedings of ACM-SIGMOD 1992 International tilevel transactions and open nested transactions. In A. K.

Conference on Management of Data, San Diego, California, Elmagarmid,editor, Advanced Transaction Models for new ap-

1992. plications. Morgan-Kaufmann, 1991.

D. Lomet. Key range locking. In Proceedings of the Nineteenth A. Wolski and J. Veijalainen. 2PC agent method: Achieving se-

International Conference on Very Large Databases, Dublin, rializability in presence of failures in a heterogeneous multi-

1993. database. In Proceedings of the International conference on

S. Mehrotra, R. Rastogi, H. F. Korth, and A. Silberschatz. Non- databases, parallel architectures and their applications, pages

serializable executions in heterogeneous distributed database 321{330, March 1990.

systems. In Proceedings of the First International Confer- A. Zhang, M. Nodine, B. Bhargava, and O. Bukhres. Ensuring re-

ence on Parallel and Distibuted Information Systems, Miami laxed atomicity for
exible transactions in multidatabase sys-

Beach, Florida, 1991. tems. In Proceedings of ACM-SIGMOD 1994 International

S. Mehrotra, R. Rastogi, Y. Breitbart, H. F. Korth, and A. Silber- Conference on Management of Data, Minneapolis, Minnesota,

schatz. The concurrency control problem in multidatabases: 1994.

Characteristics and solutions. In Proceedings of ACM-

SIGMOD 1992 International Conference on Management of

Data, San Diego, California, 1992.

S. Mehrotra, R. Rastogi, Y. Breitbart, H. F. Korth, and A. Sil- This article was processed by the author using the LaTEX style le

berschatz. Ensuring transaction atomicity in multidatabase cljour2 from Springer-Verlag.

systems. In Proceedings of the Eleventh ACM SIGACT-

SIGMOD-SIGART Symposium on Principles of Database

Systems, San Diego, California, 1992.

S. Mehrotra, R. Rastogi, H. F. Korth, and A. Silberschatz. Re-

laxing serializability in multidatabase systems. In Proceedings

of the Second International Workshop on Research Issues on

Data Engineering: Transaction and Query Processing, Mis-

sion Palms, Arizona, February 1992.

S. Mehrotra, R. Rastogi, H. F. Korth, and A. Silberschatz. A

transaction model for heterogeneous distributed database sys-

tems. In Proceedings of the Twelfth International Conference

on Distributed Computing Systems, Yokohoma, Japan, 1992.

C. Mohan. ARIES/KVL: A key-value locking method for concur-

rency control of multiaction transactions operating on B-trees

indexes. Technical Report RJ7008, IBM Research, September

1989.

C. Mohan and F. Levine. ARIES/IM: An ecient and high concur-

rency index management method using write-ahead logging.

Technical Report RJ6846, IBM Research, August 1989.

J. E. B. Moss. Nested transactions: An introduction. In B. Bhar-

gava, editor, Concurrency Control and Reliability in Dis-

tributed Systems, pages 395{425. Van Nostrand Reinhold,

1987.

P. Muth, T. C. Rakow, Weikum G., Brossler P, and Hasse C. Se-

mantic concurrency control in object-oriented database sys-

tems. In Proceedings of the Ninth International Conference

on Data Engineering, Vienna, Austria, pages 233{242, 1993.

M. Ouzzani, M. A. Atroun, and N. L. Belkhodja. A top-down

approach to two-level serializability. In Proceedings of the 20th

International Conference on Very Large Databases, Santiago,

Chile, 1995.

C. Papadimitriou. The Theory of Database Concurrency Control.

Computer Science Press, Rockville, Maryland, 1986.

C. Pu. Superdatabases for composition of heterogeneous

databases. In Proceedings of the Fourth International Con-

ference on Data Engineering, Los Angeles, 1988.

H.-J. Schek, G. Weikum, and W. Schaad. A multi-level transac-

tion approach to federated dbms transaction management. In

International Workshop on Interoperability in Multidatabase

Systems, 1991.

M. Templeton, D. Brill, A. Hwang, I. Kameny, and E. Lund. An

overview of the mermaid system - a frontend to heterogeneous

databases. In Proceedings EASCON, pages 387{402, 1983.

J. Veijalainen and A. Wolski. The 2PC agent method and its

correctness. Technical Report Research Notes 1192, Technical

research Centre of Finland, December 1990.

G. Weikum and H. Schek. Architectural issues of transaction

maangement in multi-layered systems. In Proceedings of the

Tenth International Conference on Very Large Databases,

Singapore, pages 454{465, 1984.

- Db2 Luw Useful CommandsHochgeladen vondb2dbasaurabh
- NATURAL ProgrammingHochgeladen vonJorge Armas Ramirez
- BANKING SYSTEM Presentation made by NITIN, CHANDRA SHEKHERHochgeladen vonAdesh Kumar Yadav
- BEA_FORR_InformationFabric2_0Hochgeladen vonSandip Ghosh
- Transport SynopisHochgeladen vonshantu_11
- STU0018_PKHochgeladen vonajextope
- dbfarmHochgeladen vonPreeti Gupta
- RC1801A12Hochgeladen vonManisha Mattu
- Pengantar Basis DataHochgeladen vonFadhilah Alfiani Yusran
- Data File (Autosaved)Hochgeladen vonAcharya Krishna
- 2002 Replication Techniques in Distributed Systems Advances in Database Systems.9780792398004.29706Hochgeladen vonThinh Nguyen
- HRMHochgeladen vonsrijei
- 4 - SM7 IE Class Slides, Module 4 (System-Wide Config) as of 10-28Hochgeladen voneroenko
- Test+Unit+2+Mod+2+Objective+1+ +6Hochgeladen vonKevin Mckoy
- 2007Hochgeladen vonnanimanojrajiv
- Setting up Material Status ControlHochgeladen vonShridharKhandekar
- UntitledHochgeladen vondnlkaba
- POSMANHochgeladen vonnikhilburbure
- PGM 1Hochgeladen vonmjeee
- What is Pragma Autonomous Transaction_ Plz Can u Let Me Know It in a Simple Understandable Way.thanks in AdvanceHochgeladen vonbskrbvkr
- log_150428Hochgeladen vonkkei_p
- Transaction InternalsHochgeladen vonrprytz
- 219539531 Framework Manager Interview QuestionsHochgeladen vonpramee
- PLSQL_s03_l04Hochgeladen vonHector Martinez
- What is the Function of Database for Computer ScienceHochgeladen vonAldionBiranFachrezy
- MTP SolutionHochgeladen vonVanshika Garg
- NoSQL PPTHochgeladen vonShaik Mahaboob Basha
- Global User Guide.pdfHochgeladen vonArtem Yadegarian
- DBMSHochgeladen vonKunal
- Sap Fi Intercompany ReconciliationHochgeladen vonLuis Morey

- Key for II Mid Dbms AHochgeladen vonjyothibellaryv
- ACID properties of transactionsHochgeladen vonSwati Pqr
- BBIT 423 CISY 423 - Advanced Database SystemsHochgeladen vonAnyumba Kennedy Ochieng
- SM12 - Lock ConceptHochgeladen vonPILLINAGARAJU
- ACID DatabaseHochgeladen vonManish Rauniyar
- LockingHochgeladen vonDaniel Mano
- Advantages of MnesiaHochgeladen vonjoshmuza
- Principles of DBMS Syllabus and Course Plan (1)Hochgeladen vonAditya Aadi
- # SyllabusHochgeladen vonVicky Singh
- RDBMS NotesHochgeladen vonSoumya Jyoti Bhattacharya
- 2.1 - Data Con CurrencyHochgeladen vonracroi3010
- Gujarat University-t.y.bca SyllabusHochgeladen vonSouvik Basu
- Advanced Operating System Lesson PlanHochgeladen vonSukanta Kundu
- ddb08Hochgeladen vonAnvesh Reddy Minukuri
- CSE_Database Management SystemsHochgeladen vonNikhilesh Prabhakar
- Dos QuestionsHochgeladen vonmanideepreddy
- chap16aHochgeladen voncompiler&automata
- TcsHochgeladen vonapi-3729768
- dbms pptHochgeladen vonMd Nasir
- IT Audit Ch 3(1)Hochgeladen vonGil Enriquez
- Lock FinalHochgeladen vonHitesh Panwar
- ICS 143 - Principles of Operating SystemsHochgeladen vonpalegreat
- rptIpPrintNew (5) (1)Hochgeladen vonDominic ROger
- Rlu Sosp15 PaperHochgeladen vonsymmetricdup
- dbms r16 syllabus of jntuk and its structureHochgeladen vonChristina Robinson
- Notify DebugHochgeladen vonCarolina Gamecocks
- DBMS NOTES.docxHochgeladen vonGetTrending
- dbmsHochgeladen vonSanmay Kokate
- lec 37-40.pdfHochgeladen vonVishal Mittal
- DBMSHochgeladen vonkalyanram19858017

## Viel mehr als nur Dokumente.

Entdecken, was Scribd alles zu bieten hat, inklusive Bücher und Hörbücher von großen Verlagen.

Jederzeit kündbar.