- The
reason
why do we use
conflict-serializability:
- There is a simple procedure
the test/check whether
a schedule S is:
- conflict-serializable
- or not conflict-serializable
- There is a simple procedure
the test/check whether
a schedule S is:
- Observation:
- If we find
2 conflicting actions
(anywhere in a schedule):
then (because opj (X) can never be swap with opi (X)):
- Transaction Ti must precede transaction Tj in a serial schedule
- Therefore, the
ordering in a
serial schedule must be
as follows:
- If we find
2 conflicting actions
(anywhere in a schedule):
- The precedence relationship:
- This observation has determined a
- precedence relationship between transactions Ti and Tj
Specifically:
- Transaction Ti must precede transaction Tj (in a serial schedule)
- This observation has determined a
- Notation:
- We use a graph
to represent
all precedence relationships
found in a
schedule S:
- For every pair
of conflicting actions in
a schedule S:
we add the edge Ti → Tj to the graph
- For every pair
of conflicting actions in
a schedule S:
- Example:
- Schedule:
- Make it easier by
grouping the
action by their
different DB elements:
- Now you can see the
precedence relationships
easier
(find all
conflicting operations):
- Graph with
all precedence relationships:
- Schedule:
- Fact:
- A schedule S is
conflict-serializable
iff:
- The corresponding precedence graph of schedule S does not contain any cycles
- A schedule S is
conflict-serializable
iff:
- Example 1:
- Schedule:
- Precedence graph for the
schedule:
The serial schedule is: T1 T2 T3
- Proof:
swap
the non-conflicting operations:
- Schedule:
- Example 2:
- Schedule:
Group the actions by their DB elements:
- Precedence graph for the
schedule:
This schedule is not conflict-serializable because there is a cycle
- Proof:
- To make a serial schedule with the
order
T1 ... T2
we must
swap this
pair of
conflicting action:
- To make a serial schedule with the
order
T2 ... T1
we must
swap this
pair of
conflicting action:
Therefore: there is no way to swap non-conflicting actions to convert the schedule into a serial schedule !!!
- To make a serial schedule with the
order
T1 ... T2
we must
swap this
pair of
conflicting action:
- Schedule:
- Theorem:
- Let S = a schedule for transactions T1, T2, ..., Tn
- Let G = the
precedence graph of
schedule S
- Then:
- The precedence graph G has
no cycles
⇔ (iff)
- Schedule S is conflict-serializable
- The precedence graph G has
no cycles
⇔ (iff)
- Proving the ⇐ part:
- The precedence graph G has
no cycles
⇐
- The schedule S is conflict-serializable
- Reformulated:
If schedule S is conflict-serializable, then
- the precedence graph G has no cycles
- We will prove the
logical inverse:
If the precedence graph G has a cycle, then:
- The schedule S is not conflict-serializable,
Proof:
- Given: the
precedence graph G has a
cycle
Suppose the cycle consists of the transactions T1, T2, ..., Tk :
- Then the schedule S
must contains the following
non-swappable actions
in this order:
- In order to make a
serial schedule, we
must make the
following
swap:
This swap will re-order conflicting actions.
Therefore:
- Schedule S can not be transformed into a serial schedule by swapping non-conflicting actions
In other word (by definition):
- Schedule S is not conflict-serializable
- The precedence graph G has
no cycles
⇐
- Proving the ⇒ part:
- The precedence graph G has
no cycles
⇒
- Schedule S is conflict-serializable
- In English:
If the precedence graph G has no cycles then
- Schedule S is conflict-serializable
Proof:
- by induction on the number of transactions
Basis: n = 1
- Schedule S is
a schedule of
1 transaction:
T1
- Schedule S is
trivially equal to a
serial schedule !!!
- Schedule S is conflict-serializable !!!
Induction Step:
- Induction assumption:
- If
the precedence graph G
of n transactions
has
no cycles
then (⇒)
- Schedule S of n transactions is conflict-serializable
- If
the precedence graph G
of n transactions
has
no cycles
then (⇒)
- Prove that:
- If
the precedence graph G
of n+1 transactions
has
no cycles
then (⇒)
- Schedule S of n+1 transactions is conflict-serializable
Proof:
- Given: the precedence graph G
of n+1 transactions
has
no cycles
- Then:
- There is at least
1 node
(say: Tk) in
graph G
that has
no ingoing edges:
That means in schedule S:
Every action of Tk in schedule S is preceded by non conflicting actions by other transactions
- Otherwise, there will an in-going edge to Tk !!!
Therefore, we can move all of the actions of Tk to the front of the schedule:
Therefore, schedule S is conflict equivalent to the schedule:
S "==" Tk ; S'' where: S'' is a schedule of n transactions
Furthermore, the dependency graph for the schedule S'' is:
- The original dependency graph
with the node Tk and
all outgoing edgs
removed:
(Because we did not introduce new dependencies nor remove any existing dependency between the other n transactions)
- There is at least
1 node
(say: Tk) in
graph G
that has
no ingoing edges:
- The dependency graph for
the schedule S''
does not have
cycles:
- Because removing a node Tk and all its outgoing edgs will not create cycles in a graph
So:
- S'' is a schedule of n transactions
- Its dependency graph does not have cycles
By the induction assumption, we conclude that:
- S'' is a conflict-serializable schedule
Therefore:
S "==" Tk ; S'' (from above) S'' is conflict-serializable S'' is conflict-equivalent to some serial schedule
===> S "==" Tk ; Serial Schedule ===> S is conflict-serializable
- If
the precedence graph G
of n+1 transactions
has
no cycles
then (⇒)
- The precedence graph G has
no cycles
⇒