> ## Documentation Index
> Fetch the complete documentation index at: https://villagesql.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# COMMIT e ROLLBACK no MySQL

> Como START TRANSACTION, COMMIT e ROLLBACK fazem várias instruções do MySQL terem sucesso ou falharem juntas, e as instruções que confirmam o seu trabalho sem perguntar.

> [card] [VillageSQL is a drop-in replacement for MySQL with extensions.](https://villagesql.com/docs/en/8.4/stable/install-server.md)
>
> All examples on this page work on VillageSQL. Install Now →

Mover dinheiro entre 2 contas leva 2 instruções, e uma falha entre elas
deixa o dinheiro em lugar nenhum. Uma transação agrupa instruções para que ou todas
elas contem ou nenhuma conte.

Estes exemplos usam o banco de dados `sakila_practice` da lição sobre
[INSERT](https://villagesql.com/docs/pt-BR/tutorial/insert.md). Execute o bloco de configuração de lá novamente antes de começar,
depois abra o cliente com `mysql -u root -p sakila_practice`.

## Como uma transação funciona

```sql theme={null}
START TRANSACTION;
FIRST_STATEMENT;
SECOND_STATEMENT;
COMMIT;
```

Substitua `FIRST_STATEMENT` e `SECOND_STATEMENT` pelas instruções que precisam
ter sucesso juntas.

`COMMIT` torna o trabalho permanente e visível para todos os outros. `ROLLBACK`
o descarta e devolve as linhas ao estado em que estavam. Até que você digite um dos 2,
as mudanças são só suas: outra sessão ainda vê os valores antigos.

Toda instrução fora de uma transação é confirmada por conta própria, porque `autocommit`
está ligado.

```sql theme={null}
SELECT @@autocommit AS autocommit;
```

```text theme={null}
+------------+
| autocommit |
+------------+
|          1 |
+------------+
1 row in set (0.00 sec)
```

É por isso que as lições anteriores não precisaram de `COMMIT`: cada `INSERT` e `UPDATE`
foi uma transação de 1 instrução. `START TRANSACTION` suspende isso até que você
termine.

## Exemplos

### Desfaça o trabalho com ROLLBACK

```sql theme={null}
SELECT * FROM account;
```

```text theme={null}
+------------+------------------+---------+
| account_id | owner            | balance |
+------------+------------------+---------+
|          1 | Mary Smith       |  500.00 |
|          2 | Patricia Johnson |  250.00 |
+------------+------------------+---------+
2 rows in set (0.00 sec)
```

Mova 100 de Mary para Patricia, olhe o resultado, depois mude de ideia.

```sql theme={null}
START TRANSACTION;
UPDATE account SET balance = balance - 100 WHERE account_id = 1;
UPDATE account SET balance = balance + 100 WHERE account_id = 2;
SELECT * FROM account;
ROLLBACK;
```

```text theme={null}
Query OK, 0 rows affected (0.00 sec)

Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

+------------+------------------+---------+
| account_id | owner            | balance |
+------------+------------------+---------+
|          1 | Mary Smith       |  400.00 |
|          2 | Patricia Johnson |  350.00 |
+------------+------------------+---------+
2 rows in set (0.00 sec)

Query OK, 0 rows affected (0.00 sec)
```

O `SELECT` dentro da transação mostra 400 e 350, porque uma sessão vê
seu próprio trabalho não confirmado. O `ROLLBACK` então desfaz as duas atualizações.

```sql theme={null}
SELECT * FROM account;
```

```text theme={null}
+------------+------------------+---------+
| account_id | owner            | balance |
+------------+------------------+---------+
|          1 | Mary Smith       |  500.00 |
|          2 | Patricia Johnson |  250.00 |
+------------+------------------+---------+
2 rows in set (0.00 sec)
```

Este é o único "desfazer" que o MySQL tem. Depois que uma instrução fora de uma transação
é executada, os valores antigos desaparecem.

### Mantenha o trabalho com COMMIT

```sql theme={null}
START TRANSACTION;
UPDATE account SET balance = balance - 100 WHERE account_id = 1;
UPDATE account SET balance = balance + 100 WHERE account_id = 2;
COMMIT;
```

```text theme={null}
Query OK, 0 rows affected (0.00 sec)

Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

Query OK, 0 rows affected (0.00 sec)
```

```sql theme={null}
SELECT * FROM account;
```

```text theme={null}
+------------+------------------+---------+
| account_id | owner            | balance |
+------------+------------------+---------+
|          1 | Mary Smith       |  400.00 |
|          2 | Patricia Johnson |  350.00 |
+------------+------------------+---------+
2 rows in set (0.00 sec)
```

As 2 atualizações foram aplicadas juntas. Nenhuma outra sessão viu 400 e 250 ao
mesmo tempo, e essa é toda a razão para escrever dessa forma.

## Algumas instruções confirmam sem que você peça

Uma instrução que muda a forma do banco de dados não pode ser revertida.
Pior, executar uma delas confirma tudo o que a transação aberta havia feito até aquele
ponto.

```sql theme={null}
START TRANSACTION;
UPDATE account SET balance = 0 WHERE account_id = 1;
CREATE TABLE note (id INT);
ROLLBACK;
```

```text theme={null}
Query OK, 0 rows affected (0.00 sec)

Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

Query OK, 0 rows affected (0.00 sec)

Query OK, 0 rows affected (0.00 sec)
```

Toda linha informa sucesso, incluindo o `ROLLBACK`.

```sql theme={null}
SELECT * FROM account;
```

```text theme={null}
+------------+------------------+---------+
| account_id | owner            | balance |
+------------+------------------+---------+
|          1 | Mary Smith       |    0.00 |
|          2 | Patricia Johnson |  350.00 |
+------------+------------------+---------+
2 rows in set (0.00 sec)
```

O saldo é 0. `CREATE TABLE` confirmou a atualização antes de ser executado, então o
`ROLLBACK` não tinha mais nada para desfazer e mesmo assim informou sucesso. `ALTER TABLE`,
`DROP TABLE`, `TRUNCATE TABLE` e `RENAME TABLE` se comportam da mesma forma. Mantenha todas
as 5 fora de uma transação que está protegendo dados.

As tabelas temporárias são a exceção. `CREATE TEMPORARY TABLE` e
`DROP TEMPORARY TABLE` não confirmam nada, então o mesmo teste com uma tabela temporária
no meio deixa o saldo em 500.00.

## Resumo

* Escreva `START TRANSACTION`, depois as instruções, depois `COMMIT` ou `ROLLBACK`.
* Espere que toda instrução fora de uma transação seja confirmada por conta própria, porque `autocommit` está ligado.
* Espere que sua sessão veja suas próprias mudanças não confirmadas e que nenhuma outra sessão as veja.
* Trate `ROLLBACK` como o único "desfazer" que existe.
* Mantenha `CREATE TABLE`, `ALTER TABLE`, `DROP TABLE`, `TRUNCATE TABLE` e `RENAME TABLE` fora de uma transação, porque cada uma delas a confirma.
* Espere que as formas `TEMPORARY` de `CREATE` e `DROP` não confirmem nada.

## Veja também

* [UPDATE](https://villagesql.com/docs/pt-BR/tutorial/update.md) — a instrução que mais vale a pena envolver em uma transação
* [DELETE](https://villagesql.com/docs/pt-BR/tutorial/delete.md) — removendo linhas que você pode querer de volta
* [Transações no MySQL](https://villagesql.com/docs/pt-BR/guides/transactions.md) — níveis de isolamento, bloqueios, e o que eles custam
* [Deadlocks no MySQL](https://villagesql.com/docs/pt-BR/guides/deadlocks.md) — o que acontece quando 2 transações querem as mesmas linhas


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.