> ## 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.

# UPDATE no MySQL

> Como a instrução UPDATE do MySQL altera linhas que já estão em uma tabela, o que Rows matched e Changed contam cada um, e o que acontece quando você omite o WHERE.

> [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 →

`UPDATE` altera linhas que já estão lá. O `WHERE` decide quais,
e ele é a única coisa entre 1 linha e a tabela inteira.

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 UPDATE funciona

```sql theme={null}
UPDATE TABLE_NAME
SET COLUMN_NAME = NEW_VALUE
WHERE CONDITION;
```

Substitua `TABLE_NAME` pela tabela, `COLUMN_NAME` pela coluna a alterar,
`NEW_VALUE` pelo que colocar nela, e `CONDITION` pelo teste que escolhe
as linhas.

O `WHERE` funciona exatamente como em um `SELECT`, e essa é a forma mais segura
de escrever um `UPDATE`: execute-o como um `SELECT` primeiro, olhe as linhas, depois mude
`SELECT ...` para `UPDATE ... SET ...` e deixe o `WHERE` como está.

## Exemplos

### Altere 1 linha

```sql theme={null}
UPDATE member SET active = 0 WHERE member_id = 2;
```

```text theme={null}
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
```

```sql theme={null}
SELECT member_id, first_name, last_name, active FROM member;
```

```text theme={null}
+-----------+------------+-----------+--------+
| member_id | first_name | last_name | active |
+-----------+------------+-----------+--------+
|         1 | Mary       | Smith     |      1 |
|         2 | Patricia   | Johnson   |      0 |
|         3 | Linda      | Williams  |      0 |
+-----------+------------+-----------+--------+
3 rows in set (0.00 sec)
```

### Matched e Changed contam coisas diferentes

Execute a mesma instrução uma segunda vez.

```sql theme={null}
UPDATE member SET active = 0 WHERE member_id = 2;
```

```text theme={null}
Query OK, 0 rows affected (0.00 sec)
Rows matched: 1  Changed: 0  Warnings: 0
```

O `WHERE` ainda encontrou a linha, então `Rows matched` é 1. A linha já tinha
0, então nada foi gravado e `Changed` é 0. Leia os 2 números juntos:
`matched 0` significa que o `WHERE` não encontrou nada, que é um problema diferente de
`changed 0`, que significa que você pediu um valor que as linhas já têm.

### Altere várias colunas de uma vez

Separe as atribuições com vírgulas, não com `AND`.

```sql theme={null}
UPDATE member
SET last_name = 'Smith-Davis', email = 'mary.smith-davis@example.com'
WHERE member_id = 1;
```

```text theme={null}
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0
```

```sql theme={null}
SELECT member_id, first_name, last_name, email FROM member WHERE member_id = 1;
```

```text theme={null}
+-----------+------------+-------------+------------------------------+
| member_id | first_name | last_name   | email                        |
+-----------+------------+-------------+------------------------------+
|         1 | Mary       | Smith-Davis | mary.smith-davis@example.com |
+-----------+------------+-------------+------------------------------+
1 row in set (0.00 sec)
```

## Um UPDATE encontra as mesmas restrições que um INSERT

Mover para uma coluna `UNIQUE` um valor que outra linha já tem falha da mesma
forma, e a linha mantém o que tinha.

```sql theme={null}
UPDATE member SET email = 'patricia.johnson@example.com' WHERE member_id = 3;
```

```text theme={null}
ERROR 1062 (23000): Duplicate entry 'patricia.johnson@example.com' for key 'member.uq_member_email'
```

## Sem um WHERE, ele altera todas as linhas

Não há etapa de confirmação. A instrução é executada e todas as linhas da tabela
recebem o novo valor.

Uma configuração de sessão pode recusar essa forma por você. O modo de atualização segura rejeita um
`UPDATE` ou um `DELETE` que não testa uma coluna de chave no seu `WHERE` nem
carrega um `LIMIT`, e ele fica desligado a menos que você o peça.

```sql theme={null}
SET SESSION sql_safe_updates = 1;
UPDATE member SET active = 1;
```

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

ERROR 1175 (HY000): You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column.
```

Inicie o cliente com `mysql -u root -p --safe-updates sakila_practice` para ter
a proteção desde a primeira instrução. Essa flag faz mais do que definir essa única
variável: ela também limita um `SELECT` a 1.000 linhas por meio de `sql_select_limit` e
restringe um join por meio de `max_join_size`, então uma leitura de uma tabela grande volta
incompleta sem avisar. `ERROR 1175` significa que a proteção interrompeu você.

Desligue-a novamente quando a instrução realmente deve atingir todas as linhas.

```sql theme={null}
SET SESSION sql_safe_updates = 0;
```

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

Com a proteção desligada, a instrução é executada.

```sql theme={null}
UPDATE member SET active = 1;
```

```text theme={null}
Query OK, 2 rows affected (0.00 sec)
Rows matched: 3  Changed: 2  Warnings: 0
```

```sql theme={null}
SELECT member_id, first_name, active FROM member;
```

```text theme={null}
+-----------+------------+--------+
| member_id | first_name | active |
+-----------+------------+--------+
|         1 | Mary       |      1 |
|         2 | Patricia   |      1 |
|         3 | Linda      |      1 |
+-----------+------------+--------+
3 rows in set (0.00 sec)
```

`Rows matched: 3  Changed: 2` porque 1 membro já estava ativo.

Uma atualização da tabela inteira às vezes é exatamente o certo. Aumentar todos os saldos em 5%
é 1 instrução, e o novo valor é calculado a partir do antigo.

```sql theme={null}
UPDATE account SET balance = balance * 1.05;
```

```text theme={null}
Query OK, 2 rows affected (0.00 sec)
Rows matched: 2  Changed: 2  Warnings: 0
```

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

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

`balance = balance * 1.05` lê o valor atual de cada linha, então cada linha recebe
sua própria resposta.

## Resumo

* Escreva `UPDATE table SET column = value WHERE condition` para alterar linhas existentes.
* Execute o `WHERE` como um `SELECT` primeiro, depois mude apenas o início da instrução.
* Leia `Rows matched` e `Changed` como 2 fatos separados.
* Separe várias atribuições com vírgulas.
* Espere que um `UPDATE` encontre as mesmas regras `UNIQUE` e `NOT NULL` que um `INSERT`.
* Ligue o modo de atualização segura, e leia `ERROR 1175` como a proteção fazendo o seu trabalho.

## Veja também

* [WHERE](https://villagesql.com/docs/pt-BR/tutorial/where.md) — a cláusula que decide quais linhas mudam
* [DELETE](https://villagesql.com/docs/pt-BR/tutorial/delete.md) — removendo linhas em vez de alterá-las
* [Upsert](https://villagesql.com/docs/pt-BR/tutorial/upsert.md) — atualize uma linha existente, ou insira uma se não houver nenhuma
* [Transações](https://villagesql.com/docs/pt-BR/tutorial/transactions.md) — desfazendo um UPDATE que estava errado


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