Certo, nesse artigo vamos ver os conceitos básicos necessários para você escrever as suas primeiras queries em SQL.
Se você tem duvidas ainda do que é SQL eu recomendo você ler esse artigo primeiro.
Vamos começar pelo mais básico e simples, SQL SELECT.
Essa comando é utilizado para selecionar dados de um banco de dados. Olha o exemplo abaixo.
SELECT coluna1, coluna2, ...
FROM nome_tabela;
Nós podemos traduzir isso como: “Selecione as colunas ‘coluna1’ e ‘coluna2’ da tabela ‘nome_tabela’;
Aqui, coluna1, coluna2, devem ser os nomes dos campos da tabela da qual você deseja selecionar os dados. Se você quiser selecionar todos os campos disponíveis na tabela, use a seguinte sintaxe:
SELECT * FROM nome_tabela;
Assim que você executa esse comando, os dados retornados são armazenados em uma tabela de resultados, chamada de conjunto de resultados.
Eu acho que da para mostrar melhor com um exemplo. Vamos então criar uma tabela para praticar.
A tabela que vamos usar será essa. Tabela “clientes”
| id | nome | endereco | cidade | pais |
|---|---|---|---|---|
| 1 | Rodrigo Nascimento | Berguvsvägen 8 | Berlin | Alemanha |
| 2 | Marcio Moreno | Av. Brasil 222 | Rio de Janeiro | Brasil |
| 3 | Antonio Pereira | Av. Paulista 321 | São Paulo | Brasil |
| 4 | Clovis Oliveira | P. Sherman 42, Wallaby Way | Sydney | Australia |
| 5 | Helder Santos | 120 Hanover Sq. | Brisbane | Australia |
A seguinte instrução SQL seleciona as colunas “nome” e “cidade” da tabela “clientes”:
SELECT nome, cidade FROM clientes;
E o seu conjunto de resultados deve ser parecido com esse:
| id | nome | cidade |
|---|---|---|
| 1 | Rodrigo Nascimento | Berlin |
| 2 | Marcio Moreno | Rio de Janeiro |
| 3 | Antonio Pereira | São Paulo |
| 4 | Clovis Oliveira | Sydney |
| 5 | Helder Santos | Brisbane |
Como acabamos de ver, com o SELECT você consegue filtrar as colunas, certo? Agora digamos que você queira filtrar alguns dos elementos em cada linha.
Por exemplo, você quer saber quais são os clientes que moram no Brasil ou na Australia. Usando apenas SELECT isso não é possível.
Para isso nós precisamos do WHERE.
A cláusula SQL WHERE é usada para especificar uma condição quando se vai buscar os dados de uma única tabela ou unindo com várias tabelas.
Se a condição dada for satisfeita, ela retorna todos os registros que batem com essa condição.
O objetivo é usar a cláusula WHERE para filtrar os registros e buscar somente os registros necessários.
Para o exemplo acima, poderíamos escrever uma query assim:
SELECT nome, cidade FROM clientes WHERE pais = 'Brasil';
| id | nome | cidade |
|---|---|---|
| 2 | Marcio Moreno | Rio de Janeiro |
| 3 | Antonio Pereira | São Paulo |
Ok, um coisa que você precisa ter em mente, SQL requer aspas simples em torno de valores de texto como no ‘Brasil’ aí em cima (a maioria dos SGBD também vão aceitar aspas duplas).
Entretanto, para campos numéricos não se deve colocar entre aspas:
// Errado
SELECT nome, cidade FROM clientes WHERE id = '1';
//Correto
SELECT nome, cidade FROM clientes WHERE id = 1;
Nada mais conveniente que dar continuidade a essa lista com o operador LIKE, pois ele é usado em uma cláusula WHERE para procurar um padrão especificado em uma coluna.
Já sei, melhor com exemplo né?
Digamos que precisamos atualizar o endereço dos clientes no nosso banco de dados.
Precisamos trocar todo Cliente que tem no endereço a abreviação “Av” para “Avenida”, para ajudar na logística de entregas.
Mais antes dessa atualização o gerente precisa ver quantos clientes serão afetados com esse alteração.
Como “Avenida” ou “Av” não são colunas da nossa tabela, não temos como usar apenas o WHERE.
Para isso precisamos usar o LIKE, a query fica assim:
SELECT nome, endereco FROM clientes
WHERE endereco LIKE 'Av%';
| id | nome | endereco |
|---|---|---|
| 2 | Marcio Moreno | Av. Brasil 222 |
| 3 | Antonio Pereira | Av. Paulista 321 |
Você deve estar se perguntando o que diabos esse “%” ta fazendo ali, ou que eu cometi algum erro de digitação, mas não, ta tudo certinho.
Existem dois wildcards (coringas) frequentemente usados em conjunto com o operador LIKE:
Existem muitas possíveis combinações, mas vou listar aquelas que considero as mais importantes.
| Operador LIKE | Descrição |
|---|---|
| WHERE coluna LIKE ‘a%’ | Encontre quaisquer valores que comecem com “a”. |
| WHERE coluna LIKE ‘%a’ | Encontre quaisquer valores que terminam com “a”. |
| WHERE coluna LIKE ‘%or%’ | Encontre quaisquer valores que tenham “ou” em qualquer posição |
| WHERE coluna LIKE ‘_r%’ | Encontre quaisquer valores que tenham “r” na segunda posição |
| WHERE coluna LIKE ‘a_%’ | Encontre quaisquer valores que comecem com “a” e tenham pelo menos 2 caracteres de comprimento |
| WHERE coluna LIKE ‘a__%’ | Encontre quaisquer valores que comecem com “a” e tenham pelo menos 3 caracteres de comprimento |
| WHERE coluna LIKE ‘a%o’ | Encontra quaisquer valores que começam com “a” e terminam com “o”. |
Então no nosso exemplo, estou usando o primeiro comando dessa tabela. E ele deve me retornar os clientes com id = 2 e id = 3.
Mas se quiser, você pode ser bem especifico, e usar o LIKE sem nenhum coringa. Assim:
SELECT * FROM clientes
WHERE endereco LIKE 'Av. Brazil 222';
SELECT * FROM clientes
WHERE endereco LIKE 'Av. Paulista 321';
Ainda podemos dar um upgrade nessa query, ao invés de executar duas, podemos executar apenas um query que vai resolver nosso problemas. Os nossos próximos operadores estão aqui pra isso.
Agora podemos combinar cláusula WHERE com os operadores AND, OR, e NOT, e dar uma simplificada na querry.
E para deixar claro, o AND e OR são usados para filtrar registros com base em mais de uma condição, exatamente como nosso exemplo acima.
E o NOT para negar uma condição, ou seja, qualquer coisa que NÃO seja igual a condição.
Usando esses operadores, você vai escrever suas queries usando essa sintaxe:
//AND
SELECT coluna1, coluna2, ...
FROM nome_tabela
WHERE condicao1 AND condicao2 AND condicao3 ...;
//OR
SELECT coluna1, coluna2, ...
FROM nome_tabela
WHERE condicao1 OR condicao2 OR condicao3 ...;
//NOT
SELECT coluna1, coluna2, ...
FROM nome_tabela
WHERE NOT condicao;
Na tabela abaixo tem uma breve descrição do que cada operador faz.
| Operador | Descrição |
|---|---|
| AND | Exibe um registro se todas as condições separadas por AND forem VERDADEIRAS. |
| OR | Exibe um registro se qualquer uma das condições separadas por OR for VERDADEIRA. |
| NOT | Exibe um registro se a(s) condição(ões) NÃO for(em) VERDADEIRA(s). |
Então, como disse antes, podemos simplificar a query do nosso ultima exemplo, ao invés de usar duas queries separadas, podemos escrever apenas uma, usando um dos operadores acima, nesse caso, vamos usar o OR.
Depois de simplificar nossa query o resultado é esse:
SELECT nome, endereco FROM clientes
WHERE (endereco LIKE 'Av. Brazil 222' or endereco LIKE 'Av. Paulista 321');
| id | nome | endereco |
|---|---|---|
| 2 | Marcio Moreno | Av. Brasil 222 |
| 3 | Antonio Pereira | Av. Paulista 321 |
Agora já temos dois métodos para para selecionar e visualizar os dados. Mas geralmente queremos fazer alguma coisa com esses dados certo?
Por exemplo, digamos que um dos nossos clientes se mudou de cidade ou talvez até de país, então os campos “endereco”, “cidade” e “pais” vão mudar, e precisamos atualizar o registro desse cidadão. Como fazer?
Bom, o primeiro passo é selecionar o Cliente que está se mudando, certo? E isso já sabemos como fazer, usando SELECT e WHERE.
Mas agora vamos usar o método UPDATE, para fazer exatamente a mesma coisa, com um extra step, vamos atualizar os valores ao mesmo tempo. Assim:
UPDATE clientes
SET cidade = 'Paris', pais= 'Franca', endereco = '60 rue La Boétie'
WHERE id = 1;
| id | nome | endereco | cidade | pais |
|---|---|---|---|---|
| 1 | Rodrigo Nascimento | 60 rue La Boétie | Paris | Franca |
Aqui temos no lugar do SELECT o comando UPDATE. E logo depois temos a linha com o comando(ou palavra chave) SET, é usado com o comando UPDATE para especificar quais colunas e valores devem ser atualizados em uma tabela.
Então, o que estamos fazendo aqui é simples, vamos traduzir esse comando.
“Atualize dentro da tabela ‘clientes’ a ‘cidade’, ‘pais’ e ‘endereco’ do cliente cujo o id é igual 1”.
Simples, não? Acabamos de enviar o Rodrigo pra França.
Agora, atenção!
Tenha cuidado ao atualizar os registros em uma tabela! Observe o comando WHERE na declaração UPDATE. A cláusula WHERE especifica que registro(s) deve(m) ser atualizado(s). Se você omitir a cláusula WHERE, todos os registros da tabela serão atualizados!
Todo mundo, uma vez ou outra na vida faz uma pequena 💩 certo?
No caso do banco de dados, se você guardou um registro que não deveria no banco, e precisa remover, esse é o método que você vai usar.
Vamos imaginar esse cenário, que o cliente Clovis não queira mais fazer parte do nosso clube de clientes. Pela politica da empresa, todos os dados daquele cliente precisam ser apagados.
Essa é a deixa para o usar o DELETE.
No exemplo, isso ficaria assim:
DELETE FROM clientes WHERE nome='Clovis Oliveira';
| id | nome | endereco | cidade | pais |
|---|---|---|---|---|
| 1 | Rodrigo Nascimento | Berguvsvägen 8 | Berlin | Alemanha |
| 2 | Marcio Moreno | Av. Brasil 222 | Rio de Janeiro | Brasil |
| 3 | Antonio Pereira | Av. Paulista 321 | São Paulo | Brasil |
| 5 | Helder Santos | 120 Hanover Sq. | Brisbane | Australia |
E é isso, aquela linha será completamente apagada do banco de dados.
Mas atenção!
Se você não fornecer um WHERE na cláusula com DELETE, os dados da tabela inteira serão excluídos!
!!! ISSO IRÁ APAGAR TODOS OS DADOS DESSA TABELA !!!
DELETE from clientes;
Só rode esse comando se você tiver certeza do que está fazendo. De preferência somente o faça em um banco de dados de teste.
Structured Query Language (SQL) é uma linguagem de programação que é usada em banco de dados relacional. E por “relacional” quero dizer que dados entre tabelas tem algum tipo de relação entre si. E para tratar muitos desses casos, os comandos que vimos até aqui são insuficientes. Vamos expandir nosso vocabulário SQL com JOINS.
Sem duvida uma das cláusulas SQL mais importantes, Vamos entender o que ele faz e como funciona.
A cláusula JOIN é usada para combinar linhas de duas ou mais tabelas, com base em uma coluna relacionada entre elas.
Ok, para explicar melhor o que esse comando faz, vamos precisar de alguns exemplos.
Para esses exemplos vamos precisar de uma segunda tabela, que vamos chamar de “pedidos”.
| ID | cliente_id | valor_total | vencimento |
|---|---|---|---|
| 1 | 2 | R$ 342 | 12/08/2022 |
| 2 | 4 | R$ 629 | 04/11/2022 |
Observe que a coluna “cliente_id” na tabela “pedidos” se refere ao “id” na tabela “clientes”.
Daí podemos extrair a nossa relação, porque quando falamos de um cliente queremos saber se ele tem algum pedido, e quando olhamos para a lista de pedidos, precisamos saber de quem aquele pedido pertence.
O JOIN resolve esse problema pra gente, e o resultado você confere na tabela abaixo.
SELECT pedidos.valor_total, pedidos.vencimento, clientes.nome
FROM pedidos
INNER JOIN clientes ON pedidos.cliente_id=clientes.id;
| valor_total | vencimento | nome |
|---|---|---|
| R$ 342 | 12/08/2022 | Marcio Moreno |
| R$ 629 | 04/11/2022 | Clovis Oliveira |
Ok, não é a mais simples das queries, mas é fácil de entender. Vamos traduzir isso para bom português.
“Selecione as colunas “valor_total” e “vencimento” na tabela “pedidos” e a coluna “nome” na tabela “clientes” da tabela “pedidos” fazendo união com a tabela “clientes” onde a coluna “cliente_id” na tabela “pedidos” for igual ao “id” na tabela “clientes””.
Ainda confuso? Vamos separar por partes, pra ver se ajuda.
A primeira parte já vimos no exemplo do SELECT. Bem similar
Selecione as colunas “valor_total” e “vencimento” na tabela “pedidos” e a coluna “nome” na tabela “clientes” da tabela “pedidos”.
SELECT pedidos.valor_total, pedidos.vencimento, clientes.nome
FROM pedidos
Certo, temos duas coisa a pontuar aqui, uma é que estamos usando “pedidos.valor_total” ao invés de apenas “valor_total”. a outra é que temos “clientes.nome” que não tem nada a ver com a tabela pedidos.
Essa é a magica do comando JOIN, ele te ajuda a unir colunas de várias tabelas em um único resultado.
Temos as colunas “vencimento” e “valor_total” que estão vindo da tabela pedido e “nome” que está vindo da tabela “clientes”, por isso precisamos especificar de onde cada dado está vindo.
Fazemos isso usando a notação: tabela.coluna
Agora a novidade é a segunda parte:
INNER JOIN clientes ON pedidos.cliente_id=clientes.id;
Que se traduz como algo do tipo:
Faça união com a tabela “clientes” onde a coluna “cliente_id” na tabela “pedidos” for igual ao “id” na tabela “clientes””.
O resumo então, quando “cliente.id” e “pedido.cliente_id”coincidirem, me mostre essas três colunas pedidos.vencimento, pedidos.valor_total, clientes.nome.
Um INNER JOIN nada mais é do que uma união, você provavelmente viu isso na escola, se não fugiu das aulas de matemática. Era aquela aula que falavam dos Diagramas de Venn. Aqui vai uma imagem para ajudar.
| Tipo | Descrição |
|---|---|
| (INNER) JOIN | Retorna registros que têm valores correspondentes em ambas as tabelas |
| LEFT (OUTER) JOIN | Retorna todos os registros da tabela da esquerda, e os registros combinados da tabela da direita |
| RIGHT (OUTER) JOIN | Retorna todos os registros da tabela da direita, e os registros combinados da tabela da esquerda |
| FULL (OUTER) JOIN | Retorna todos os registros quando há uma correspondência na tabela da esquerda ou da direita |
Pela tabela acima, você vê que temos vários tipos de JOINS, o que estamos usando nesse exemplo é o INNER JOIN, mas poderíamos ter usado qualquer um dos outros, se eles resolvessem o nosso problema.
Dê uma lida na descrição de cada método e tente entender o que cada um faz.
E é isso. Acredito que quem quer dar o ponta pé inicial com SQL, esses métodos e cláusulas já são um bom começo, sem duvidas. Deixe um comentário se ficou faltando alguma coisa, eu leio todos, juro.
Se você quiser praticar um pouco do que aprendeu, da uma olhada nesse link, você pode testar as queries com um banco de dados de verdade, é bem legal.
Até a próxima!
Deixe um comentário