Sie sind auf Seite 1von 22

VLDB Journal Manuscript Nr.

(will be inserted by hand later)

Concurrency Control in Hierarchical Multidatabase


Systems?

Sharad Mehrotra , Henry F. Korth , and Avi Silberschatz


1 2 2

1 Department of Computer Science, University of Illinois at Urbana Champaign


1304 W. Spring eld Avenue, Urbana, IL 61801, USA
2 Lucent Technologies, 600 Mountain Ave, Murray Hill, NJ 07974, USA

Received: <date> / Accepted: <date>

Abstract. Over the past decade, signi cant 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 di erent 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, signi cant research has been
tecture for a multidatabase environment and develop done to identify mechanisms for e ectively 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
sacri cing 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 di erent 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 o er 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 di erent 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, di erent organizations may stein et. al., 1987, is capable of participating in a two-
prefer di erent 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 di erent 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 di er- interoperation may not be a feasible cost-e ective 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 speci c 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, di erent component ing scheme to preserve consistency of the document in-
MDBSs may follow di erent 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 de ne 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 modi ed for the sake of inte- tion that reads both the accounts sees a sum that di ers
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 classi ed 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 a ects 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 signi cant 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 signi cant 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 satis es the following property| if a
ni cant 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 signi cant 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

technique does not provide the complete bene ts of the DBMS1


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 di erent
MDBSs in the hierarchy may follow di erent 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 de ned 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 di erent 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

local(T1 ; D1 ). Suppose another transaction T2 accesses D1 D2


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
satis es 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 de ned as follows.
which is similar to the notion of o-element developed in
Pu 1988 and that of the serialization event introduced De nition 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 de ne 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 satis ed. ations is de ned as follows:
For example, if the timestamp ordering (TO) concur-
rency control protocol is used to ensure serializability of De nition 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 De nition 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

We refer to sf(Ti ; D) as a serialization function of


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 de ned 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 de nitions of the Fig. 4. Domain Ordering for Example 3
transaction T~iD , and the schedule S~D with respect to the
newly de ned serialization function. This is done below.
De nition 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 de ne 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 ) De nition 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 de ned 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 di erent serS~D (T~iD ); if for all DBk , D 6= DBk 
transactions over the same child domain:
De nition 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 de nition 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

that S D and S D are serializable and further that an


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 de ned. 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

tions that map transactions to their commit operations.


3 4

By De nition 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

T~iD , i = 1; 2; 3, are as follows.


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

Consider the schedule S~D that contains transactions 2


5 Ensuring Serializability of S D
~T1D and T~2D . Let serS~D be a function that maps the
2 2

transaction T~iD to its rst operation in S~D . That is,


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 satis es 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

that in S~D , operation c13 con icts with c23Dand c14


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

occurs before serS~D (T~2D ) = c24, the function serS~D


2
2
2
satis es the requirement of the serialization function
2
5.1 Ensuring Serializability in Simple Domains
for S~D . Thus, by De nition 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 De nition 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 modi ca-
functions can be arti cially 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 de n- by the local DBMS a ects the degree of concurrency
ing a new data items, the scheme developed in this pa- a orded 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 di er-
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 di ers 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

domain D such that parent(D ; D) for processing . main D = we


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

main manager for the parent domains of DBk . Further- D1 D2


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 Satis es R1
for a domain D = DBk di ers from the domain manager
de ned 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

main manager for each domain D, in turn, acknowledges ~D ~


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

in the execution, Dthe domainD manager of D1 serialized


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

6 Ensuring Global Serializability manager of D2 serializes T~3D before transaction T~1D ,


2 2

thereby resulting in the loss ofSserializability. If, however,


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

R1: For all domains Di ; Dj 2 TOP , there exists a D3 D1 D2


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
 satis es the restriction R1. Fig. 7. A Domain Ordering with a cyclic DG
Unfortunately, even if the set of domain  satis es
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,  satis es 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  satis es 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 satis es 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  satis es 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  satis es 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  satis es 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  satis es
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 di erent 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

order to ensure global serializability. In the hierarchi-


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 certi cation 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 di erent
domain managers could follow di erent 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 di erence 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 di erence 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 certi cation 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

(and the domain managers of the descendent domains of 4


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, e orts 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. Speci cally, 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 di erent 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 e ec-
schemes, each transaction is de ned 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. ri cing 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 o er 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 di erent domains may follow di erent 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-
di erent component MDBSs may follow di erent 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 speci cally, each of the following three conditions hold:
for a global schedule S and a domain D, we identi ed 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 identi ed 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

In this paper, we did not consider the issue of failure- 1


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 de nition 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 de ned 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

Lemma 2: Consider an MDBS environment with the S


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 ) satis es 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

by de nition of serSk , serSk (Ti ) S serSk (Tj ). Hence,


that DB1 @ D. If for all DBi , i = 1; 2; : : :; n, DBi @ D,
1

sf(Ti ; D) S sf(Tj ; D).


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 de ni-
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 de nition 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 de nition 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 de nition 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

D such that level(D)  p. We show it to be true for


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 de nition 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

sf(Tn,1 ; DBkn ) S sf(Tn ; DBkn ), and


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 de nition 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 de ni-
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 de nition 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 de nition 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

Thus, by Lemma 3, we have that T~i D 0 


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 de ni-
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 de nition 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

j = m , 2; m , 1, such that DBj @ Li . Hence, for some


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

D 2 TOP be a domain, level(D)  2, and T and Tn be


T~1D  S~0D0
1 1 1

and0 DBk , global(T k ; D00). Hence by IH,


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

DBj @ Di and further, for all edges in the path


{ (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

1 ~ Basis (r = 0:) Thus, LDG contains an edge


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

Hence, by IH, T~1D  S~D T~kD and further T~kD  S~D


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

2 cle. Consider the cycle (D; D0 ), (D0 ; D1 ), (D1 ; D2),


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

Control and Recovery in Database Systems. Addison-Wesley,


(Dr +1 ; Dr +2 ), : : :, (Dr,1 ; Dr ), (Dr ; D00), (D00 ; D)
1 2

2 2 Reading, MA, 1987.


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

V. Gligor and R. Popescu-Zeletin. Concurrency conctrol issues in


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

Publishing Company, 1982.


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.