Continuando a apresentação dos comandos SQL para manipulação de dados (conhecidos como DML, ou Data Manipulation Language), veremos neste artigo como incluir, excluir e atualizar registros, além de uma introdução sobre o uso de sub-consultas.
Inserindo Dados
O comando SQL usado para inclusão de dados é o INSERT, que tem a seguinte formação:
INSERT INTO [(<lista_campos>)]</lista_campos>
VALUES ()Ou
INSERT INTO [(<lista_campos>)]</lista_campos>
()onde,
- NomeTabela: tabela sobre a qual o comando será executado.
- Lista_campos: termo opcional que indica as colunas que receberão os valores.
- ValoresInsert: valores que serão incluídos na tabela. Os campos devem estar na mesma ordem descrita em lista_campos. Se lista_campos não foi utilizado, a lista deve conter todos os campos, na ordem em que foram criados.
- Instrução_Select: opcional, permite incluir na tabela dados originados da execução de uma frase SELECT em outra tabela. Neste caso, a instrução SELECT tem que retornar o mesmo número de colunas com os mesmos tipos de dados especificados em lista_campos.
Vejamos alguns exemplos:
INSERT INTO empregados (Codigo, Nome, Salario, Departamento)
VALUES (1, “José Silva”, 1500, 1);
INSERT INTO Empregados VALUES (1, “José Silva”, 1500, 1);
Na segunda opção omitimos a descrição dos campos. Repare que esta sintaxe só funciona se passarmos valores para todos os campos.
Podemos também passar um comando SELECT na lista de valores, referenciando outras tabelas. Veja o exemplo:
INSERT INTO empregados (Codigo, Nome, Salario)
SELECT (Codigo, Nome, Salario)
FROM empregados_filial
Where departamento = 2Neste comando todos os empregados da filial que trabalham no departamento “2” foram cadastrados na matriz. Se o nome dos campos não for especificado na cláusula INSERT, o SELECT deverá retornar valores compatíveis para todos os campos disponíveis na tabela de destino.
Atualizando dados
O comando SQL usado para atualização de registros é UPDATE, que tem a seguinte formação:
UPDATE
SET
[WHERE]onde,
- NomeTabela: tabela sobre a qual o comando será executado.
- AtribuiçõesColunas: recebe o campo seguido do novo valor. Vários campos podem ser alterados de uma vez, devendo ser separados por vírgula.
- Where : é a cláusula que impõe uma condicional à execução do comando. Se não for informada, a tabela inteira será atualizada.
Veja alguns exemplos:
UPDATE departamentos
SET salario_base = 1000
WHERE codigo = 1Neste código o departamento de código 1 terá o salário-base alterado para R$ 1000,00.
UPDATE empregados
SET salario = 500,
nome = ‘José da Silva’,
departamento = 3
WHERE codigo = 1;Neste exemplo alteramos vários campos de uma vez. Repare que selecionamos apenas um empregado, mas nada impede que vários registros sejam modificados. Veja o próximo exemplo:
UPDATE empregados
SET salario=1000
WHERE departamento = 5;Podemos combinar o uso do comando SELECT com UPDATE. No exemplo a seguir, os funcionários de menor salário receberão um aumento de 10%:
UPDATE empregados
SET salario = salario * 1.1
WHERE salario = (SELECT MIN(salario) from empregados)O comando SELECT também pode ser utilizado na atribuição do valor ao campo:
UPDATE empregados
SET salario = (SELECT MAX(salario) FROM EMPREGADOS)
WHERE departamento = 5;
Removendo dados
O comando SQL usado para exclusão é o DELETE, que tem a seguinte formação:
DELETE FROM
[WHERE]onde,
- NomeTabela: é o nome da tabela sobre a qual o comando será executado
- Where : é a clausula que impõe uma condicional sobre a execução do comando. Se não for informada, a tabela será esvaziada.
Exemplos:
DELETE FROM empregados
WHERE codigo = 125;
DELETE FROM empregados
WHERE departamento = 1;
DELETE FROM empregados
WHERE salario < 1000 OR departamento = 3;
Sub-consultas SQL
Uma sub-consulta é uma instrução SELECT aninhada dentro de outra instrução SELECT, INSERT, DELETE ou UPDATE. Vejamos algumas sintaxes para criação de sub-consultas:
- comparação [ANY | SOME | ALL ] (instruçãosql)
- expressão [NOT] IN (instruçãosql)
- expressão [NOT] EXISTS (instruçãosql)
Os predicados ANY e SOME, sinônimos, são utilizados para recuperar registros na consulta principal que satisfaçam a comparação com qualquer registro da sub-consulta. Para exemplificar, temos as tabelas abaixo:
Tabela A
|
X |
Y |
|
1 |
5 |
|
2 |
9 |
|
3 |
10 |
|
4 |
6 |
Tabela B
|
X |
Y |
|
10 |
4 |
|
20 |
3 |
|
30 |
11 |
|
40 |
9 |
Exemplo:
SELECT * FROM A WHERE Y > ANY
(SELECT Y FROM B WHERE X >20);
Resultado:
|
X |
Y |
|
3 |
10 |
Os registros da tabela A que forem maior do que qualquer registro do resultado da sub-consulta serão selecionados. Repare que nenhum registro da tabela A é maior do que 11; No entanto, o terceiro registro é maior do que 9. Vejamos outro exemplo:
SELECT * FROM A WHERE Y > ANY
(SELECT Y FROM B WHERE X < 40);
Resultado:
|
X |
Y |
|
1 |
5 |
|
2 |
9 |
|
3 |
10 |
|
4 |
6 |
Todos os registros foram selecionados porque o valor de Y no resultado da sub-consulta assume 3, que é menor do que todos os valores de Y da tabela A. Se utilizarmos o ANY com sinal de igualdade teremos o mesmo resultado da cláusula IN. Veja o exemplo:
SELECT * FROM A WHERE Y = ANY
(SELECT Y FROM B);
Resultado:
|
X |
Y |
|
2 |
9 |
O predicado ANY também pode ser utilizado em conjunto com os comandos UPDATE e DELETE. Veja os exemplos:
UPDATE A SET X = X * 10 WHERE Y > ANY
(SELECT Y FROM B WHERE X < 40);
DELETE FROM A WHERE Y > ANY
(SELECT Y FROM B WHERE X < 40);
O predicado ALL é utilizado para recuperar os registros da consulta principal que satisfaçam a comparação com todos os registros recuperados na sub-consulta. Observe os exemplos:
SELECT * FROM A WHERE Y > ALL
(SELECT Y FROM B);
Resultado:
|
X |
Y |
SELECT * FROM A WHERE Y > ALL
(SELECT Y FROM B WHERE X > 30);
Resultado:
|
X |
Y |
|
3 |
10 |
O uso de != ALL equivale a NOT IN:
SELECT * FROM A WHERE Y != ALL
(SELECT Y FROM B )
Resultado:
|
X |
Y |
|
1 |
5 |
|
3 |
10 |
|
4 |
6 |
O predicado IN é utilizado para recuperar apenas os registros na consulta principal que contém equivalência na sub-consulta. É o mesmo que =ANY:
SELECT * FROM A WHERE Y IN
(SELECT Y FROM B)
Resultado:
|
X |
Y |
|
2 |
9 |
No código a seguir retornamos os empregados que venderam um montante maior que R$ 50.000,00:
SELECT * FROM empregado WHERE codigo IN
(SELECT codempregado FROM vendas
GROUP BY codempregado
HAVING Max(valortotal) > 50000);
De maneira contrária, NOT IN pode ser utilizado para recuperar apenas os registros na consulta principal para os quais não existam equivalência na sub-consulta. Veja o exemplo:
SELECT * FROM A WHERE Y NOT IN
(SELECT Y FROM B)
Resultado:
|
X |
Y |
|
1 |
5 |
|
3 |
10 |
|
4 |
6 |
O predicado EXISTS determina se a sub-consulta retorna algum registro. Esta cláusula produz resultados semelhantes ao uso de IN. Veja um exemplo:
SELECT * FROM empregado WHERE EXISTS
(SELECT * FROM pedidos
WHERE empregado.codigo = pedidos.codempregado
GROUP BY pedidos.codempregado
HAVING Max(pedidos.valor_total) > 50000;
Neste comando são retornados o nome e o departamento dos funcionários cuja soma de vendas ultrapassaram R$ 50.000,00.
O predicado NOT EXISTS também pode ser utilizado, produzindo o efeito contrário:
SELECT * FROM empregado WHERE NOT EXISTS
(SELECT * from pedidos
WHERE empregado.codigo = pedidos.codempregado )
Como vimos, os comandos SQL fornecem uma linguagem muito simples para manipulação de dados no SGBD. Como a SQL se tornou um padrão, os comandos apresentados funcionarão na maioria dos bancos de dados relacionais disponíveis no mercado. Consulte a referência do seu banco para possíveis alterações ou particularidades.
Destaques
“em tabelas grandes ou com campos opcionais não é necessário explicitar todos os campos da mesma na frase de insert”
“é possível incluir dados numa tabela originados da execução de uma frase do tipo SELECT em outra tabela”
“a atualização pode efetuar várias operações com as colunas, sejam aritméticasou de concatenação se caracteres”
