scispace - formally typeset

Journal ArticleDOI

Ensuring relaxed atomicity for flexible transactions in multidatabase systems

24 May 1994-Sigmod Record (ACMPUB27New York, NY, USA)-

TL;DR: Global transaction management requires cooperation from local sites to ensure the consistent and reliable execution of global transactions in a distributed database system.

AbstractGlobal transaction management requires cooperation from local sites to ensure the consistent and reliable execution of global transactions in a distributed database system. In a heterogeneous distr...

Topics: Atomicity (68%), Distributed database (57%)

Summary (3 min read)

1 Introduction

  • A flurry of research activity has been devoted to the problems of enhancing transaction management by using extended transaction models.
  • In particular, some flexible transaction models proposed for the MDBS environment, such as Flex Transactions [8] and S-transaction [22] , increase the failure resiliency of global transactions by allowing alternative subtransactions to be executed when a local database fails or a subtransaction aborts.
  • Transaction to adhere to a weaker form of atomicity, which the authors term semi-atomicity, while still maintaining its correct execution in the multidatabase.
  • The following example is illustrative: Ift 2 fails, ta may replace t2.
  • Most of this work has assumed the availability of visible prepare-to-commit states in local database systems.

1.1 Proposed Research

  • The authors present an approach which preserves semi-atomicity in an MDBS environment in which the local database systems are requ.ired only to ensure serializability and recoverability [4] .
  • Each partial order provides one alternative for the successful execution of the flexible transaction.
  • This methodology differs from previous approaches in that no specific application semantics are involved.
  • Therefore, a theoretical basis for flexible transaction management can be built.
  • As the compensation and retry approaches [15) are unified and employed as flexible transaction failure recovery techniques, local prepare-to-commit states are no longer required.

1.3 Structure of the Paper

  • Section 2 introduces the fundamental flexible transaction model and Section 3 defines the property of semi-atomicity.
  • In Section 4, the authors define those flexible transac tions that can be executed in the error-prone MDBS environment without requiring local prepare-tocommit states.
  • In Section 5, the authors present the flexible transaction recovery protocol and demonstrate its effectiveness in preserving the semi-atomicity of flexible transactions.
  • Concluding remarks are offered in Section 6.

4.1 Commit Dependencies

  • Flexible transaction may cause its commitment to result in a deadlock situation, in which each subtransaction has to wait for another subtransa.ction to commit before its commitment.
  • In addition, the possession of two or more pivot subtransactions in a -<-partial order may render it difficult to determine a commit order among them which ensures that the -<-partial order can move either forward to the commitment of its sub transactions or backward to the removal of any partial effects of the committed subtransactions.

4.2 Well-formed Flexible Transactions

  • By the critical point determination rules, t2 is the critical point for all three partial orders, because there is altemative if the pivot 8ubtransaetion i3 fails.
  • Thus, ta. is, t6, t7 are abnormal subtransactions and among them, ls. ts. and t6 are the blocking points.
  • Thus, in a well-formed flexible transaction t for any -<-partial order (Tit -<) which contains an abnormal subtransaction t, there is at least one alternative -<-partial order (Tj, -<) which shares a prefix with (TiI-<) such that the aborting of t will lead the execution of T from (Tit -<) to (Tj,-<) without resulting in any database inconsistency.

Observation 1 If a flexible transaction is well-formed. it has at least one -<-partial order such

  • That it has no abnormal subtransaction and no other -<-partial order has lower priority than it.
  • The only blocking point t4 constitutes a switching set.
  • In Example 3, the flexible transaction 7 has one -<-partial order 1'3 that contains no abnormalsubtransaction.
  • Since the blocking point t3 constitutes the switching set and the blocking points t s and ta also constitute the switching set, T is also well-formed.

S is commit dependency preserving and F-recoverable, then the semi-atomicity of T is preservable.

  • Without loss of generality, the authors assume that each -<-partial order of T contains at least one pivot subtransaction.
  • Then, at least one pivot subtransaction of (7i, -<) has committed.
  • Since T is well-formed, by Definition 3, the execution of (Ti, -<) can be changed to another -<-partial order (Tj, -<) without resulting in any database inconsistency.
  • Because abnormal subtransactions are permitted, the concept of a well-formed flexible transaction greatly extends the scope of global transactions that can be specified in the MDBS environment beyond that of the basic global transaction model proposed in [15}.

5 The Flexible Transaction Commit Protocol

  • As each subtransaction begins to execute, the type of the sub transaction is sent to the local database server with the begin command.
  • The operations belonging to the sub transaction are submitted to an individual local data.
  • The completion of each submitted operation, as well as the begin and commit operations, are individually acknowledged by the local database server to the GTM.

5.2 The Commit Protocol

  • When all subtransactions in the currently executing -<-partial order of the flexible transaction enter the committed state, the flexible transaction commits.
  • All its subtransactions which are not in the committed -<-partial order should be in either inactive, aborted, or committed-reversed states.
  • Otherwise, there is no committed -<-partial order, the flexible transaction aborts.
  • All its subtransactions should be in either inactive, aborted, or committed-reversed state.

Did you find this useful? Give us your feedback

...read more

Content maybe subject to copyright    Report

Purdue University Purdue University
Purdue e-Pubs Purdue e-Pubs
Department of Computer Science Technical
Reports
Department of Computer Science
1993
Ensuring Relaxed Atomicity for Flexible Transactions in Ensuring Relaxed Atomicity for Flexible Transactions in
Multidatabase Systems Multidatabase Systems
Aidong Zhang
Marian H. Nodine
Omran Bukhres
Report Number:
93-069
Zhang, Aidong; Nodine, Marian H.; and Bukhres, Omran, "Ensuring Relaxed Atomicity for Flexible
Transactions in Multidatabase Systems" (1993).
Department of Computer Science Technical Reports.
Paper 1082.
https://docs.lib.purdue.edu/cstech/1082
This document has been made available through Purdue e-Pubs, a service of the Purdue University Libraries.
Please contact epubs@purdue.edu for additional information.

ENSURING RELAXED ATOMICITY
FOR
FLEXIBLE TRANSACfIONS IN
MULTIDATABASE SYSTEMS
Aidong Zhang
Marian H. Nodine
Omran Bukhres
CSD-TR-93-069
November 1993

Ensuring
Relaxed
Atomicity
for
Flexible
Transactions
in
Multidatabase
Systems
Aidong Zhang·
Marian H. Nodine*
Omran
Bukhres*
-Department
of
Computer
Sciences
Purdue
University
West Lafayette,
IN
47907 USA
{azbang, bukhres}@cs.purdue.edu
"'Department of
Computer
Sciences
Brown University
Providence,
RI
02912 USA
mhn@cs.brown.edu
Abstract
Global tra.nsaction management
and
the
preservation
of
local autonomy are conflicting re-
quirements
in
the design
of
multidatabase
transaction management systems. A flexible trans-
action model for
the
specification
of
global transactions makes it possible to construct robust
global transactions while still preserving local autonomy.
This
paper
presents an approach
that
preserves semi-atomicity. a weaker form of atomicity applicable to flexible transactions
which
span several local database systems
that
maintain serializability and recoverability.
We
first
offer
a fundamental characterization of the flexible transaction model and then precisely define
semi-atomicity
for
flexible transactions.
We
then investigate the principles underlying the ap-
proach to
ROOble
tra.nsaction management which ensures this property. Finally,
we
construct a
class offlexible transactions
which
can
be
executed
in
the presence offailures using our proposed
commit protocol. The results demonstrate
that
the flexible transaction model substantially en-
hances the scope ofglobal transaction management beyond
that
offered
by
the traditional global
transaction model.
1
Introduction
A
multidatabase
system
(MDBS) is a collection of
autonomous
local
databases
(LDBSs)
that
can
be
accessed as a single unit.
There
are
two types
of
transactions
in a
multidatabase.
A local
transaction,
which accesses a local
database
only,
is
submitted
directly to a local
database
system.
A global
transaction,
in
contrast,
may
access several local
databases.
Such a global
transaction
is
submitted
to a global
transaction
manager
(GTM)
superimposed
upon
a
set
of
local
autonomous
1

database
systems, where
it
is parsed
into
a series
of
global
subtransactions
to
be
submitted
to
the
local
database
systems.
While atomicity
in
traditional
distributed
databases
can
be
ensured using well-known proto-
cols [4],
multidatabase
systems cannot use these protocols directly because
of
the
stronger
autonomy
requirements
of
the
component local.
databases
[3,
21}.
Of
particular
concern
is
the
fact
that
multi-
databases
cannot
assume
that
all
participating
local
databases
support
a visible prepare-to-commit
state
for global
subtransactions,
in which
they
have
not
yet been
committed
but
are
guaranteed
the
ability
to
commit.
In
such situations, a local
database
system
that
participates
in a multi-
database
environment
may
unilaterally
abort
a global subtransa.ction
without
agreement from
the
global. level
(termed
a
local
unilateral abort). As a result,
it
becomes difficult
to
ensure
that
a single
logical. commit action
of
the
subtransactions
of
a global
transaction
will
be
consistently carried
out
at
multiple local sites.
In
addition, even when local
database
systems do provide such
support,
the
potential
blocking
and
long delays caused by prepare-to-commit
states
would severely degrade
local execution autonomy.
A flurry
of
research activity has been devoted to
the
problems
of
enhancing
transaction
man-
agement by using extended
transaction
models.
l
In
particular, some flexible
transaction
models
proposed for
the
MDBS
environment, such as Flex Transactions
[8]
and S-transaction
[22],
increase
the
failure resiliency
of
global transactions by allowing alternative
subtransactions
to
be
executed
when a local
database
fails
or
a
subtransaction
aborts.
This
flexibility allows a global.
transaction
to adhere
to
a weaker form
of
atomicity, which we
term
semi-atomicity, while still maintaining
its correct execution in
the
multidatabase.
Semi-atomicity allows a global
transaction
to
commit
even
if
some
subtransactions
abort,
provided
that
their
alternative
subtransactions
commit.
The
following example is illustrative:
Example
1 Consider the following
global
transaction. A user
of
an Automatic Teller Machine
(ATM)
wishes to withdraw $50 from his savings account al in bank b
l
and to obtain the money in
cash from the
ATM.
If
the
ATM
fails
to
disburse the cash, he will instead transfer the $50 to his
checking account
a2
in bank b
2
. With Flex Transactions, this is represented
by
the
follOWing
set
of
subtransactions:
tl:
Withdraw $50 from savings account
al
in bank b
l
.
t2: Disburse $50 from the
ATM.
ta: Transfer $50 to checking account
a2
in bank 6
2
.
In this
global
transaction, either
{tl'
t
2
}
or
{h,
t
a
}
is acceptable, with
{tl'
t2} prefern;d.
Ift
2
fails,
ta may replace
t2.
The entire
global
transaction thus may not have to
be
aborted, even
if
t
2
fails,
but
if
both
t
2
and fa fail, then
it
must abort. 0
1 Many such modelB have
appeared
in
[6,
7].
2

Since
the
flexible transaction model was proposed, much research has been devoted
to
its ap-
plication [13, 2, 1, 12].
Most
of
this work has assumed
the
availability
of
visible prepare-to-commit
states
in local
database
systems.
In
such a scenario,
the
preservation
of
the
semi-atomicity of
flexible transactions is relatively straightforward.
1.1
Proposed
Research
In
this
paper,
we offer a precise definition
of
the
fundamental model
and
of
the
semi-atomicity
property
of
flexible transactions.
We
present
an
approach which preserves semi-atomicity in an
MDBS environment
in which
the
local
database
systems
are
requ.ired only
to
ensure serializability
and
recoverability
[4].
In
the
proposed formulation, a flexible
transaction
is defined as a set
of
subtransactions
upon
which a set
of
partial orders is specified. Each partial
order
provides one
alternative for
the
successful execution of
the
flexible transaction. This methodology differs from
previous approaches in
that
no
specific application semantics
are
involved. Therefore, a theoret-
ical basis for flexible
transaction
management can
be
built. We
then
classify
the
set
of flexible
transactions
that
can
be
executed in an error-prone MDBS environment. As
the
compensation
and
retry
approaches
[15)
are
unified and employed as flexible
transaction
failure recovery techniques,
local prepare-to-commit
states
are
no longer required.
We
demonstrate
that
the
flexible transaction
model substantially enhances
the
scope
of
global transaction management beyond
that
offered by
the
traditional
global transaction model.
1.2
Related
Research
In
order
to
handle local unila.teral
aborts,
approaches using forward recovery (redo
and
retry)
and
backward recovery (compensation) have been proposed in
the
literature. These approaches seek to
ensure
the
semantic atomicity
[9]
of
global transactions in MDBSs. When a subtransa.ction of a
global
transaction
aborts,
the
GTM
may
either re-execute
it
until commitment
or
undo
the
effects
of
the
committed
subtransactions
of
the
global transaction.
The
strategies characterizing these
approaches can
be
classified by
the
relative timing
of
the commitment
of
subtransactions in
the
local
databases
with respect
to
the
global transaction
commit/abort
decision [16]. [23,5] enforce a
global decision on
the
subtransactions by redoing or retrying
them
as necessary. [19,14,18] commit
subtransactions locally before a global decision is
made
and
rely
on
compensation when a global
transaction is aborted. [15,
17]
combine these two approaches.
With
the
forward approach, all
subtransa.ctions
must
be redoable or retriable, while
the
backward approach requires
that
all sub-
transactions
must
be
compensatable.
With
the
combined approach, only one subtransaction
of
each
global
transaction
can be neither retriable
nor
compensatable,
and
the
rest of its subtransactions
must
be
either retriable
or
compensatable. Consequently,
the
ability
to
specify global transactions
becomes severely limited when
the
traditional global transaction model is employed in MDBSs.
3

Citations
More filters

Journal ArticleDOI
TL;DR: The proposed concurrency control algorithm, v-lock, uses global locking tables created with semantic information contained within the hierarchy that are used to serialize global transactions, detect and remove global deadlocks.
Abstract: As technological advances are made in software and hardware, the feasibility of accessing information "any time, anywhere" is becoming a reality. Furthermore, the diversity and amount of information available to a given user is increasing at a rapid rate. In a mobile computing environment, a potentially large number of users may simultaneously access the global data; therefore, there is a need to provide a means to allow concurrent management of transactions. Current multidatabase concurrency control schemes do not address the limited bandwidth and frequent disconnection associated with wireless networks. This paper proposes a new hierarchical concurrency control algorithm. The proposed concurrency control algorithm, v-lock, uses global locking tables created with semantic information contained within the hierarchy. The locking tables are used to serialize global transactions, detect and remove global deadlocks. Additionally, data replication, at the mobile unit, is used to limit the effects of the restrictions imposed by a mobile environment. The replicated data provides additional availability in case of a weak connection or disconnection. Current research has concentrated on page and file-based caching or replication schemes to address the availability and consistency issues in a mobile environment. In a mobile, multidatabase environment, local autonomy restrictions prevent the use of a page or file-based data replication scheme. This paper proposes a new data replication scheme to address the limited bandwidth and local autonomy restrictions. Queries and the associated data are cached at the mobile unit as a complete object. Consistency is maintained by using a parity-based invalidation scheme. A simple prefetching scheme is used in conjunction with caching to further improve the effectiveness of the proposed scheme. Finally, a simulator was developed to evaluate the performance of the proposed algorithms. The simulation results are presented and discussed.

68 citations


Journal ArticleDOI
TL;DR: An overview of correctness in workflow management is provided, enumerating the correctness issues that have to be considered to ensure data consistency and survey techniques that have been proposed or are being used in WFMSs for ensuring correctness of workflows.
Abstract: Workflow management is a technique to integrate and automate the execution of steps that comprise a complex process, e.g., a business process. Workflow management systems (WFMSs) primarily evolved from industry to cater to the growing demand for office automation tools among businesses. Coincidentally, database researchers developed several extended transaction models to handle similar applications. Although the goals of both the communities were the same, the issues they focused on were different. The workflow community primarily focused on modelling aspects to accurately capture the data and control flow requirements between the steps that comprise a workflow, while the database community focused on correctness aspects to ensure data consistency of sub-transactions that comprise a transaction. However, we now see a confluence of some of the ideas, with additional features being gradually offered by WFMSs. This paper provides an overview of correctness in workflow management. Correctness is an important aspect of WFMSs and a proper understanding of the available concepts and techniques by WFMS developers and workflow designers will help in building workflows that are flexible enough to capture the requirements of real world applications and robust enough to provide the necessary correctness and reliability properties. We first enumerate the correctness issues that have to be considered to ensure data consistency. Then we survey techniques that have been proposed or are being used in WFMSs for ensuring correctness of workflows. These techniques emerge from the areas of workflow management, extended transaction models, multidatabases and transactional workflows. Finally, we present some open issues related to correctness of workflows in the presence of concurrency and failures.

55 citations


Book ChapterDOI
20 Nov 2005
TL;DR: This paper proposes a mechanism to ensure the consistent executions of isolation-relaxing WS transactions, and proposes a new Web services Transaction Dependency management Protocol (WTDP), which helps organizations manage the WS transactions easily without data inconsistency.
Abstract: For efficiently managing Web Services (WS) transactions which are executed across multiple loosely-coupled autonomous organizations, isolation is commonly relaxed. A Web services operation of a transaction releases locks on its resources once its jobs are completed without waiting for the completions of other operations. However, those early unlocked resources can be seen by other transactions, which can spoil data integrity and causes incorrect outcomes. Existing WS transaction standards do not consider this problem. In this paper, we propose a mechanism to ensure the consistent executions of isolation-relaxing WS transactions. The mechanism effectively detects inconsistent states of transactions with a notion of a completion dependency and recovers them to consistent states. We also propose a new Web services Transaction Dependency management Protocol (WTDP). WTDP helps organizations manage the WS transactions easily without data inconsistency. WTDP is designed to be compliant with a representative WS transaction standard, the Web Services Transactions specifications, for easy integration into existing WS transaction systems. We prototyped a WTDP-based WS transaction management system to validate our protocol.

39 citations


Journal ArticleDOI
TL;DR: A process algebraic framework to publish atomicity-equivalent public views from the backend processes that allows service consumers to choose suitable services such that their composition satisfies the atomicity sphere without disclosing the details of their backend processes.
Abstract: Atomicity is a highly desirable property for achieving application consistency in service compositions. To achieve atomicity, a service composition should satisfy the atomicity sphere, a structural criterion for the backend processes of involved services. Existing analysis techniques for atomicity sphere generally assume complete knowledge of all involved backend processes. Such an assumption is invalid when some service providers do not release all details of their backend processes to service consumers outside the organizations. To address this problem, we propose a process algebraic framework to publish atomicity-equivalent public views from the backend processes. These public views extract relevant task properties and reveal only partial process details that service providers need to expose. Our framework enables the analysis of atomicity sphere for service compositions using these public views instead of their backend processes. This allows service consumers to choose suitable services such that their composition satisfies the atomicity sphere without disclosing the details of their backend processes. Based on the theoretical result, we present algorithms to construct atomicity-equivalent public views and to analyze the atomicity sphere for a service composition. Two case studies from supply chain and insurance domains are given to evaluate our proposal and demonstrate the applicability of our approach.

36 citations


Journal ArticleDOI
TL;DR: A new concurrency control criterion for the execution of flexible and local transactions, termed F- serializability, in the error-prone heterogeneous distributed database environments is proposed and a scheduling protocol is presented that ensures F-serializability on global schedules.
Abstract: A heterogeneous distributed database environment integrates a set of autonomous database systems to provide global database functions. A flexible transaction approach has been proposed for the heterogeneous distributed database environments. In such an environment, flexible transactions can increase the failure resilience of global transactions by allowing alternate (but in some sense equivalent) executions to be attempted when a local database system fails or some subtransactions of the global transaction abort. We study the impact of compensation, retry, and switching to alternative executions on global concurrency control for the execution of flexible transactions. We propose a new concurrency control criterion for the execution of flexible and local transactions, termed F-serializability, in the error-prone heterogeneous distributed database environments. We then present a scheduling protocol that ensures F-serializability on global schedules. We also demonstrate that this scheduler avoids unnecessary aborts and compensation.

36 citations


References
More filters

Journal ArticleDOI
TL;DR: This paper investigates how the semantic knowledge of an application can be used in a distributed database to process transactions efficiently and to avoid some of the delays associated with failures.
Abstract: This paper investigates how the semantic knowledge of an application can be used in a distributed database to process transactions efficiently and to avoid some of the delays associated with failures. The main idea is to allow nonserializable schedules which preserve consistency and which are acceptable to the system users. To produce such schedules, the transaction processing mechanism receives semantic information from the users in the form of transaction semantic types, a division of transactions into steps, compatibility sets, and countersteps. Using these notions, we propose a mechanism which allows users to exploit their semantic knowledge in an organized fashion. The strengths and weaknesses of this approach are discussed.

536 citations


Journal ArticleDOI
Abstract: The history of database system research in the US is one of exceptional productivity and startling economic impact Barely twenty years old as a basic science research field, database research conducted with Federal support in the nation's universities and in its industrial research laboratories has fueled an information services industry estimated at $10 billion per year in the US alone This industry has grown at an average rate of 20 percent per year since 1965 and is continuing to expand at this rate Achievements in database research underpin fundamental advances in communications systems, transportation and logistics, financial management, knowledge-based systems, accessibility to scientific literature, and a host of other civilian and defense applications They also serve as the foundation for considerable progress in basic science in various fields ranging from computing to biology

196 citations


Proceedings ArticleDOI
01 Mar 1992
TL;DR: A transaction model for multidatabase system (MDBS) applications in which global subtransactions may be either compensatable or retriable is presented and a commit protocol and a concurrency control scheme that ensures that all generated schedules are correct are presented.
Abstract: A transaction model for multidatabase system (MDBS) applications in which global subtransactions may be either compensatable or retriable is presented. In this model compensation and retrying are used for recovery purposes. However, since such executions may no longer consist of atomic transactions, a correctness criterion that ensures that transactions see consistent database states is necessary. A commit protocol and a concurrency control scheme that ensures that all generated schedules are correct are also presented. The commit protocol eliminates the problem of blocking, which is characteristics of the standard 2PC protocol. The concurrency control protocol can be used in any MDBS environment irrespective of the concurrency control protocol followed by the local DBMSs in order to ensure serializability. >

167 citations


Proceedings ArticleDOI
01 May 1990
TL;DR: A fault tolerant transaction management algorithm and recovery procedures that retain global database consistency are designed and shown that their algorithms ensure freedom from global deadlocks of any kind.
Abstract: A model of a multidatabase system is defined in which each local DBMS uses the two-phase locking protocol Locks are released by a global transaction only after the transaction commits or aborts at each local site. Failures may occur during the processing of transactions. We design a fault tolerant transaction management algorithm and recovery procedures that retain global database consistency. We also show that our algorithms ensure freedom from global deadlocks of any kind.

143 citations


Proceedings ArticleDOI
01 Apr 1991
TL;DR: A family of practical protocols is devised that ensure semantic atomicity is guaranteed as the effects of a transaction that is finally aborted are undone semantically by a compensating transaction, and reduces to serializability when no global transactions are aborted.
Abstract: A major disadvantage of the two-phase commit (2PC) protocol is the potential unbounded delay that transactions may have to endure if certain failures occur. By combining a novel use of compensating transactions along with an optimistic assumption, we propose a revised 2PC protocol that overcomes these difficulties. In the revised protocol, locks are released when a site votes to commit a transaction, thereby solving the indefinite blocking problem of 2PC. Semantic, rather than standard, atomicity is guaranteed as the effects of a transaction that is finally aborted are undone semantically by a compensating transaction. Relaxing standard atomicity interacts in a subtle way with correctness and concurrency control issues. Accordingly, a correctness criterion is proposed that is most appropriate when atomicity is given up for semantic atomicity. The correctness criterion reduces to serializability when no global transactions are aborted, and excludes unacceptable executions when global transactions do fail. We devise a family of practical protocols that ensure this correctness notion. These protocols restrict only global transactions, and do not incur extra messages other than the standard 2PC messages. The results are of particular importance for multidatabase systems.

121 citations