Transações MySQL e Integridade de Dados

Introdução

Neste laboratório, você aprenderá a usar transações MySQL para garantir a integridade dos dados. Transações agrupam uma série de operações SQL em uma única unidade de trabalho, onde tudo é executado ou nada é executado. Isso é essencial para tarefas como transferências financeiras, onde todas as etapas devem ser concluídas com sucesso.

Você praticará o início de uma transação com BEGIN, a confirmação de alterações com COMMIT, o desfazimento de alterações com ROLLBACK e a realização de rollbacks parciais usando SAVEPOINT. Ao final deste laboratório, você entenderá como gerenciar operações de banco de dados de forma segura e confiável.

Configurar o Banco de Dados e as Tabelas

Antes de trabalhar com transações, você precisa configurar um banco de dados e uma tabela. Nesta etapa, você criará um banco de dados chamado bank_db e uma tabela accounts para simular operações bancárias.

Primeiro, abra o terminal a partir da sua área de trabalho.

Conecte-se ao servidor MySQL como o usuário root. Este ambiente de laboratório não requer senha para o usuário root.

sudo mysql -u root

Uma vez conectado, você verá o prompt do MySQL (mysql>), indicando que você pode executar comandos SQL.

Crie o banco de dados bank_db e mude para ele para a sessão atual. A cláusula IF NOT EXISTS impede um erro se o banco de dados já existir.

CREATE DATABASE IF NOT EXISTS bank_db;
USE bank_db;

Em seguida, crie a tabela accounts. Esta tabela armazenará informações da conta, incluindo um ID, número da conta e saldo.

CREATE TABLE accounts (
    id INT AUTO_INCREMENT PRIMARY KEY,
    account_number VARCHAR(20) UNIQUE NOT NULL,
    balance DECIMAL(10, 2) NOT NULL
);

Agora, insira duas contas de exemplo na tabela accounts. Estas servirão como nossos dados iniciais.

INSERT INTO accounts (account_number, balance) VALUES
('ACC001', 1000.00),
('ACC002', 500.00);

Para confirmar que a tabela e os dados foram criados corretamente, execute a seguinte consulta:

SELECT * FROM accounts;

Você deverá ver as duas contas que acabou de inserir. A saída será semelhante a esta:

+----+----------------+---------+
| id | account_number | balance |
+----+----------------+---------+
|  1 | ACC001         | 1000.00 |
|  2 | ACC002         |  500.00 |
+----+----------------+---------+
2 rows in set (0.00 sec)

Com o banco de dados e a tabela preparados, você está pronto para aprender sobre transações.

Criar uma Transação Bem-Sucedida com BEGIN e COMMIT

Uma transação é uma sequência de operações realizadas como uma única unidade lógica. Para tornar as alterações permanentes, você deve confirmá-las (COMMIT). Nesta etapa, você simulará uma transferência bancária bem-sucedida de ACC001 para ACC002.

Você ainda deve estar no shell do MySQL da etapa anterior.

Primeiro, inicie uma nova transação usando o comando BEGIN. Todos os comandos subsequentes farão parte desta transação até que você execute COMMIT ou ROLLBACK.

BEGIN;

Agora, execute as duas operações para a transferência: deduzir $100 de ACC001 e adicionar $100 a ACC002.

UPDATE accounts SET balance = balance - 100.00 WHERE account_number = 'ACC001';
UPDATE accounts SET balance = balance + 100.00 WHERE account_number = 'ACC002';

Neste ponto, as alterações são visíveis apenas dentro da sua sessão atual. Você pode verificar o estado temporário das contas:

SELECT * FROM accounts;

A saída mostrará os saldos atualizados, mas eles ainda não foram salvos permanentemente.

+----+----------------+---------+
| id | account_number | balance |
+----+----------------+---------+
|  1 | ACC001         |  900.00 |
|  2 | ACC002         |  600.00 |
+----+----------------+---------+
2 rows in set (0.00 sec)

Como ambas as operações foram bem-sucedidas, você pode tornar as alterações permanentes confirmando a transação.

COMMIT;

O comando COMMIT salva todas as alterações feitas durante a transação. A transferência está agora completa e visível para todas as outras conexões do banco de dados. Você pode verificar isso consultando a tabela novamente. Os saldos permanecerão em $900 e $600.

Desfazer uma Transação com ROLLBACK

Às vezes, uma operação dentro de uma transação falha, ou você pode decidir cancelá-la. O comando ROLLBACK descarta todas as alterações feitas durante a transação atual, restaurando o banco de dados ao seu estado anterior ao início da transação.

Vamos iniciar uma nova transação para adicionar uma nova conta.

BEGIN;

Agora, insira uma nova conta ACC003 na tabela accounts.

INSERT INTO accounts (account_number, balance) VALUES ('ACC003', 150.00);

Verifique a tabela para ver a nova conta dentro da transação.

SELECT * FROM accounts;

Você verá três contas listadas.

+----+----------------+---------+
| id | account_number | balance |
+----+----------------+---------+
|  1 | ACC001         |  900.00 |
|  2 | ACC002         |  600.00 |
|  3 | ACC003         |  150.00 |
+----+----------------+---------+
3 rows in set (0.00 sec)

Agora, imagine que você percebe que esta conta não deveria ter sido adicionada. Em vez de confirmar (COMMIT), você pode cancelar toda a transação usando ROLLBACK.

ROLLBACK;

Este comando desfaz a operação INSERT. Para verificar isso, consulte a tabela accounts novamente.

SELECT * FROM accounts;

A conta ACC003 desapareceu, e a tabela voltou ao estado em que estava antes de você digitar BEGIN.

+----+----------------+---------+
| id | account_number | balance |
+----+----------------+---------+
|  1 | ACC001         |  900.00 |
|  2 | ACC002         |  600.00 |
+----+----------------+---------+
2 rows in set (0.00 sec)

ROLLBACK é uma ferramenta crítica para manter a integridade dos dados quando ocorrem erros.

Usar SAVEPOINT para Rollbacks Parciais

Para transações longas, você pode querer desfazer apenas uma parte do trabalho em vez da transação inteira. SAVEPOINT permite que você defina um marcador dentro de uma transação para o qual você pode posteriormente fazer rollback.

Vamos iniciar uma nova transação.

BEGIN;

Primeiro, atualize o saldo de ACC001, aumentando-o em $50.

UPDATE accounts SET balance = balance + 50.00 WHERE account_number = 'ACC001';

Agora, crie um savepoint. Isso funciona como um marcador para o estado atual da transação.

SAVEPOINT after_update;

Em seguida, execute outra operação: insira uma nova conta ACC004.

INSERT INTO accounts (account_number, balance) VALUES ('ACC004', 300.00);

Vamos supor que a inserção de ACC004 foi um erro, mas a atualização de ACC001 estava correta. Você pode fazer rollback para o savepoint para desfazer apenas a instrução INSERT.

ROLLBACK TO after_update;

Este comando reverte a transação para o estado em que estava quando você criou o savepoint after_update. A inserção de ACC004 é desfeita, mas a atualização de ACC001 permanece.

Consulte a tabela para confirmar. ACC004 deve ter desaparecido, mas o saldo de ACC001 deve estar atualizado.

SELECT * FROM accounts;

A saída deve mostrar ACC001 com um saldo de $950.00 e sem ACC004.

+----+----------------+---------+
| id | account_number | balance |
+----+----------------+---------+
|  1 | ACC001         |  950.00 |
|  2 | ACC002         |  600.00 |
+----+----------------+---------+
2 rows in set (0.00 sec)

Como você deseja manter a atualização de ACC001, você pode agora confirmar a parte restante da transação.

COMMIT;

Você usou com sucesso um savepoint para realizar um rollback parcial. Agora você pode sair do shell do MySQL.

exit;

Resumo

Neste laboratório, você aprendeu os fundamentos das transações MySQL para manter a integridade dos dados. Você praticou o ciclo de vida completo da transação, desde o início de uma transação com BEGIN até a sua finalização com COMMIT ou o cancelamento com ROLLBACK.

Você simulou com sucesso uma transferência bancária, garantindo que múltiplas operações fossem tratadas como uma única unidade atômica. Você também aprendeu a usar SAVEPOINT para obter um controle mais refinado sobre transações complexas, permitindo rollbacks parciais. Essas habilidades são cruciais para desenvolver aplicações de banco de dados robustas e confiáveis, onde a consistência dos dados é primordial.