1 Introduction au contrôle de concurrence

Oracle gère des verrous pour contrôler les processus concurrents, au niveau des tables ou des n-uplets. Certains sont posés implicitement (sur les n-uplets lors des mises à jour d'instance), d'autres explicitement (sur les tables). Il n'est pas possible que deux processus possèdent des verrous globaux sur la meme table ou locaux sur le meme n-uplet. Les verrous sont relâchés en fin de transaction.

On s'initie ci-dessous à intuiter le déroulement des ordres posant des verrous, puis à en poser nous-même là où il faut.

1.1 Analyse de programme

On considère une table T(A,B : integer) contenant au début les n-uplets (1,1) et (2,2). Tout ordre dessus est autorisé à tout utilisateur. On considère deux processus clients p₁ et p₂ qui effectuent les séquences d'ordres suivantes, immédiatement après leur connexion. Un autre client quelconque est représenté par p₃. Remplir les tableaux dans l'ordre dans lequel les ordres sont effectivement exécutés. Puis vérifiez sur machine.

```
1 (p1) : delete t where b=1
2 (p1) : commit
```
client ordre T ds trans p₁ T ds trans p₂ T vue par p₃

11 11 11

22 22 22

1 (p1) : delete t where b=1
2 (p2) : update t set b=b-1
3 (p1) : commit
4 (p2) : commit

client	ordre	`T` ds trans p₁	`T` ds trans p₂	`T` vue par p₃
		`11`	`11`	`11`
		`22`	`22`	`22`

1 (p2) : update t set b=b-1
2 (p1) : delete t where b=1
3 (p2) : commit
4 (p1) : commit

client	ordre	`T` ds trans p₁	`T` ds trans p₂	`T` vue par p₃
		`11`	`11`	`11`
		`22`	`22`	`22`

1 (p1) : update t set a = 1 where b = 2
2 (p2) : delete t where a = 1
3 (p1) : commit
4 (p2) : commit

client	ordre	`T` ds trans p₁	`T` ds trans p₂	`T` vue par p₃
		`22`	`22`	`22`

1.2 Demandes de verrous mutuellement bloquantes

Dans chacune des questions suivantes, la table T(A integer, B integer) contient au départ les n-uplets 1 1 et 2 2.

Conclusions ?

Un processus client p₁ exécute, sur la table T, la séquence d'ordres SQL suivante :
insert 1 1; delete 1 1; commit;
Décrire après chacun de ces ordres ce que voit :
- p₁
- tout autre processus différent de p₁
On considère les séquences d'ordres SQL suivantes :
```
s1:                                s2:
update T set A=A+1;                update T set A=A+1;
commit;                            commit;

s3:                                s4:
update T set A=A+1;               delete T where (A=2);
commit;                           commit;
```
Détailler les problèmes pouvant survenir lors de l'exécution concurrente des séquences s1 et s2 par deux utilisateurs différents. De même pour l'exécution concurrente des séquences s3 et s4. Expliquer comment Oracle gère les problèmes liés à ces accès concurrents.
On considère maintenant les deux séquences d'ordres SQL+ suivantes :
```
s5:                                s6:
update T set A=A+1 where (A=1);    update T set A=A+1 where (A=2);
update T set A=A+1 where (A=2);    update T set A=A+1 where (A=1);
commit;                            commit;
```
Détailler les problèmes liés à l'exécution concurrente des squences s5 et s6 par des utilisateurs différents. Quelles sont les solutions que propose Oracle pour gérer ce type de problème.

1.3 Construction de programme

On considère la situation classique dans laquelle deux agences de voyages accèdent concurremment à une table Reservation à deux colonnes Nom et Num_place. Il y a 100 n-uplets, un par place, de numéros 1 à 100. Le nom correspondant est indéfini jusqu'à ce qu'une réservation ait lieu.

Testez tous les exercices ci-dessous sur machine.

Ecrivez un premier programme naïf (sans verrous explicites) qui regarde s'il y a une place libre, la place dans une variable locale, puis met à jour le n-uplet correspondant.
Montrez que votre programme n'est pas robuste à la concurrence, en en déroulant deux exemplaires d'une manière qui réserve deux fois la même place.
Posez un ou des verrous sur un seul de ces deux programmes (par exemple il se dit qu'il va se protéger en gérant des verrous). Montrez que votre programme n'est toujours pas robuste à la concurrence, par un exemple analogue à celui ci-dessus... Le contrôle de concurrence est donc une affaire à gérer à plusieurs !
Réglez enfin le problème...