ENI RV
Transactions dans un SGBD relationnel
1. Introduction
Une transaction est un ensemble d'actions
atomiques permettant de prendre une base
donnée dans un état cohérent et de la rendre
dans un état cohérent. Il s'agit d'éviter par
exemple que l'on puisse lire une information que
l'on est en train de modifier par ailleurs ou de
mettre à jour, ou même que deux utilisateurs
mettent à jour simultanément la même
information.
Par exemple : une transaction bancaire de
transfert d'une somme S d'un compte C1 à un
autre compte C2 ( on enlève sur un compte, on
dépose sur l'autre.)
(1) Début transaction
(2) Lire (C1) // lire le compte C1
(3) C1=C1-S // débiter le solde de C1
(4) Ecrire (C1)
(5) Lire (C2) // lire le compte C2
(6) C2=C2+S // créditer C2
(7) Ecrire (C2)
(8) Fin-Transaction
En supposant qu'avant l'exécution d'une telle
transaction la base était dans un état cohérent. ,
on remarque que l'exécution incomplète de cette
transaction peut mettre la base dans un état
incohérent , c'est à dire lorsqu' une des deux
opérations échoue. Par exemple , si l'exécution
s'arrête après l'action (4) , le premier compte a
bien débité mais le second n'a pas encore crédité.
On veut que soit les deux opérations réussissent,
mais si une d'elles échoue, on annule le tout et on
remet les comptes dans l'état initial .On dit que les
deux opérations forment une seule et même
transaction .
Un des avantages de la transaction est que si une
transaction s'exécute toute seule, dans une base
de données cohérente, alors elle va laisser la
base de données dans un état cohérent
La transaction peut être utilisée pour résoudre le
problème de partage concurrent de données :
plusieurs clients consultent et modifient les
mêmes données et s'accorde avec les pannes
machines ou réseau.
La transaction vérifie les propriétés ACID
(atomicité , cohérence , isolation et durabilité):
Atomicité : une transaction doit effectuer ses
mises à jour ou ne rien faire du tout. En cas
d'échec , une transaction doit annuler toutes les
modifications qu'elle a engagées.
1
Cohérence : la transaction doit faire passer la
base de données d'un état cohérent à un autre
état. En cas d'échec , l'état courant cohérent initial
doit être restauré.
Isolation : les résultats d'une transaction ne
doivent être visibles aux autres transactions
qu'une fois la transaction validée , ceci afin
d'éviter les interférences avec les autres
transactions .
Durabilité : dès qu'une transaction valide ses
modifications , le système doit garantir que ces
modifications seront conservées en cas de panne.
2.Mise en œuvre d'une transaction dans
MySQL par
BEGIN/COMMIT/ROLLBACK
Par défaut, MySQL est lancé en mode
autocommit . Cela signifie que chaque
modification effectué est enregistré
immédiatement sur le disque par MySQL.
Si vous utilisez des tables supportant les
transactions (comme InnoDB ), vous pouvez
configurer MySQL en mode non- autocommit
grâce à la commande: SET AUTOCOMMIT=0
A partir de là, vous devez utiliser COMMIT pour
enregistrer les modifications sur le disque ou
ROLLBACK pour ignorer les modifications
apportées depuis le début de la transaction ( pour
ramèner la base à l'état initial) .Si vous souhaitez
sortir du mode AUTOCOMMIT pour une série
d'opérations, vous pouvez utiliser les commandes
BEGIN ou BEGIN WORK :
BEGIN;
SELECT @A:=SUM(salary) FROM table1 WHERE
type=1;
UPDATE table2 SET summmary=@A WHERE
type=1;
// autres commandes de mise à jour
COMMIT ou ROLLBACK;
Ainsi, chaque transaction se termine par un
COMMIT si la transaction a réussi, ou par un
ROLLBACK qui la ramène à l'état initial si la
transaction échoue pour une raison ou pour une
autre
Mysql exige que les tables soient
transactionnelles de type InnoDB, par exemple
CREATE TABLE Client( Nom CHAR(10),
Adresse CHAR(40)) TYPE = INNODB
Avec PostgreSQL™, une transaction est réalisée
en entourant les commandes SQL de la
ENI RV
transaction avec les commandes BEGIN et
COMMIT. Donc, notre transaction pour la banque
ressemblera à ceci
BEGIN;
UPDATE comptes SET balance = balance -
100.00 WHERE nom = 'Alice';
-- etc etc
COMMIT;
Si, au cours de la transaction, nous décidons que
nous ne voulons pas valider (peut-être nous
sommes-nous aperçus que la balance d'Alice
devenait négative), nous pouvons envoyer la
commande ROLLBACK au lieu de COMMIT, et
toutes nos mises à jour jusqu'à maintenant seront
annulées.
3. Verrouillage en deux phases(Two Phase
Locking)
Le verrouillage en deux phases est une technique
de prévention des conflits ( concurrences) basée
sur le verrouillage des objets en lecture ou
écriture avant d'effectuer une opération de
sélection ou de mise à jour. C'est alors une
technique de contrôle des accès concurrents
consistant à verrouiller les objets au fur à mesure
des accès par une transaction (phase
d'acquisition de verrous: LOCK ) et à relâcher les
verrous seulement après obtention de tous les
verrous (phase de relâchement : UNLOCK).
Sous Mysql , par exemple , il est possible de
verrouiller les tables dont vous aurez
besoin pour que les autres threads ne
pourront pas intervenir sur ces tables
durant vos opérations, ni en extraire des
informations si la table est en WRITE –
locked si vous allez exécuter plusieurs
requêtes sur plusieurs tables par les
commandes LOCK TABLES/UNLOCK
TABLES.
Ces commandes peuvent être utilisées pour
verrouiller un type de table dans MySQL qui ne
supporte pas les transactions, et pour vous
assurez qu'aucun autre thread ne s'intercale entre
un SELECT et un UPDATE .
Syntaxe de LOCK TABLES/UNLOCK TABLES
LOCK TABLES nom_de_table [AS alias] {READ |
WRITE}
[, nom_de_table [AS alias] {READ | WRITE} ...]
2
...
UNLOCK TABLES
LOCK TABLES verrouille une table pour le thread
courant. UNLOCK TABLES déverrouillera
automatiquement tous les verrous posés par le
thread courant.
L'exemple suivant necessite LOCK TABLES pour
s'executer en toute sécurité :
mysql> LOCK TABLES trans READ, customer
WRITE;
mysql> SELECT SUM(value) FROM trans WHERE
customer_id=some_id;
mysql> UPDATE customer SET
total_value=sum_from_previous_statement
-> WHERE customer_id=some_id;
mysql> UNLOCK TABLES;
Sans LOCK TABLES , Il est possible qu'un autre
thread ait inseré une nouvelle ligne dans la table
trans entre l'execution du SELECT et l'exécution
de la requête UPDATE .
4. Mise en œuvre d'une transaction dans une
application
Une transaction est un ensemble d'instructions
devant s'exécuter d'un seul bloc. C'est à dire que
les instructions sont soit toutes exécutées, soit
toutes annulées. Si une seule instruction du bloc
échoue la transaction ne prends pas effet.
Par défaut, les Connection sont en mode auto-
commit. C'est à dire que chaque instruction SQL
est considérée comme une transaction. Vous
pouvez changer ce comportement en utilisant la
méthode setAutoCommit(boolean).
Dans le cas ou l'auto-commit est desactivé, vous
devrez appeller la méthode commit pour
effectivement valider la transaction. Pour annuler
une transaction vous devez utiliser la méthode
rollback. Cette méthode à pour effet d'annuler
toutes les modifications faites par la transaction
courrante et de supprimmer les verrous en place.
a) Exemple d'une transaction en JAVA via
JDBC:
Si une erreur survient, une exception de type
SQLException est déclenchée. Dans ce cas, le
bloc catch annule la transaction. Sinon, elle est
confirmée. Dans tous les cas de figure (bloc
finally) on ferme la connexion à la base de
données.
ENI RV

Connection connection = null;

try{ Dim cnn1 As ADODB.Connection
connection = ...; Dim rstTitles As ADODB.Recordset
connection.setAutoCommit(false); Dim strCnn As String
//traitement des différentes instructions Dim strTitle As String
composant la transaction Dim strMessage As String
if(jeVeuxValider){
connection.commit();// c'est ici que l'on valide
la transaction ' Ouvrir la connexion.
connection.setAutoCommit(true); strCnn = "Provider=sqloledb;" & _
}else{ "Data Source=srv;Initial Catalog=Pubs;User
connection.rollback(); Id=sa;Password=; "
} Set cnn1 = New ADODB.Connection
} cnn1.Open strCnn
catch(SQLException sqle){
try{connection.rollback();} catch(Exception e){} ' Ouvrir la table Titles.
} Set rstTitles = New ADODB.Recordset
catch(Exception e){ rstTitles.CursorType = adOpenDynamic
try{connection.rollback();} catch(Exception e){} rstTitles.LockType = adLockPessimistic
} rstTitles.Open "titles", cnn1, , , adCmdTable
finally{
try{connection.close();} catch(Exception e){}
rstTitles.MoveFirst
}
cnn1.BeginTrans
b) Exemple de transaction en VB
' Parcourir le jeu d'enregistrements et
Méthodes BeginTrans, CommitTrans et demander à l'utilisateur s'il souhaite 'modifier le
RollbackTrans type d'un titre spécifié.

Ces méthodes gèrent le traitement des Do Until rstTitles.EOF

transactions dans un objet Connection, de la If Trim(rstTitles!Type) = "psychology" Then
manière suivante : strTitle = rstTitles!Title
• BeginTrans : lance une nouvelle strMessage = "Title: " & strTitle & vbCr & _
transaction. "Change type to self help?"
• CommitTrans : enregistre les
modifications et met fin à la transaction. ' Modifier le titre de l'employé spécifié.
Elle peut aussi commencer une nouvelle If MsgBox(strMessage, vbYesNo) = vbYes
transaction. Then
• RollbackTrans : annule les modifications
rstTitles!Type = "self_help"
effectuées lors de la transaction en cours rstTitles.Update
et met fin à cette dernière. Elle peut aussi End If
commencer une nouvelle transaction. End If
Exemple de méthodes BeginTrans,
CommitTrans et RollbackTrans (VB) rstTitles.MoveNext
Loop
Cet exemple change le titre de tous les livres de
psychologie figurant dans la table Titles de la
base de données. Une fois que la méthode
' Demander à l'utilisateur s'il veut valider toutes
BeginTrans a lancé une transaction qui identifie
les
toutes les modifications effectuées dans la table
' modifications apportées ci-dessus.
Titles, la méthode CommitTrans enregistre les
If MsgBox("Save all changes?", vbYesNo) =
modifications. Vous pouvez utiliser la méthode
vbYes Then
Rollback pour annuler les modifications que vous
cnn1.CommitTrans
avez enregistrées à l'aide de la méthode Update.
Else
cnn1.RollbackTrans
Public Sub BeginTransX()
3
ENI RV

End If myTrans.Rollback()
Response.Write(ep.ToString())
' Imprimer les données en cours dans le jeu Response.Write( "Neither record was written to
d'enregistrements. database." )
rstTitles.Requery Finally
rstTitles.MoveFirst myConnection.Close()
Do While Not rstTitles.EOF End Try
Debug.Print rstTitles!Title & " - " & rstTitles!
Type d)TRANSACTION EN PDO
rstTitles.MoveNext
Loop <?php
$dsn = 'mysql:dbname=testdb;host=127.0.0.1;
port=3306’’; 'dbuser'; 'dbpass';
' Restaurer les données originales, car il s'agit try {
d'une $dbh = new PDO($dsn, $user, $password);
' démonstration. $dbh->beginTransaction();
rstTitles.MoveFirst $dbh->exec("insert into staff
Do Until rstTitles.EOF (id, first, last) values (23, 'Joe', 'Bloggs')");
If Trim(rstTitles!Type) = "self_help" Then $dbh->exec("insert into salarychange
rstTitles!Type = "psychology" (id, amount, changedate)
rstTitles.Update values (23, 50000, NOW())");
End If $dbh->commit();
rstTitles.MoveNext
Loop }
catch (Exception $e)
rstTitles.Close { die('Erreur : ' . $e->getMessage());
cnn1.Close $dbh->rollBack();

End Sub }
catch (PDOException $e) {
c) Faire transaction Transact-SQL en utilisant echo 'Connexion échouée : ' . $e->getMessage();
DB SQL Server ASP.NET 2.0 et VB.NET }
?>
Tout d'abord, importer l'espace de noms
System.Data.SqlClient

Dim myConnection As New SqlConnection( "Data

Source=localhost;Initial
Catalog=Northwind;uid=sa;pwd=sa;" )
myConnection.Open()

Dim myTrans=myConnection.BeginTransaction()
Dim myCommand As New SqlCommand()
myCommand.Connection = myConnection
myCommand.Transaction = myTrans
Try
myCommand.CommandText = "Insert into Region
(RegionID, RegionDescription) VALUES (100,
'Description')"
myCommand.ExecuteNonQuery()
myCommand.CommandText = "delete * from
Region where RegionID=101"
myCommand.ExecuteNonQuery()
myTrans.Commit()
Response.Write( "Both records are written to
database." )
Catch ep As Exception
4