Transaction Ensemble d'opérations de modification de données annulées ou validées en bloc. Une Transaction vérifie les caractéristiques suivantes ( ACID ): Atomicité Cohérence Isolation Durabilité Driss HAZZAF

Définitions Atomicité : Toutes les opérations d'une transaction sont exécutées, ou toutes sont annulées. Une exécution de seulement d'un sous ensemble de ces opérations est interdite. Cohérence: Une transaction transforme la base de données d'un état cohérent à un autre. Isolation : Pour garantir une lecture cohérente aux autres transactions, les résultats d'une transaction ne sont visibles par les autres transactions que lorsque celle ci est validée. Durabilité : Une fois la transaction validée, on ne peut pas annuler une transaction validée, et ses données sont conservées même en cas de panne. Driss HAZZAF

Concurrence Une exécution concurrente est une séquence d’exécution avec entrecroisement des opérations de plusieurs transactions. Comment est représentée une exécution concurrente ? Les transactions sont représentées par des indices, les lectures par des « r », et les écritures par des « w ». Par exemple, pour représenter la lecture de la donnée « x » par la transaction « 1 » : r1[x] Exemple d’une exécution concurente : (Histoire) H : r1[x] r2[y] w1[x] r3[y] r2[x] w3[y] r2[z] c1 r3[z] w2[z] c2 w3[z] c3 Driss HAZZAF

Problèmes de concurrence Perte de mise à jour Données non validées Annulation de Transaction Driss HAZZAF

Perte de mise à jour Considérons les transactions T1 et T2 qui modifient le coût du projet WEB ( Le coût initial du projet WEB est 100 ) : L’histoire d’exécution est la suivante : T1 lit le coût du projet WEB ( coût = 100 ) T2 lit le coût du projet WEB ( coût = 100 ) T2 met ce coût à + 10 % => ( coût = 110 ) T1 met ce coût à + 50 % => ( coût = 150 ) Validation T1 Validation T2 A la fin le coût du projet WEB est 150, or ce coût doit être 165. A montrer en lançons deux sql+ et les afficher simultanément : T2 : SQL> select cout from projet 2 where projet_code = 'WEB';   COUT ---------- 100 SQL> update projet set cout = cout*1.1 1 ligne mise à jour. 110 T1 : SQL> update projet set cout = cout*1.5 SQL> commit; Validation effectuée. RESULTAT : SQL> select cout from projet 2 where projet_code = 'WEB'; 165 Driss HAZZAF

Données non validées Considérons les deux mêmes transactions T1 et T2 qui modifient le coût du projet WEB ( Le coût initial du projet WEB est 100 ) : L’histoire d’exécution est la suivante : T1 lit le coût du projet WEB ( coût = 100 ) T1 met ce coût à + 50 % => ( coût = 150 ) T2 lit le coût du projet WEB ( coût = 150 ) T2 met ce coût à + 10 % => ( coût = 165 ) T1 Annulée A la fin le coût du projet WEB est 165, or ce coût doit être 110. Ce scénario est évité dans la base de données car une transaction ne lit que les données validées. Driss HAZZAF

Annulation de Transaction Considérons les transactions T1 et T2. L’histoire d’exécution est la suivante : H = r1[x]w1[x]r2[x]w2[x]c2a1 L’annulation de T1 ( a1 ) impose l’annulation de T2, et ceci après que T2 soit validée ( c2 ). Ce qui est contradictoire avec la règle de durabilité. Driss HAZZAF

Exécution recouvrable Une exécution qui évite l’annulation des transactions validées (Respecte la règle de durabilité ) Exemple : w1[x] r2[x] w2[x] c2 a1 L’annulation de T1 ( a1 ) oblige l’annulation de T2 après que T2 soit validé ( c2 ). Cette exécution n’est pas recouvrable. Par contre l’exécution w1[x] a1r2[x] w2[x] c2 est recouvrable. Driss HAZZAF

Conflit Deux opérations O1 et O2 sont en conflit si elles ne sont pas permutables (l’exécution O1, O2 n’a pas le même effet que O2,O1), et elles appartiennent à deux transactions différentes. Exemple : H : r1[x] r2[y] w1[x] r3[y] r2[x] w3[y] r2[z] c1 r3[z] w2[z] c2 w3[z] c3 Les conflit : sur x : w1[x]-r2[x] sur y : r2[y]-w3[y] sur z : r2[z]-w3[z], r3[z]-w2[z], w2[z]-w3[z] Driss HAZZAF

Graphe de précédence Les précédences sont créées par les séquences d’opérations d’une même donnée. Dans un graphe de précédence : Les nœuds sont les transactions. Si la transaction Tm précède Tn, alors il existe un arc de Tm vers Tn Exemple : Soit l’exécution : H : r1[x] r2[y] w1[x] r3[y] r2[x] w3[y] r2[z] c1 r3[z] w2[z] c2 w3[z] c3 T1 T2 T3 Driss HAZZAF

Sérialisabilité Une exécution en série : Il n’y a aucun entrelacement entre les transactions. Les transactions sont exécutées les unes après les autres. Exécutions équivalentes : Deux exécutions sont équivalentes si : Elles ont les mêmes Transactions et les mêmes opérations. Elles font les mêmes modifications dans la base. Elles ont les mêmes impacts sur les transactions. Exécution sérialisable : est une exécution équivalente à une exécution en série. Important : Si le graphe de précédence d’une exécution contient des cycles, alors l’exécution n’est pas sérialisable. Driss HAZZAF

Exécution stricte Une exécution stricte est une exécution qui évite les annulation en cascade. Exemple : H : r1[x] r2[y] w1[x] r3[y] r2[x] w3[y] r2[z] c1 r3[z] w2[z] c2 w3[z] c3 r2[x] se fait après w1[x] et avant c1, donc H n’évite pas les annulations en cascade. H n’est pas stricte. Driss HAZZAF

Verrouillage à deux phases Le verrouillage à deux phases est une technique de verrouillage des objets par une transaction, et à relâcher les verrous après avoir obtenu tous ce dont elle a besoin. Une transaction passe par deux phases : Acquérir les verrous Relâcher les verrous Au niveau des SGBD les verrous sont relâchés à la fin de la transaction ( Lors de la validation ou l’annulation de la transaction ). Driss HAZZAF

Verrouillage à deux phases (exemple) H: r1[x] r2[y] r3[x] r1[z] r1[u] w3[x] r1[y] r3[u] w2[y] c2 c1 w3[u] c3 r1[x], r2[y] s’exécutent, en prenant les verrous de lecture r3[x] partage le verrou de lecture sur x avec r1[x] et s’exécute r1[z], r1[u] s’exécutent, en prenant les verrous de lecture w3[x] bloquée par r1[x], donc T3 bloquée r1[y] partage le verrou de lecture sur y avec r2[y] et s’exécute r3[u] bloquée, car T3 bloquée w2[y] bloquée par r1[y], donc T2 bloquée c2 bloquée car T2 bloquée c1 s’exécute et relâche les verrous de T1 w3[x] s’exécuter, r3[u] s’exécute. W2[y] s’exécuter C2 s’exécute et relâche les verrou de T2 W3[u] et c3 s’exécutent Le résultat final est donc H’ : r1[x] r2[y] r3[x] r1[z] r1[u] r1[y] c1 w3[x] r3[u] w2[y] c2 w3[u] c3 Driss HAZZAF

Exercice Considérons l’exécution concurrente de trois transactions suivante : H : r1 [x] r2 [y] w1 [y]r3[y]w1 [z]w2 [y]c1w3[z]c3c2   1. Vérifiez si H est sérialisable en identifiant les conflits et en construisant le graphe de sérialisation. 2. L’exécution H est-elle stricte? Justifiez votre réponse. 3. Quelle est l’exécution obtenue par verrouillage à deux phases à partir de H? On considère que le relâchement des verrous d’une transaction se fait au Commit et qu’à ce moment on exécute en priorité les opérations bloquées en attente de verrou, dans l’ordre de leur blocage. 1. Les conflits sur x : aucun Les conflits sur y : r2[y]-w1[y], w1[y]-r3[y], w1[y]-w2[y], r3[y]-w2[y]. Les conflits sur z : w1[z]-w3[z]. Le graphe de sérialisation contient les arcs T2 -> T1 , T1-> T3, T1 -> T2, T3 - > T2 . Il y a des cycles, donc H n’est pas sérialisable. 2. Après w1[y], on a r3[y] avant la fin de T1 , donc H n’évite pas les annulations en cascade, donc elle n’est pas stricte. 3. r1[x], r2[y] s’exécutent w1[y] est bloquée en attente de verrou sur y r3[y] s’exécute en partageant le verrou de lecture avec r2[y] w1[z] est bloquée, car T1 est bloquée w2[y] est bloquée à cause de r3[y] c1 est bloquée, car T1 est bloquée w3[z] s’exécute C3 s’exécute et relâche les verrous de T3 w2[y] s’exécute c2 s’exécute et relâche les verrous de T2 w1[y], w1[z] et c1 s’exécutent. Résultat: r1[x] r2[y] r3[y] w3[z] c3 w2[y] c2 w1[y] w1[z] c1 Driss HAZZAF

Solution 1. Les conflits sur x : aucun Les conflits sur y : r2[y]-w1[y], w1[y]-r3[y], w1[y]- w2[y], r3[y]-w2[y]. Les conflits sur z : w1[z]-w3[z]. Le graphe de sérialisation contient les arcs T2 -> T1 , T1-> T3, T1 -> T2, T3 - > T2 . Il y a des cycles, donc H n’est pas sérialisable. 2. Après w1[y], on a r3[y] avant la fin de T1 , donc H n’évite pas les annulations en cascade, donc elle n’est pas stricte. Driss HAZZAF

Solution (suite) 3. l’exécution obtenue par verrouillage à deux phases : r1[x], r2[y] s’exécutent w1[y] est bloquée en attente de verrou sur y r3[y] s’exécute en partageant le verrou de lecture avec r2[y] w1[z] est bloquée, car T1 est bloquée w2[y] est bloquée à cause de r3[y] c1 est bloquée, car T1 est bloquée w3[z] s’exécute C3 s’exécute et relâche les verrous de T3 w2[y] s’exécute c2 s’exécute et relâche les verrous de T2 w1[y], w1[z] et c1 s’exécutent. Résultat: r1[x] r2[y] r3[y] w3[z] c3 w2[y] c2 w1[y] w1[z] c1 Driss HAZZAF