Introdução a Manipulação de Dados - SQL
Tags: beginners, sql, mysql, braziliandevs
Published: 2022-02-23 21:28:19

## Tabela de Conteúdos

- [`INSERT`](#insert)
- [`UPDATE`](#update)
- [`DELETE`](#delete)

---

## INSERT

### O que é?

É um comando SQL utilizado para inserir dados em uma tabela.

### Sintaxe

A sintaxe é simples, para definir a tabela e as colunas que receberão os dados devemos utilizar as palavras reservadas `INSERT INTO`, seguida do nome da tabela que queremos inserir os dados e por fim passamos as colunas que receberão os dados como argumento.

Após definir onde enviaremos os dados, utilizamos o comando `VALUES`, seguido dos valores a serem enviados como argumento.

``` sql
INSERT INTO <nome da tabela> (<coluna1>, <coluna2>, ..., <colunaN>)
VALUES ('valor1', 'valor2', ..., 'valorN');
```
``` sql
INSERT INTO sakila.actor (first_name, last_name)
VALUES ('Tom', 'Holland');
```

### Variações

#### Inserindo múltiplas linhas

Para inserirmos múltiplas linhas em nossa tabela, podemos separar as informações passadas após o comando `VALUES` utilizando vírgula.

``` sql
INSERT INTO <nome da tabela> (<coluna1, coluna2, …>) VALUES
('valor1', 'valor2'), /* <- Nova linha */
('valor3', 'valor4'), /* <- Nova linha */
('valor5', 'valor6'); /* <- Nova linha */
```

``` sql
INSERT INTO sakila.actor (first_name, last_name) VALUES
('Tom', 'Holland'), /* <- Nova linha */
('Brad', 'Pitt'), /* <- Nova linha */
('Leonard', 'Dicaprio'); /* <- Nova linha */
```

<br />

#### Ignorando linhas existentes

Ao importarmos uma grande quantidade de dados, pode ser interessante ignorarmos os erros que normalmente parariam nossa Query, dessa forma o DB __automaticamente irá descartar os dados importados problemáticos e atualizar os importados com sucesso__.

Para isso basta utilizar o comando `IGNORE`, após o `INSERT` e antes do `INTO`.

``` sql
INSERT IGNORE INTO <nome da tabela> (<coluna1, coluna2, …>)
VALUES ('valor1', 'valor2', …);
```

``` sql
INSERT IGNORE INTO sakila.actor (first_name, last_name)
VALUES ('Tom', 'Holland');
```

<br />

#### Importando de outra tabela
Podemos importar uma tabela inteira para outra tabela, desde que elas __possuam a mesma quantidade de colunas e cada coluna seja do mesmo tipo__. Dessa forma podemos __criar cópias para testes__.

Para isso utilizamos o comando `INSERT INTO`, seguido do `SELECT FROM` e por fim, podemos opcionalmente adicionar filtros com o `WHERE`.

``` sql
INSERT INTO <tabela1> (<coluna1, coluna2>)
SELECT <coluna1>, <coluna2>
FROM <tabela2>;
```

``` sql
INSERT INTO sakila.actor_test (first_name, last_name)
SELECT (first_name, last_name)
FROM sakila.actor;
```

<br />

<small>[Voltar ao topo](#tabela-de-conteúdos)</small>

___

## UPDATE

### O que é?

É um comando para atualizar determinado dado em nosso DB.

### Sintaxe

Para utilizarmos o `UPDATE` devemos informar a tabela que queremos acessar, a coluna queremos modificar e por fim o dado em si que sofrerá a modificação. Para selecionarmos especificamente um dado __devemos utilizar um filtro__, no caso o `WHERE`, seguido das condicionais.

``` sql
UPDATE <tabela>
SET <coluna> = <novo valor>
WHERE <condicional>;
```
``` sql
UPDATE sakila.actor
SET first_name = 'Jorge'
WHERE first_name = 'George';
```

Uma observação importante a se fazer, é que o MySQL possui uma configuração de segurança que não nos permite realizar um `UPDATE` ou `DELETE` sem informar a Key da linha que desejamos alterar.

Para desabilitar essa configuração, podemos rodar o comando `SET SQL_SAFE_UPDATES = 0` em um arquivo de Query, sendo necessário __rodar esse comando toda a vez que abrimos o DB__.

### Variações

#### Alterando mais de uma coluna
Para alterarmos mais de uma coluna na mesma interação podemos simplesmente adicionar mais colunas após o comando `SET`, separando-as por vírgula.

``` sql
UPDATE <tabela>
SET <coluna1> = <novo valor>, <coluna 2> = <novo valor>
WHERE <condicional>;
```

``` sql
UPDATE sakila.actor
SET first_name = 'Jorge', last_name = 'Amado'
WHERE first_name = 'George' AND last_name = 'Lucas';
```

<br />

#### Alteração em massa

##### Opção 1
Mesmo podendo separar as alterações por vírgula, há outra forma de realizarmos alterações em massa, no caso da sintaxe de separação por vírgula ficar muito verbosa e ilegível.

Para isso temos duas opções, podemos alterar diversas colunas com um valor único, utilizado o `IN` como condicional e passando as condições entre parênteses.

Dessa forma, toda a coluna que for verdadeira diante da condicional, terá seu valor alterado por aquele que nós passamos.

``` sql
UPDATE <tabela>
SET <coluna> = <'novo valor'>
WHERE <condicional> IN (opção 1, opção 2, opção 3, …);
```

``` sql
UPDATE sakila.actor
SET first_name = 'Jorge'
WHERE first_name in ('George', 'Giorge', "Jurge');
```

##### Opção 2
Ou no caso de querermos alterar diferentes valores para cada caso, devemos utilizar uma sintaxe similar ao `switch/case` do JS.

Após o `SET` abrimos parênteses e utilizamos o comando `CASE`, passando a coluna de comparação, seguido do comando `WHEN` que deve informar a condição e por fim o `THEN` que informa o novo valor.

Nessa sintaxe também é necessário o uso do comando `ELSE` ao final dos casos, informando que todos os outros dados, que não foram listados, devem permanecer iguais.

``` sql
UPDATE <tabela>
SET <coluna> = (
  CASE <coluna de comparação>
    WHEN <condição> THEN <novo valor>
    WHEN <condição> THEN <novo valor>
    WHEN <condição> THEN <novo valor>
  ELSE <coluna>
END);
```

``` sql
UPDATE sakila.actor
SET first_name = (
  CASE first_name
    WHEN 'George' THEN 'Jorge'
    WHEN 'John' THEN 'João'
    WHEN 'Joseph' THEN 'José'
  ELSE first_name
END);
```

<br />

#### Fazendo updates sequenciais

Podemos ainda configurar e limitar nossos updates utilizando os comandos `ORDER BY` e `LIMIT`, dessa forma as alterações serão realizadas na ordem que forem encontradas e __caso houver limitação, somente um determinado número de dados será alterado__.

``` sql
UPDATE <tabela>
SET <coluna> = <novo valor>
WHERE <condicional>
ORDER BY <coluna de ordenação>
LIMIT <quantidade a ser alterada>;
```

``` sql
UPDATE sakila.actors
SET age = 18
WHERE age >= 60
ORDER BY age
LIMIT 5;
```

<br />

<small>[Voltar ao topo](#tabela-de-conteúdos)</small>

___

## DELETE

### O que é?
É um comando que deleta dados de uma tabela.

### Sintaxe
A sintaxe do `DELETE` segue a mesma ideia do `UPDATE`, informamos a tabela a ser acessada e __através de uma condição definimos os dados a serem excluídos__.

Lembrando que da mesma forma que o `UPDATE` possui uma limitação de segurança, imposta pelo próprio MySQL, o `DELETE` também a possui.

``` sql
DELETE FROM <DB>.<tabela>
WHERE <coluna> = <condicional>;
```

``` sql
DELETE FROM sakila.actors
WHERE id = 1;
```

### Dependências
Diferente de outros comandos, o `DELETE` não possui muitas variações, porém ele tem algumas limitações, isso porque muitas vezes um dados está relacionado ao outro, logo se o excluirmos estamos deixando nosso DB incoerente.

As dependências podem ser variadas, logo o melhor a se fazer é __ler o erro__ que o DB retorna ao tentarmos excluir um dado.


<br />

<small>[Voltar ao topo](#tabela-de-conteúdos)</small>