Base de données – TD

1. Soit une base de données contenant la table val dont la définition est: (a int, b int).
La table contient un unique tuple (1,2). Nous considérons qu'il y a 2 clients C1 et
C2. C1 lance les séquences d'ordres suivantes avec le mode de confirmation
automatique non activé. Le client C2 est également connecté. Nous nous
intéressons à la vue de chaque client. Remplir les tableaux suivants et vérifier par
la suite sur les postes avec postgresql.

1.a
Ordre de C1 Val vue par C1 Val vue par C2
begin transaction;
insert into val values(3,4)
insert into val values (1,2)
rollback;

1.b
Ordre de C1 Val vue par C1 Val vue par C2
begin transaction;
insert into val values(3,4)
commit;
1.c

Ordre de C1 Val vue par C1 Valu vur par C2

begin transaction;
update val set b=1 where
a=1;
alter table val add column c
int;
commit;
1.d Maintenant des ordres de C1 et C2 en repartant de l'état avant 1.a (1 tuple
(1,2)) donc sans la colonne c.
Ordres C1 Ordres C2 Val pour C1 Val pour C2
begin transaction;
Insert into val begin transaction;
values(5,6);
Insert into val
values(7,8);
commit;
rollback;
1.e
Ordres C1 Ordres C2 Vla pour C1 Val pour C2
begin transaction;
Insert into val
values(8,9);
Update val set b=0
where a=8;
commit;

2. Soit T1 et T2 les transactions suivantes:

Transaction T1 Transaction T2
Read (a) Read (a)
a:=a+100; a:=a*2;
write(a); write(a);
read(b) read(b)
b:=b+100; b:=b*2;
write(b); write(b);

2.a) Si la valeur initiale de a est 25 et celle de b est 25, quelles sont leurs valeurs de a et
b si on exécute les transactions à la suite, T1 puis T2.
2.b) Quelles sont les valeurs si on exécute T2 puis T1?
2.c) maintenant les deux transactions sont exécutées de façon concurrente de la façon
suivante:

Transaction T1 Transaction T2
Read (a)
a:=a+100;
write(a);
Read (a)
a:=a*2;
write(a);
read(b)
b:=b+100;
write(b);
read(b)
b:=b*2;
write(b);

Si on considère les mêmes valeurs initiales qu'en a) quelles sont les valeurs de a et b à
l'issue de l'exécution des transactions? Cette exécution entremêlée est elle correcte,
pourquoi?

2.d) Si les deux transactions sont exécutées de façon concurrente de la façon suivante:
 Transaction T1 Transaction T2
Read (a)
a:=a+100;
write(a);
Read (a)
a:=a*2;
write(a);
read(b)
b:=b*2;
write(b);
read(b)
b:=b+100;
write(b);

Si on considère les mêmes valeurs initiales qu'en a) quelles sont les valeurs de a et b à
l'issue de l'exécution des transactions?

3.
Notre système utilise le protocole de verrous exclusifs avec libération explicite.
Supposons l'exécution suivante
des transactions T1 et T2:
Transaction T1 Transaction T2
t1 XRead (a)
t2 a:=a+100; XRead (a)
t3 mise en attente
t4 write(a);
t5
t6 XRelease (a) a:=a*2;
t7 write(a);
t8 XRelease (a)
t9
t10 Xread(b)
t11 b:=b+100; Xread(b)
t12 mise en attente
t13 write(b);
t14
t15 XRelease (b) b:=b*2;
t16 write(b);
t17 XRelease (b)

Cette exécution se passe t'elle correctement? Quels sont les problèmes possibles en cas
d'échec de T1?

4. Soit les deux transactions T1 et T2.

Pouvez vous proposer une exécution concurrente pour ces deux transactions?
Justifiez votre réponse.
T1: Xread(a)
 a:=a+2; Xread(b)
Write(a); b:=b*2;
Xread(b); Write(b);
b:=b*3; Xread(a);
Write(b) a:=a+3;
XRelease(a) Write(a)
XRelease(b); Xrelease(a)
T2: Xrelease(b);
5. Soient les transactions suivantes; on admet que les transactions avec numérotation
impaire obéissent au protocole PSX (S pour Shared) et les transactions avec numérotation
paire obéissent au protocole PX (X pour eXclusif) . Aucun verrou n'est libéré avant la fin
de transaction.
temps t0 ........................................
temps t1 T1 : read(A)
temps t2 T2 : read(B)
temps t3 T1 : read(C)
temps t4 T3 : read(D)
temps t5 T4 : read(B)
temps t6 T5 : read(A)
temps t7 T2 : read(E)
temps t8 T2 : upd (E)
temps t9 T3 : read(F)
temps t10 T2 : read(F)
temps t11 T5 : read(A)
temps t12 T5 : upd (A)
temps t13 T1 : commit
temps t14 T6 : read(A)
temps t15 T5 : rollback
temps t16 T6 : read(C)
temps t17 T6 : upd (C)
temps t18 T7 : read(G)
temps t19 T8 : read(H)
temps t20 T9 : read(G)
temps t21 T9 : upd (G)
temps t22 T8 : read(E)
temps t23 T7 : commit
temps t24 T9 : read(H)
temps t25 T3 : read(G)
temps t26 T10 : read(A)
temps t27 T6 : read(C)
temps t28 T6 : commit
temps t29 T12 : read(A)
temps t30 T13 : read(A)
temps t31 ................................
Dessiner le diagramme qui montre l'état du graphe des attentes au temps t31. Y a-t-il
des verrous mortels? Pour chaque instruction Read, indiquer s'il s'agit d'une Sread ou
Xread. De même pour les Update, indiquer s'il s'agit d'un Xupdate ou d'un Update.
Exemple:
Temps T1 T2 T3..
t1 read(A)
t2
t3..