L'explication la plus complète et la plus détaillée des transactions MySQL

Qu'est-ce qu'une transaction ?

Quelle est la phrase officielle MySQL pour décrire une transaction ? Les transactions MySQL sont principalement utilisées pour traiter des données avec des opérations volumineuses et une grande complexité. Alors pourquoi la quantité de données est-elle si importante ? Pourquoi la complexité est-elle élevée ? Permettez-moi de le décrire en utilisant ma propre compréhension. La transaction est en fait un moyen de traiter des données dans MySQL. Elle est principalement utilisée lorsque l'intégrité des données est élevée et que la dépendance entre les données est importante. Par exemple, Xiao Zhang a transféré 200 yuans sur la carte bancaire de Xiao Li. Lorsque Xiao Zhang a cliqué sur le bouton pour confirmer le transfert, le système s'est soudainement écrasé. Il y aura plusieurs situations incorrectes comme celle-ci :

1. L'argent de Xiao Zhang a été transféré sur le compte de Xiao Li, mais l'argent sur son propre compte n'a pas été déduit.

2. transféré sur le compte de Xiao Li, mais l'argent sur son propre compte a été déduit

Un tel scénario commercial nécessite une maintenance des transactions MySQL. Même si la machine tombe en panne, les données sont toujours correctes. Conditions d'utilisation des transactions

MySQL Pour utiliser des transactions, la prise en charge du moteur de stockage dans MySQL est requise. Actuellement, les moteurs de stockage intégrés de MySQL qui prennent en charge les transactions incluent InnoDB et le cluster NDB, et les moteurs de stockage tiers incluent PBXT et XtrDB

Quelles sont les caractéristiques des transactions ?

Les transactions dans MySQL ont les caractéristiques suivantes (ACID) :

Atomicité :

Une transaction doit être Comme une unité minimale indivisible de fonctionnent, toutes les opérations de chaque transaction doivent réussir ou échouer. Il n'est jamais possible que certaines opérations échouent et que certaines opérations réussissent. C'est ce qu'on appelle le concept d'atomicité.

Cohérence :

La cohérence est identique à l'exemple ci-dessus. Lorsqu'une exception se produit, les données sont toujours correctes. C'est-à-dire que lorsqu'une transaction ne s'exécute pas, les données ne seront pas affectées par des situations anormales et conserveront toujours leur exactitude

Isolement :

Lors d'un. la transaction n'a pas encore été engagée, chaque transaction est isolée les unes des autres et la complémentarité est affectée.

Durabilité (durabilité) :

Quand Après la soumission d'une transaction, le les modifications seront stockées pour toujours dans la base de données.

Niveau d'isolement de la transaction

Quand on parle des caractéristiques d'isolement de MySQL, nous devons parler d'isolement Plusieurs niveaux de sexe. Quant à la raison pour laquelle cela est impliqué, cela peut être compris simplement comme suit : s'il y a deux requêtes pour effectuer des opérations de transaction en même temps, et que ces deux transactions opèrent sur le même élément de données, alors dont le résultat final est basé sur lequel prévaudra ? Différents niveaux d'isolement conduisent à des résultats différents, donc le niveau d'isolement d'une transaction est également un point très important

Les niveaux d'isolement sont divisés selon les points suivants :

1. (LECTURE UNCOMMITTED)

Les modifications apportées aux données dans une transaction, même si elles ne sont pas validées, sont toujours visibles pour les autres transactions. Dans ce cas, des lectures incorrectes sont susceptibles de se produire, affectant l'intégrité des données

Par exemple : lorsque Xiao Ming a payé avec Alipay, il a vérifié le solde de sa carte bancaire pour 300 yuans. En fait, ce n'était que 100 yuans. C'était simplement parce que sa petite amie déposait 200 yuans sur la carte bancaire. À ce moment-là, la petite amie ne voulait pas économiser, alors elle a cliqué sur l'opération de restauration, mais Xiao Ming n'a pas réussi à payer.

2 LIRE COMMITTED

Une transaction. commence, seules les autres transactions soumises peuvent être vues. Dans ce cas, une lecture non répétable est facile à produire (les résultats des deux lectures sont différents).

Exemple : en reprenant le même exemple ci-dessus, lorsque sa petite amie a glissé la carte, le solde de la carte était de 1 000. 100 yuans, mais après avoir cliqué sur le paiement final, il m'a été demandé que le solde était insuffisant. À ce moment-là, l'argent sur la carte avait disparu. En effet, lorsque la petite amie de Xiao Ming a payé, la transaction opérée par Xiao Ming n'avait pas encore été soumise, donc la petite amie de Xiao Ming a vu des résultats différents à deux reprises.

LECTURE RÉPÉTABLE

<.>Les résultats de la lecture des enregistrements plusieurs fois sont cohérents. La lecture répétable peut résoudre la situation de lecture non répétable ci-dessus. Mais il existe une situation dans laquelle lorsqu'une transaction lit des enregistrements dans une certaine plage, une autre transaction insère une nouvelle donnée dans cette plage. Lorsque la transaction lit à nouveau les données, il s'avère que les données sont plus volumineuses que la première lecture. Il y a un autre enregistrement. C'est ce qu'on appelle la lecture fantôme. Les résultats des deux lectures sont incohérents Par exemple : lorsque la petite amie de Xiao Ming a vérifié les relevés de carte bancaire, elle a vu 5 relevés de consommation. cette fois, Xiao Ming était Consommation, ce record de consommation a été enregistré dans le record de consommation. Lorsque la petite amie a relu le record, elle a découvert qu'il y avait 6 enregistrements.

4. 🎜>

La série est comme une file d'attente. Chaque transaction est mise en file d'attente et en attente d'exécution. Ce n'est qu'après la soumission de la transaction précédente que la transaction suivante peut être effectuée. Bien que cette situation puisse résoudre la lecture fantôme ci-dessus, elle ajoutera un verrou à chaque élément de données, ce qui peut facilement entraîner un grand nombre de délais d'attente de verrouillage et une concurrence de verrouillage. Elle ne convient particulièrement pas à certains scénarios commerciaux à forte concurrence.

Exemple : Nous faisons la queue pour déposer de l'argent à la banque. Ce n'est que lorsque la personne précédente a terminé toutes les opérations que la personne suivante peut procéder. Les personnes du milieu ne sont pas autorisées à sauter dans la file d'attente, elles ne peuvent s'aligner qu'une par une. La sérialisation des transactions est un tel concept. En fait, le soi-disant mode série est un tel concept.

Résumé de l'isolement

A travers les exemples ci-dessus, il ne nous est pas difficile de le découvrir. Les lectures sales et non répétables se concentrent sur la mise à jour des données, et les lectures fantômes se concentrent sur l'insertion de données.

Comment les transactions sont traitées avec plusieurs moteurs de stockage

Selon les conditions utilisées dans les transactions ci-dessus, nous pouvons obtenir On sait que certains moteurs de stockage ne prennent pas en charge les transactions, comme le moteur de stockage MyISAM. Si un moteur de stockage transactionnel et un stockage non transactionnel sont utilisés dans une transaction, la validation peut se dérouler normalement, mais la restauration du moteur de stockage non transactionnel affichera un message d'erreur de réponse. Les informations spécifiques sont liées au moteur de stockage. 🎜>

Comment utiliser les transactions

Les transactions dans MySQL sont implicitement activées, c'est-à-dire qu'une instruction SQL est une transaction Lorsque l'instruction SQL est exécutée, la transaction est. soumis. Pendant la démonstration, nous avons explicitement activé.

Commit automatique dans MySQL

Comme mentionné ci-dessus, les transactions dans MySQL sont activées implicitement, ce qui signifie qu'à chaque fois que nous Un SQL est automatiquement soumis. Si vous devez le désactiver, vous devez définir l'option de validation automatique.

// 查看autocommit配置值（1或者ON则表示开启）
mysql root@127.0.0.1:(none)> show variables like '%autocommit%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit | ON |
+---------------+-------+
1 row in set
Time: 0.018s
// 设置autocommit配置值
mysql root@127.0.0.1:(none)> set autocommit = 0;
Query OK, 0 rows affected
Time: 0.000s
mysql root@127.0.0.1:(none)> show variables like '%autocommit%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit | OFF |
+---------------+-------+
1 row in set
Time: 0.013s

1 La structure de la table est la suivante

mysql root@127.0.0.1:test> desc user;
+-------+--------------+------+-----+---------+----------------+
| Field | Type | Null | Key | Default | Extra |
+-------+--------------+------+-----+---------+----------------+
| id | int(11) | NO | PRI | <null> | auto_increment |
| name | varchar(255) | YES | | <null> | |
| age | int(2) | YES | | <null> | |
+-------+--------------+------+-----+---------+----------------+
3 rows in set
Time: 0.013s

Instruction SQL

CREATE TABLE `test`.`Untitled` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
`age` int(2) NULL DEFAULT NULL,
PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;

.

2. Utiliser des transactions

MySQL implémente des transactions

Dans le code suivant, nous effectuons principalement les opérations suivantes

Ouvrir une transaction<. 🎜>

b. Modifier les données

c. Interrogez à nouveau les données et constatez qu'elles ont été modifiées. est revenu à l'état avant la modification

f . Modifier les données

g. Soumission de la transaction

h. Interrogez les données et constatez que les données ont été modifiées en dernier lieu. état

i. Essayez l'annulation de la transaction

j. Requérez pour vérifier si elle a été annulée, et il s'avère que les données sont toujours dans le dernier état modifié et que l'annulation de la transaction a échoué.

// 我们先查看表中的数据,id为1的age字段是12
mysql root@127.0.0.1:test> select * from user;
+----+------+-----+
| id | name | age |
+----+------+-----+
| 1 | 张三 | 12 |
| 2 | 李四 | 15 |
+----+------+-----+
2 rows in set
Time: 0.013s
// 开启事务
mysql root@127.0.0.1:test> begin;
Query OK, 0 rows affected
Time: 0.001s
// 将id为1的age字段改为10
mysql root@127.0.0.1:test> update user set age=10 where id=1;
Query OK, 1 row affected
Time: 0.001s
// 再次查询数据时,发现数据改为修改后的值
mysql root@127.0.0.1:test> select * from user;
+----+------+-----+
| id | name | age |
+----+------+-----+
| 1 | 张三 | 10 |
| 2 | 李四 | 15 |
+----+------+-----+
2 rows in set
Time: 0.012s
// 此时我们进行回滚操作
mysql root@127.0.0.1:test> rollback;
Query OK, 0 rows affected
Time: 0.001s
// 再次查询发现数据回到最初状态
mysql root@127.0.0.1:test> select * from user;
+----+------+-----+
| id | name | age |
+----+------+-----+
| 1 | 张三 | 12 |
| 2 | 李四 | 15 |
+----+------+-----+
2 rows in set
Time: 0.019s
// 我们再次对数据进行修改
mysql root@127.0.0.1:test> update user set age=15 where id=1;
Query OK, 1 row affected
Time: 0.001s
// 此时将事务进行提交
mysql root@127.0.0.1:test> commit;
Query OK, 0 rows affected
Time: 0.000s
// 发现此时的数据变为我们最终提交的值
mysql root@127.0.0.1:test> select * from user;
+----+------+-----+
| id | name | age |
+----+------+-----+
| 1 | 张三 | 15 |
| 2 | 李四 | 15 |
+----+------+-----+
2 rows in set
Time: 0.012s
// 我们尝试用刚才回滚的方式进行还原数据
mysql root@127.0.0.1:test> rollback;
Query OK, 0 rows affected
Time: 0.000s
// 发现数据无法回退了,仍然是提交后的数据
mysql root@127.0.0.1:test> select * from user;
+----+------+-----+
| id | name | age |
+----+------+-----+
| 1 | 张三 | 15 |
| 2 | 李四 | 15 |
+----+------+-----+
2 rows in set
Time: 0.017s

Code d'exemple d'implémentation de transaction PHP

<?php
// 连接MySQL
$mysqli = new mysqli(&#39;127.0.0.1&#39;, &#39;root&#39;, &#39;123456&#39;, &#39;test&#39;, 3306);
// 关闭事务自动提交
$mysqli->autocommit(false);
// 1.开启事务
$mysqli->begin_transaction();
// 2.修改数据
$mysqli->query("update user set age=10 where id=1");
// 3.查看数据
$mysqli->query("select * from user");
// 4.事务回滚
$mysqli->rollback();
// 5.查看数据
$mysqli->query("select * from user");
// 7.修改数据
$mysqli->query("update user set age=15 where id=1");
// 8.事务提交
$mysqli->commit();
// 9.事务回滚
$mysqli->rollback();
// 10.查看数据
$mysqli->query("select * from user");

Comment définir le niveau d'isolement d'une transaction

// 查看当前的事务隔离级别
mysql root@127.0.0.1:test> select @@tx_isolation;
+-----------------+
| @@tx_isolation |
+-----------------+
| REPEATABLE-READ |
+-----------------+
1 row in set
Time: 0.015s
// 设置隔离级别
set session transaction isolation level 隔离级别(上面事务隔离级别中的英文单词);

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!