Transação é a menor unidade de uma operação lógica. Especificamente, ela se refere a um conjunto de instruções sql no banco de dados. Este conjunto de sql deve ser executado com sucesso antes que os dados da operação possam ser confirmados. ele deve ser revertido e todas as operações sql perdem seu efeito.
No MySQL, a instrução SQL da operação é enviada automaticamente por padrão, e os métodos begin e start transaction também são fornecidos para iniciar a transação para realizar o commit manual (commit). Somente as operações que não são confirmadas podem ser revertidas (rollback) . A seguir, vamos apresentar seus "poços" de uso e operação específicos aos quais precisamos prestar atenção.
1. O parâmetro
autocommit autocommit determina se os resultados podem ser enviados diretamente após a execução de um dado no MySQL. O padrão no MySQL é 1, o que significa que o envio automático está ativado. Quando seu valor é definido como 0, ele não será enviado automaticamente. Depois de executar o SQL, você pode enviar manualmente ou optar por reverter.
(1) Visualize o valor de autocommit, entre no banco de dados MySQL e use
SELECT @@autocommit；
Para ver o valor de @autocommit relacionado
mysql> select @@autocommit;
+--------------+
| @@autocommit |
+--------------+
| 1 |
+--------------+
1 row in set (0.00 sec)
Como você pode ver aqui, o valor = 1, o que significa que o auto-commit está ativado por padrão, mas para implementar as transações, precisamos desligar o auto-commit.
(2) Defina o valor de autocommit para desligar o envio automático. usar
set autocommit=0;
Defina seu valor como 0 para desligar o envio automático.
mysql> set autocommit=0;
Query OK, 0 rows affected (0.00 sec)
mysql> select @@autocommit;
+--------------+
| @@autocommit |
+--------------+
| 0 |
+--------------+
1 row in set (0.00 sec)
Desta forma, após executarmos a instrução sql, precisamos submetê-la manualmente, caso contrário o resultado não será modificado.
(3) O efeito de confirmação e reversão
+-------+------+-------+
| name | age | id |
+-------+------+-------+
| curry | 15 | 10001 |
+-------+------+-------+
Esta é uma tabela de usuário com campos de nome, idade e id. Primeiro adicione um dado a esta tabela
mysql> insert into user values('tom',10,2);
Query OK, 1 row affected (0.01 sec)
Aqui vemos que ele foi adicionado com sucesso, mas os dados estão realmente salvos? selecione e dê uma olhada
mysql> select * from user;
+-------+------+-------+
| name | age | id |
+-------+------+-------+
| tom | 10 | 2 |
| curry | 15 | 10001 |
+-------+------+-------+
3 rows in set (0.00 sec)
Descobri que está mesmo na tabela, mas não há envio aqui. O que acontece se eu reverter?
mysql> rollback;
Query OK, 0 rows affected (0.01 sec)
mysql> select * from user;
+-------+------+-------+
| name | age | id |
+-------+------+-------+
| curry | 15 | 10001 |
+-------+------+-------+
2 rows in set (0.00 sec)
As informações do tom se foram. Esta é uma maneira de desligar a confirmação automática definindo autocommit = 0 e, em seguida, implementar as transações por meio de rollback. Mas há um problema, ou seja, após definir este parâmetro, todo o banco de dados precisa ser enviado manualmente ao enviar operações, o que é muito problemático. O MySQL fornece intimamente os métodos de transação inicial e inicial, que realmente realizam a operação de um conjunto de dados e a reversão manual do relatório de erro!
Dois, comece
antes de querer escrever a instrução sql, use-a primeiro
mysql> begin;
Query OK, 0 rows affected (0.01 sec)
mysql> insert into user values('tom',10,2);
Query OK, 1 row affected (0.01 sec)
mysql> select * from user;
+-------+------+-------+
| name | age | id |
+-------+------+-------+
| tom | 10 | 2 |
| curry | 15 | 10001 |
+-------+------+-------+
3 rows in set (0.00 sec)
Inserido, ele pode ser revertido usando rollback?
mysql> rollback;
Query OK, 0 rows affected (0.01 sec)
mysql> select * from user;
+-------+------+-------+
| name | age | id |
+-------+------+-------+
| curry | 15 | 10001 |
+-------+------+-------+
Para uma reversão bem-sucedida, o seguinte método de transação inicial é igual a esta etapa de uso.
Três, iniciar a transação
está aqui, não reverteremos diretamente, depois de terminarmos de operar o sql, enviaremos manualmente e, em seguida, reverteremos para ver o efeito!
Preferido para usar o início da transação
mysql> start transaction;
Query OK, 0 rows affected (0.00 sec)
Inserir dados
mysql> insert into user values('tom',10,2);
Query OK, 1 row affected (0.00 sec)
mysql> select * from user;
+-------+------+-------+
| name | age | id |
+-------+------+-------+
| tom | 10 | 2 |
| curry | 15 | 10001 |
+-------+------+-------+
3 rows in set (0.00 sec)
Submissão manual
mysql> commit;
Query OK, 0 rows affected (0.01 sec)
Em seguida, role para trás e veja os resultados
mysql> rollback;
Query OK, 0 rows affected (0.00 sec)
mysql> select * from user;
+-------+------+-------+
| name | age | id |
+-------+------+-------+
| tom | 10 | 2 |
| curry | 15 | 10001 |
+-------+------+-------+
3 rows in set (0.00 sec)
Pode-se ver que, uma vez enviado, não pode ser revertido. Antes de enviar, você pode usar a operação de rollback para retirar sem reter o efeito sql! A próxima seção apresenta as quatro principais características das transações em detalhes, o nível de isolamento das transações e os problemas que podem surgir.
Próxima seção: características de transação e problemas de nível de isolamento de transação no banco de dados MySQL