SQL Guia de referência: Comandos DML

Mostraremos agora os comandos da DML (Data Manipulation Language ou Linguagem de Manipulação de Dados). Tais comandos abrangem as principais operações executadas no banco de dados: inclusão, edição, exclusão e consulta.

O comando INSERT

A inclusão de dados se dá através do comando Insert. A sintaxe desse comando é bastante simples, basta informar a tabela, os campos e os seus respectivos valores:

INSERT INTO <nome da tabela>

[(<coluna> [, <coluna>, ...)]]

VALUES

(<valor> [,<valor> , ...] | <comando de seleção>)

Para incluir um registro na tabela Aluno, por exemplo, utilize o código:

INSERT INTO ALUNO (ID_ALUNO, NOME)

  VALUES (1, 'Fabio Sarturi')

Como podemos notar, nem todos os campos da tabela Aluno estão no código anterior (faltaram os campos Data_Nasc, Telefone e Email). Esses campos puderam ser suprimidos porque não são obrigatórios (restrição Not Null), ou seja, se um campo é obrigatório ele necessariamente deve estar presente no Insert, claro, do contrário o comando falhará.

A exceção ocorre quando formos preencher todos os campos da tabela. Nesse caso, podemos simplesmente suprimir o nome de todas as colunas, tomando apenas o cuidado de colocar todos os valores na mesma ordem em que a tabela foi criada:

INSERT INTO ALUNO VALUES (2, 'Jose da Silva',

  '02/02/1980','48 2335566','silva@provedor.com');

A inclusão de dados pode ainda ser feita via comando de seleção (SELECT). A vantagem desse recurso é que podemos facilmente migrar dados de uma tabela para outra, veja um exemplo de utilização:

INSERT INTO tabelaX

(C1, C2)

(SELECT C3, C4 FROM tabelaY)

Evidentemente, o tipo de dado do campo C1 deve ser compatível com tipo de dado do C3, assim como os dos campos C2 e C4. Além disso, é preciso tomar cuidado para que os valores não causem duplicidade em algum campo que contenha a restrição Unique, como chaves-primárias. Note que, quando incluímos dados através de um comando Select (estudaremos ele ainda neste artigo), suprimimos a palavra Values da instrução.

Registros das tabelas

Para fazer os exemplos que serão apresentados neste artigo, inclua na tabela Aluno os registros da Tabela 1, na tabela Curso os registros: 1- Delphi, 2- Firebird, 3- Java e na tabela Aluno_Curso os registros da Tabela 2.

O comando UPDATE

O UPDATE permite a atualização de dados, sua sintaxe é:

UPDATE <nome da tabela>

SET <coluna> = <novo valor>

 [, <coluna> = <novo valor>, ...]

[WHERE <condição>]

Por exemplo, para alterar o nome Fabio Sarturi, que foi incluído sem o último sobrenome, basta fazer:

UPDATE ALUNO

SET NOME = 'Fabio Sarturi Prass'

WHERE ID_ALUNO = 1

O UPDATE também permite a atualização simultânea de vários campos:

UPDATE ALUNO

SET NOME = 'Fabio Sarturi Prass',

  EMAIL = 'fsprass@yahoo.com.br'

WHERE ID_ALUNO = 1

É preciso tomar cuidado com a cláusula where, ela não é obrigatória, porém se não for utilizada, todos os registros da tabela serão alterados, obviamente. Entretanto, mesmo com a existência do where, é preciso tomar cuidado. Se no código anterior, trocarmos a condição Id_Aluno = 1 para Id_Aluno >= 1, todos os registros serão alterados, claro, uma vez que não temos nenhum valor menor do que 1 no campo Id_Aluno.

O comando DELETE

O Delete permite apagar registros de tabelas. A sintaxe do comando é mostrada a seguir:

DELETE FROM <nome da tabela>

[WHERE <condição>]

Vale aqui a mesma observação feita no comando UPDATE, se a cláusula WHERE for suprimida, todos os registros da tabela serão apagados. O código a seguir exclui o aluno cujo Id seja igual a 1:

DELETE FROM ALUNO WHERE ID_ALUNO = 1

Se o leitor tentar executar o comando apresentado, não obterá sucesso. Quando criamos a tabela Aluno_Curso, adicionamos a ela uma restrição de chave estrangeira para exclusão (On Delete No Action - ver o artigo na edição anterior). Para que pudéssemos excluir o aluno com o Id igual a 1, teríamos antes que excluir todas as linhas na tabela Aluno_Curso em que ele é referenciado (no entanto, não execute os comandos, apenas considere como exemplo):

DELETE FROM ALUNO_CURSO WHERE ID_ALUNO = 1;

DELETE FROM ALUNO WHERE ID_ALUNO = 1;

Se a restrição de exclusão não tivesse sido adicionada, ao excluir o aluno com Id igual a 1, ficaríamos com registros na tabela Aluno_Curso de um aluno que não existe mais, ou seja, teríamos uma inconsistência no banco de dados.

Ainda sobre a restrição de chave-estrangeira, se tivéssemos utilizado a opção On Delete Cascade na tabela Aluno_Curso, ao excluir o aluno da tabela Aluno, todos os registros da tabela Aluno_Curso cujo Id_Aluno for igual a 1 também seriam excluídos.

Comando SELECT

Sem dúvida esse é o principal comando da linguagem SQL. O SELECT permite selecionar registros no banco de dados. Sua sintaxe básica é a seguinte:

SELECT
  * | <coluna> [, <coluna> …]
FROM <tabela> [, <tabela> …]
[WHERE <condição>]
[ORDER BY <coluna> [, <coluna> …]]

SELECT identifica os campos que serão mostrados, From identifica a lista de tabelas que serão consultadas, Where a condição para que o registro seja selecionado e, por último, ORDER BY indica a ordenação em que o resultado será mostrado. Segue um exemplo simples de utilização do comando SELECT:

O primeiro comando de consulta apresenta todos os registros da tabela Aluno_Curso. Se essa tabela fizesse parte de um sistema que controla os alunos de uma instituição de ensino do mundo real, teríamos na tabela um grande número de registros.

Dessa forma, para não gerarmos um tráfego de dados desnecessário, e também para que a nossa listagem possa ser lida com clareza, devemos adicionar algumas restrições nos comandos. Por exemplo: mostrar os alunos da Turma 1 (Nr_Turma = 1), do curso de Delphi (Id_Curso = 1), ordenado pelo nome do aluno:

SELECT ID_ALUNO, NOTA1, NOTA2

FROM ALUNO_CURSO

WHERE

  NR_TURMA = 1 AND

  ID_CURSO = 1

ORDER BY ID_ALUNO

Se o leitor executar o comando apresentado, terá como resultado duas linhas (1; 8.0; 7.0 e 2; 7.8; 8.2). A leitura desses dados é difícil, uma vez que apenas o número do aluno foi apresentado e não o seu nome. Para mostrar o nome do aluno, necessitamos fazer uma junção (um JOIN) entre as tabelas Aluno e Aluno_Curso. A forma mais simples de fazer isso é utilizar o seguinte código:

SELECT A.NOME, AC.NOTA1, AC.NOTA2

FROM ALUNO_CURSO AC, ALUNO A

WHERE

  AC.ID_ALUNO = A.ID_ALUNO AND

  AC.NR_TURMA = 1 AND

  AC.ID_CURSO = 1

ORDER BY A.NOME

Note que em From foi acrescentada a tabela Aluno. Sempre que estivermos selecionando dados em mais de uma tabela, devemos dar um alias (ou apelido) a cada uma delas, como os usados no código anterior: AC para Aluno_Curso e A para Aluno. O uso de alias não é obrigatório, entretanto se não tivéssemos utilizado o mesmo, seria necessário escrever o nome da tabela antes de cada um dos campos, cujo nome existe em mais de uma tabela.

Nesse caso, sempre que Id_Aluno for usado, seria necessário fazer algo como Aluno_Curso. Id_Aluno ou Aluno. Id_Aluno, o que torna o código maior e menos legível. Se no From temos mais de uma tabela, devemos identificar na cláusula where como essas tabelas estão relacionadas, em outras palavras, precisamos informar como se dá a "junção" entre ambas (daqui para frente usaremos o termo Join).

O Join entre tabelas é feito através da chave-estrangeira (Foreign Key). Nesse caso, o campo IId_Aluno é a referência, então devemos informar ao banco de dados que sempre que Id_Aluno aparecer na tabela Aluno_Curso, queremos que seja apresentado o registro correspondente na tabela Aluno, isso é feito da seguinte forma: AC.ID_ALUNO = A.ID_ALUNO.

Se não especificarmos como as tabelas são relacionadas, o banco de dados trará como resultado o produto cartesiano das tabelas envolvidas (no caso Aluno_Curso x Aluno). Exclua do comando a expressão AC.ID_ALUNO = A.ID_ALUNO AND e execute o mesmo. Ao invés de apenas dois registros, retornarão 14, ou seja, o produto cartesiano da tabela Aluno (sete registros) com a tabela Aluno_Curso onde Nr_Turma e Id_Curso forem igual a 1 (dois registros).

É possível ainda fazer a junção de tabelas através do comando INNER JOIN conforme veremos no próximo artigo.

Funções

Bons bancos de dados trazem consigo uma série de funções que ajudam na hora de selecionar registros. Como queremos atender a todos os leitores, apresentaremos apenas as funções mais usuais (Tabela 3), que estão presentes em todos os bancos de dados. Os exemplos de utilização estão a seguir.

Exemplos de utilização de funções

Seleciona a maior, a menor e a média da primeira nota:

SELECT MAX(NOTA1), MIN(NOTA1), AVG(NOTA1)

FROM ALUNO_CURSO

Conta quantos alunos não tiveram a segunda nota informada:

SELECT COUNT(*) FROM ALUNO_CURSO

WHERE NOTA2 IS NULL

Lista todos os alunos, mostrando o nome em letras maiúsculas:

SELECT UPPER(NOME) FROM ALUNO

Operadores Lógicos

Além dos operadores lógicos mais conhecidos: igual a (=), maior que (>), maior ou igual que (>=), menor que (<) e menor ou igual que (<=), existem outros que podem ser usados para restringir os dados na cláusula where, os mais usados estão na Tabela 4.

Todos os operadores listados na tabela podem ainda ser combinados com o operador Not, que nega o resultado da condição. Por exemplo, NOTA2 IS NULL traria somente os registros onde a coluna Nota2 não estivesse preenchida, NOTA2 IS NOT NULLl faria o contrário. Exemplo:

SELECT A.NOME

FROM ALUNO_CURSO AC, ALUNO A

WHERE

  AC.ID_ALUNO = A.ID_ALUNO AND

  AC.NOTA2 IS NULL

Operador IN

Verifica se o valor de uma coluna está presente em um conjunto de valores. Para selecionar os alunos que fizeram o curso de Delphi ou de Firebird, por exemplo, usaríamos o seguinte código:

SELECT A.NOME

FROM ALUNO_CURSO AC, ALUNO A

WHERE

  AC.ID_ALUNO = A.ID_ALUNO AND

  AC.ID_CURSO IN (1,2)

Operador BETWEEN

Seleciona apenas os registros cujos valores estão entre dois outros indicados. Para recuperar todos os alunos cujo número de faltas esteja entre 2 e 4, por exemplo, utilizaríamos o seguinte código:

SELECT A.NOME, AC.NR_FALTAS

FROM ALUNO_CURSO AC, ALUNO A

WHERE

  AC.ID_ALUNO = A.ID_ALUNO AND

  AC.NR_FALTAS BETWEEN 2 AND 4

Operador LIKE

Permite a busca por parte de uma string. Possui um papel muito importante, já que é comum o usuário buscar um texto sabendo apenas parte dele. Com o LIKE é possível localizar um texto independentemente da posição que se encontra, isso é feito com o uso de dois caracteres especiais:

• % (percent): chamado de coringa, representa qualquer quantidade de caracteres. Significa que admite em seu lugar um caractere, um conjunto de caracteres ou nenhum caractere;
• _ (underline): Indica que pode existir qualquer caractere na posição desejada.

A Listagem 2 mostra uma série de exemplos do uso do LIKE e %.Vale lembrar que, embora o operador LIKE possua recursos extremamente avançados e úteis, seu uso deve ser controlado, pois se ele for usado no começo ou no meio da expressão o gerenciador do banco de dados não utilizará índice para realizar a pesquisa, o que pode tornar a mesma demorada quando a tabela possuir um número muito grande de registros.

Exemplos de utilização do operador LIKE

Alunos que contenham no nome a palavra 'SARTURI' em qualquer parte do nome:

SELECT NOME FROM ALUNO

WHERE UPPER(NOME) LIKE '%SARTURI%'

Alunos cujo nome não comece com a letra 'P':

SELECT NOME FROM ALUNO

WHERE UPPER(NOME) NOT LIKE 'P%'

Alunos cujos nomes terminam com a palavra 'SANTOS':

SELECT NOME FROM ALUNO

WHERE UPPER(NOME) LIKE '%SANTOS'

Conclusões

Começamos a ver neste artigo os comandos que fazem parte da DML, foram apresentados os comandos INSERT, UPDATE e DELETE. Também apresentamos o comando SELECT, entretanto, por questões de espaço, não é possível mostrar em um único artigo tudo o que ele pode fazer. Na próxima edição veremos outros comandos de seleção avançados, como: GROUP BY, HAVING e o uso de SUBSELECT. Além disso, conforme já comentado, mostraremos como realizar a junção de tabelas com o comando Inner Join.