A melhor parte de analisar os dados é quando vou entrevistar os dados (obter informações). É nessa etapa que descobrimos se os dados estão completos, se existe algum dado que não é necessário e, acima de tudo, que tipo de informações podemos obter com esses dados. Uma maneira de pensar nessa etapa é como se ela você uma entrevista de emprego. Você deve fazer perguntas que vão lhe dar as informações para contratar essa pessoa e onde ela será mais produtiva. Do mesmo modo você deve fazer com os dados: Esses dados me serão útil? Onde?
A entrevista é importante porque você obtém informações. Por exemplo, numa entrevista de emprego você descobre que metade dos entrevistados não colocou o nome do pai ou não informou um endereço de e-mail. Na entrevista você pode descobrir se os seus dados estão incorretos: nomes trocados, faltando letras, data no formato errado, entre outras coisas. Esse tipo de informação se torna parte dos dados.
Na linguagem SQL, começamos a entrevista com a declaração SELECT. Essa declaração é utilizada para recuperar informações de linhas e colunas nos bancos de dados. A instrução SELECT pode ser simples, retornando toda a informação sem nenhum filtro, ou pode ser complexa, retornando dezenas de tabelas e aplicando filtros e cálculos.
Nesse tutorial vamos começar com instruções SELECT simples.
Sintaxe básica da declaração SELECT
Nesse exemplo, vamos selecionar todas as linhas e colunas da tabela funcionarios. Essa coluna está no banco de dados que criamos no último tutorial. É importante ter um banco de dados selecionado antes de clamar a instrução SELECT. Você pode notar o banco de dados selecionado entre colchetes.
MariaDB [(none)]> USE meu_banco_de_dados;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Database changed
MariaDB [meu_banco_de_dados]> SELECT * FROM funcionarios;
+------+---------+----------+-------------------+-------------+---------+
| id | p_nome | u_nome | profissao | data_inicio | salario |
+------+---------+----------+-------------------+-------------+---------+
| 0 | Eveline | Ferreira | Vendedor | 2018-02-03 | 3400 |
| 1 | Osvaldo | Perreira | Vendedor | 2018-03-03 | 3400 |
| 2 | Maria | Saturno | Gerente de vendas | 2018-01-01 | 8500 |
| 3 | Mariana | Reis | Diretor | 2018-01-01 | 5000 |
| 4 | Marisa | Lima | Gerente | 2019-03-01 | 9000 |
+------+---------+----------+-------------------+-------------+---------+
5 rows in set (0.001 sec)
Esse exemplo mostra a forma mais básica de selecionar dados com a linguagem SQL. Utilizamos o asterisco, depois da declaração SELECT, como um curinga. O curinga é utilizado no lugar de um valor especifico. O asterisco assume o valor de todos os valores possíveis. A instrução utilizada nesse exemplo é uma forma de dizer: 'selecione todas as colunas da tabela funcionarios'. Se você passar o nome de uma coluna, no lugar do asterisco, apenas os valores dessa coluna serão apresentados. A declaração FROM indica onde a declaração SELECT deve procurar os dados. O ponto e vírgula é utilizado para sinalizar o fim da instrução.
Consultando um conjunto de colunas
O asterisco é utilizado para descobrir todo o conteúdo de uma tabela. Com grandes bancos de dados é mais prático limitar o número de coluna que a declaração deve retornar. Você pode não ter interesse nos dados sobre id ou data de entrada, você pode estar procurando informações sobre profissão e salário. Podemos definir os dados que temos interesse passando os nomes das colunas separados por vírgula depois da declaração SELECT. Veja um exemplo:
MariaDB [meu_banco_de_dados]> SELECT salario, profissao, p_nome FROM funcionarios;
+---------+-------------------+---------+
| salario | profissao | p_nome |
+---------+-------------------+---------+
| 3400 | Vendedor | Eveline |
| 3400 | Vendedor | Osvaldo |
| 8500 | Gerente de vendas | Maria |
| 5000 | Diretor | Mariana |
| 9000 | Gerente | Marisa |
+---------+-------------------+---------+
5 rows in set (0.001 sec)
Note que os dados foram retornados na ordem em que passamos os nomes das colunas. Primeiro o salário, depois a profissão e por último o nome.
Mesmos esses exemplos básicos, mostram uma boa estrategia para iniciar a analise de dados. É uma prática comum verificar se todos os dados estão presentes e no formato certo. As datas estão completas? Dia, mês e ano? Ou só o mês e o ano? Existem nomes começando, misteriosamente, com a letra C? Esses são alguns problemas que você pode achar nessa "entrevista".
Nesse exemplo, utilizamos um banco de dados com poucas linhas, mas quando você se deparar com um banco de dados, com centenas ou milhares de linhas, é preciso fazer uma analise rápida da quantidade e qualidade dos dados. Vamos fazer isso com mais algumas declarações do SQL.
Selecionando valores únicos com a declaração DISTINCT
É muito comum encontrar colunas com valores duplicados. Na coluna profissao temos algumas linhas com o valor vendedor. Isso porque uma empresa pode ter vários vendedores. Se você precisar saber quais profissões estão presentes na tabela profissao, podemos fazer uma consulta que vai retornar apenas valores únicos, eliminando os valores duplicados com a declaração DISTINCT (os valores não serão mostrados, mais continuam na tabela).
MariaDB [meu_banco_de_dados]> SELECT DISTINCT profissao
-> FROM funcionarios;
+-------------------+
| profissao |
+-------------------+
| Vendedor |
| Gerente de vendas |
| Diretor |
| Gerente |
+-------------------+
4 rows in set (0.001 sec)
Mesmo a tabela funcionarios tendo cinco linhas, essa instrução nos mostro apenas quatro. Isso porque o valor Vendedor aparece mais de uma vez e a declaração DISTINCT nos mostra apenas valores únicos. Essa declaração é útil para analisar a quantidade e a qualidade dos dados. Com ela podemos saber o quanto de dados vamos analisar e quantos desses dados estão numa boa qualidade. Por exemplo, com a declaração DISTINCT podemos saber se existem dados escrito de forma de forma errada, como o valor Vendedor escrito dessa forma: Cendedor.
Podemos ver os valores únicos de mais de uma coluna por vez. Para isso precisamos passar os nomes das colunas separadas por vírgula.
MariaDB [meu_banco_de_dados]> SELECT DISTINCT profissao, salario
-> FROM funcionarios;
+-------------------+---------+
| profissao | salario |
+-------------------+---------+
| Vendedor | 3400 |
| Gerente de vendas | 8500 |
| Diretor | 5000 |
| Gerente | 9000 |
+-------------------+---------+
4 rows in set (0.001 sec)
Desse modo podemos saber, por exemplo, quantos profissões tem salários diferentes. Se tiver uma pessoa que tem a mesma profissão, mas que recebe um salário diferente, será retornado o valor profissão para cada salário diferente.
Adicione uma nova linha na tabela funcionarios com o valor Vendedor e com um salário diferente de 3400 (Veja como fazer isso no tutorial anterior). Depois chame a mesma instrução do exemplo acima, o resultado deve ser parecido com esse:
MariaDB [meu_banco_de_dados]> SELECT DISTINCT profissao, salario
-> from funcionarios;
+-------------------+---------+
| profissao | salario |
+-------------------+---------+
| Vendedor | 3400 |
| Gerente de vendas | 8500 |
| Diretor | 5000 |
| Gerente | 9000 |
| Vendedor | 6500 |
+-------------------+---------+
5 rows in set (0.001 sec)
Note que agora temos dois valores Vendedor na coluna profissão, mas com os valores da coluna salário diferentes.
Ordenando dados com a declaração ORDER BY
Um maneira de encontrar algum sentido nos dados é organizando esses dados de alguma forma. Quando os dados estão organizados fica mais fácil encontrar algum padrão que não percebemos quando os dados estão misturados. Com a linguagem SQL podemos organizar os dados de uma consulta com a declaração ORDER BY seguido do nome da coluna ou das colunas.
Quando utilizamos ORDER BY numa consulta não estamos modificando a tabela, apenas os dados retornados pela consulta. Veja um exemplo de como utilizar ORDER BY:
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> ORDER BY salario DESC;
+---------+-------------------+---------+
| p_nome | profissao | salario |
+---------+-------------------+---------+
| Marisa | Gerente | 9000 |
| Maria | Gerente de vendas | 8500 |
| Fabiana | Vendedor | 6500 |
| Mariana | Diretor | 5000 |
| Eveline | Vendedor | 3400 |
| Osvaldo | Vendedor | 3400 |
+---------+-------------------+---------+
6 rows in set (0.001 sec)
Nesse exemplo, organizamos os dados de forma decrescente adicionando a palavra-chave DESC. Por padrão ORDER BY organiza os dados de forma crescente. Ordenando os valores de forma decrescente descobrimos qual é a profissão que ganha mais.
A organização nos permite fazer consultas de forma mais direta e uma maior flexibilização na hora de visualizar os dados. Um dessas flexibilidades é a capacidade de organizar mais de uma coluna.
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, data_inicio
-> FROM funcionarios
-> ORDER BY p_nome ASC, data_inicio DESC;
+---------+-------------------+-------------+
| p_nome | profissao | data_inicio |
+---------+-------------------+-------------+
| Eveline | Vendedor | 2018-02-03 |
| Fabiana | Vendedor | 2019-03-20 |
| Maria | Gerente de vendas | 2018-01-01 |
| Mariana | Diretor | 2018-01-01 |
| Marisa | Gerente | 2019-03-01 |
| Osvaldo | Vendedor | 2018-03-03 |
+---------+-------------------+-------------+
6 rows in set (0.001 sec)
Nesse exemplo, organizamos a coluna p_nome de forma crescente (ordem alfabética) e, a coluna data_inicio, de forma decrescente. Mas se a coluna data_inicio esta organizada de forma decrescente porque a data 2019-03-20 não está no topo? Porque a prioridade é a coluna p_nome. Primeiro os resultados são organizados por nomes e depois por data, criando subgrupos de organização.
Com esse exemplo, podemos obter a resposta para o tipo de pergunta: “Qual é a pessoa, que o nome começa com F, que está na empresa a mais tempo?”. Esse é um exemplo bobo, mas com os dados certos essa informação é muito importante.
Filtrando linhas com WHERE
Com um banco de dados grande você vai precisar limitar os resultados de uma consulta. Talvez você queira apenas os resultados que satisfaça algumas condições. Por exemplo, as profissões que ganham mais de três mil ou o nome das pessoas que trabalham como vendedor. Para limitar os resultados com condições que os dados devem ter usamos a declaração WHERE.
A declaração WHERE é utilizada para encontrar dados que correspondam a um valor especifico ou satisfação uma condição. Utilizando WHERE você pode excluir linhas com base em condições.
A declaração WHERE vem depois da declaração FROM e do nome da tabela onde vamos fazer uma consulta. Veja um exemplo:
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE profissao = 'Vendedor';
+---------+-----------+---------+
| p_nome | profissao | salario |
+---------+-----------+---------+
| Eveline | Vendedor | 3400 |
| Osvaldo | Vendedor | 3400 |
| Fabiana | Vendedor | 6500 |
+---------+-----------+---------+
3 rows in set (0.003 sec)
Nesse exemplo, fizemos uma consulta nas colunas p_nome, profissao e salario da tabela funcionarios e definimos que queremos ver apenas as linhas onde o valor da coluna profissao é igual a Vendedor. No exemplo acima, utilizamos apenas o operador igual, mas a linguagem SQL tem suporte a outros operadores. Veja a lista dos operadores suportados pela linguagem SQL:
| Operador |
Função |
Exemplo |
| = |
Igual |
WHERE profissao = ‘Vendedor’ |
| <> |
Diferente |
WHERE profissao <> ‘Vendedor’ |
| > |
Maior que |
WHERE salario > 3000 |
| < |
Menor que |
WHERE salario < 6000 |
| >= |
Maior ou igual |
WHERE salario >= 6500 |
| <= |
Menor ou igual |
WHERE salario <= 6500 |
| BETWEEN |
Entre x e y |
WHERE salario BETWEEN 6000 AND 9000 |
| IN |
Corresponde a um dos
elementos passados |
WHERE profissao IN (‘Vendedor’, 'Gerente de vendas') |
| LIKE |
Corresponde a um padrão
(Case sensitive)
|
WHERE p_nome LIKE ‘Mar%’ |
| NOT |
Nega uma condição |
WHERE p_nome NOT ILIKE ‘mar%’ |
Agora que já sabemos quais operadores podemos usar, vamos utilizar cada operador num exemplo. Vamos começar com o operador igual. Vamos selecionar todas as linhas com o valor da coluna salario igual a 3400.
MariaDB [meu_banco_de_dados]> SELECT u_nome, profissao, salario
-> FROM funcionarios
-> WHERE salario = 3400;
+----------+-----------+---------+
| u_nome | profissao | salario |
+----------+-----------+---------+
| Ferreira | Vendedor | 3400 |
| Perreira | Vendedor | 3400 |
+----------+-----------+---------+
2 rows in set (0.001 sec)
Para o nosso próximo exemplo, vamos selecionar todas as linhas que tenham um valor diferente de Vendedor na coluna profissao.
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE profissao <> 'Vendedor';
+---------+-------------------+---------+
| p_nome | profissao | salario |
+---------+-------------------+---------+
| Maria | Gerente de vendas | 8500 |
| Mariana | Diretor | 5000 |
| Marisa | Gerente | 9000 |
+---------+-------------------+---------+
3 rows in set (0.001 sec)
No exemplo abaixo, vamos usar os operadores >, <, >=, <=.
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE salario > 4000;
+---------+-------------------+---------+
| p_nome | profissao | salario |
+---------+-------------------+---------+
| Maria | Gerente de vendas | 8500 |
| Mariana | Diretor | 5000 |
| Marisa | Gerente | 9000 |
| Fabiana | Vendedor | 6500 |
+---------+-------------------+---------+
4 rows in set (0.001 sec)
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE salario < 7000;
+---------+-----------+---------+
| p_nome | profissao | salario |
+---------+-----------+---------+
| Eveline | Vendedor | 3400 |
| Osvaldo | Vendedor | 3400 |
| Mariana | Diretor | 5000 |
| Fabiana | Vendedor | 6500 |
+---------+-----------+---------+
4 rows in set (0.001 sec)
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE salario >= 3400;
+---------+-------------------+---------+
| p_nome | profissao | salario |
+---------+-------------------+---------+
| Eveline | Vendedor | 3400 |
| Osvaldo | Vendedor | 3400 |
| Maria | Gerente de vendas | 8500 |
| Mariana | Diretor | 5000 |
| Marisa | Gerente | 9000 |
| Fabiana | Vendedor | 6500 |
+---------+-------------------+---------+
6 rows in set (0.001 sec)
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE salario <= 9000;
+---------+-------------------+---------+
| p_nome | profissao | salario |
+---------+-------------------+---------+
| Eveline | Vendedor | 3400 |
| Osvaldo | Vendedor | 3400 |
| Maria | Gerente de vendas | 8500 |
| Mariana | Diretor | 5000 |
| Marisa | Gerente | 9000 |
| Fabiana | Vendedor | 6500 |
+---------+-------------------+---------+
6 rows in set (0.001 sec)
Para o nosso próximo exemplo vamos selecionar todas as linhas que o valor da coluna salario esteja entre 3500 e 8900.
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE salario BETWEEN 3500 AND 8900;
+---------+-------------------+---------+
| p_nome | profissao | salario |
+---------+-------------------+---------+
| Maria | Gerente de vendas | 8500 |
| Mariana | Diretor | 5000 |
| Fabiana | Vendedor | 6500 |
+---------+-------------------+---------+
3 rows in set (0.004 sec)
Com operador IN você pode passar um conjunto de valores para a declaração WHERE. Desse modo a declaração WHERE vai fazer mais de uma verificação por dado. Por exemplo, você pode querer selecionar as linhas que tenham os valores 'Vendedor' ou 'Gerente' na coluna profissao. Veja o exemplo disso:
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE profissao IN ('Gerente', 'Vendedor');
+---------+-----------+---------+
| p_nome | profissao | salario |
+---------+-----------+---------+
| Eveline | Vendedor | 3400 |
| Osvaldo | Vendedor | 3400 |
| Marisa | Gerente | 9000 |
| Fabiana | Vendedor | 6500 |
+---------+-----------+---------+
4 rows in set (0.001 sec)
Usando o operador LIKE
Para o nosso próximo exemplo vamos utilizar o operador LIKE. Esse operador vai selecionar dados que começam com a string que passamos para o operador. É importante notar que o operador LIKE diferencia letras maiúsculas de minusculas, então Mar e mar são diferentes.
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE p_nome LIKE 'Mar%';
+---------+-------------------+---------+
| p_nome | profissao | salario |
+---------+-------------------+---------+
| Maria | Gerente de vendas | 8500 |
| Mariana | Diretor | 5000 |
| Marisa | Gerente | 9000 |
+---------+-------------------+---------+
3 rows in set (0.001 sec)
O sinal de porcentagem (%) no final da string é utilizado para sinalizar que queremos qualquer valor que comece com 'Mar' não importa o tamanho que esse valor tenha. Esse caractere também pode ser utilizado para selecionar valores com um final de string em comum. Por exemplo, na coluna p_nome existem dois nomes que terminam com ‘ana’ no final, Fabiana e Mariana. Para selecionar as linhas que tenham esses valores passaríamos a string ‘%ana’ para o operador LIKE.
Outro carácter utilizado é o underline (_). Esse caractere é usado para sinalizar que queremos os valores com apenas um carácter a mais dos que já passamos. Por exemplo, passando ‘Marian_’ para o operador LIKE, o operador vai retornar todos os valores que comecem com ‘Marian’ e tenham um carácter a mais. Esse carácter pode ser qualquer um, pode ser um a, um b ou c. Se começar com ‘Marian’ e tiver somente mais um carácter o valor será selecionado pelo operador. E o underline pode ser usado no meio da palavra.
Veja outros exemplos de utilização dos caracteres de porcentagem e underline:
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE p_nome LIKE '%ana';
+---------+-----------+---------+
| p_nome | profissao | salario |
+---------+-----------+---------+
| Mariana | Diretor | 5000 |
| Fabiana | Vendedor | 6500 |
+---------+-----------+---------+
2 rows in set (0.000 sec)
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE p_nome LIKE '%ia%';
+---------+-------------------+---------+
| p_nome | profissao | salario |
+---------+-------------------+---------+
| Maria | Gerente de vendas | 8500 |
| Mariana | Diretor | 5000 |
| Fabiana | Vendedor | 6500 |
+---------+-------------------+---------+
3 rows in set (0.001 sec)
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE p_nome LIKE 'Marian_';
+---------+-----------+---------+
| p_nome | profissao | salario |
+---------+-----------+---------+
| Mariana | Diretor | 5000 |
+---------+-----------+---------+
1 row in set (0.001 sec)
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE p_nome LIKE 'Mar_ana';
+---------+-----------+---------+
| p_nome | profissao | salario |
+---------+-----------+---------+
| Mariana | Diretor | 5000 |
+---------+-----------+---------+
1 row in set (0.001 sec)
Combinando operadores com AND ou OR
A linguagem SQL nos permite utilizar mais de um operador ao mesmo tempo. Assim podemos definir mais de uma condição para selecionar um valor. Por exemplo, você pode querer selecionar apenas os valores que tenham o valor 'Vendedor' na coluna profissao e o valor da coluna salario maior que 3400. Para isso usamos a palavra chave AND. Com ela o dado só será selecionado se atender as duas condições, ter o valor ‘Vendedor’ na coluna profissao E (AND) o valor da coluna salario maior que 3400.
A palavra-chave OR define duas condições e se qualquer uma dessas condições for satisfeita o dado é selecionado. Por exemplo, se você quiser selecionar os dados que tenham o valor ‘Vendedor’ na coluna profissao ou o valor da coluna salario seja maior que 3000, você deve usar OR.
Veja exemplos de como utilizar AND e OR:
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE profissao = 'Vendedor'
-> AND salario > 3400;
+---------+-----------+---------+
| p_nome | profissao | salario |
+---------+-----------+---------+
| Fabiana | Vendedor | 6500 |
+---------+-----------+---------+
1 row in set (0.001 sec)
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE profissao = 'Vendedor'
-> OR salario > 3000;
+---------+-------------------+---------+
| p_nome | profissao | salario |
+---------+-------------------+---------+
| Eveline | Vendedor | 3400 |
| Osvaldo | Vendedor | 3400 |
| Maria | Gerente de vendas | 8500 |
| Mariana | Diretor | 5000 |
| Marisa | Gerente | 9000 |
| Fabiana | Vendedor | 6500 |
+---------+-------------------+---------+
6 rows in set (0.001 sec)
Utilizando WHERE E ORDER BY juntos
Você já pode perceber que até as consultas mais simples nos permitem analisar os dados com precisão e flexibilidade para encontrar o que procuramos. Aprendemos a usar as palavras chaves AND e OR para definir mais de uma condição ao selecionar dados. E ainda aprendemos a utilizar a declaração WHERE e organizar os dados com a declaração ORDER BY.
Agora vamos combinar o que aprendemos nesse tutorial num exemplo. O SQL é específico quanto à ordem das palavras chaves, então siga essa ordem:
SELECT nome_colunas
FROM nome_tabelas
WHERE condição
ORDER BY nome_colunas;
Veja um exemplo utilizando os conhecimentos que você acabou de adquirir:
MariaDB [meu_banco_de_dados]> SELECT p_nome, profissao, salario
-> FROM funcionarios
-> WHERE p_nome LIKE 'Mar' OR salario > 3400
-> ORDER BY id DESC;
+---------+-------------------+---------+
| p_nome | profissao | salario |
+---------+-------------------+---------+
| Fabiana | Vendedor | 6500 |
| Marisa | Gerente | 9000 |
| Mariana | Diretor | 5000 |
| Maria | Gerente de vendas | 8500 |
+---------+-------------------+---------+
4 rows in set (0.001 sec)
Note que não selecionamos a coluna id, mas podemos utilizá-la com a declaração ORDER BY.
