SQL do zero à primeira consulta
Oi pessoal, aqui é o Gustavo do Pizza de Dados de novo com outro texto pro Data Bootcamp!
Eu sou o líder do time de ciência de dados de uma startup e até semana passada eu não sabia nada de SQL. A verdade é que eu nunca precisei usar até agora e, por isso, estava de má vontade para aprender.
Agora surgiu a necessidade e resolvi escrever esse texto pra compartilhar com vocês o básico do básico que eu aprendi com foco em pessoas que, como eu, estão de má vontade 😜.
Existem vários cursos online gratuitos e pagos, no caso de SQL não tem muito erro. Eu comecei a aprender no DataCamp, pois já estou mais acostumado com a plataforma e já pago a mensalidade deles. Esse post não visa substituir esse cursos, mas apenas chamar atenção para alguns conceitos importantes para quem está iniciando.
Por que aprender?
Usar excel e/ou csv é comum por que é muito fácil compartilhar esses dados. Mas muitas vezes os dados vão estar guardados em um banco de dados, ou vários. Por isso aprender SQL é muito importante para o trabalho de um cientista de dados.
Mas beleza, vamos simplificar ainda mais: imagine que você quer colocar aquela sua regressão linear disponível para as pessoas usarem. Você criou um modelo em que a pessoa coloca a altura e peso dela e sua regressão prevê quanto anos a pessoa vai viver. É só um exemplo simples.
Agora imagina que você vai começar a coletar dados na internet sobre a altura, peso e idade que pessoas famosas tinham ao falecer. Você pode ir colocando isso em um CSV. As informações do Marlon Brando vão acabar aparecendo em mais de um site, mas não tem problema você colocar linhas repetidas no seu CSV né? Só fazer um drop_duplicates depois que você importar ele no pandas que tá sussa.
Mas se você for colocando suas informações em um banco, você pode programar ele para não salvar informações repetidas, economizando espaço. Você pode usar SQL para garantir que se está colocando o tipo certo de informação na coluna correspondente. Por exemplo, que ele só aceite 1,90m na coluna de altura e 75kg na coluna de peso.
Depois que o seu modelo estiver em produção você vai querer:
- Calcular a acurácia do modelo com os dados reais (comparar sua previsão com a idade que as pessoas morreram de fato).
- Retreinar o modelo com os dados novos.
- Monitorar se suas hipóteses ainda são válidas (por exemplo: se a distribuição dos dados das pessoas que estão usando o modelo, condiz com a distribuição dos dados que você usou para treinar o modelo).
Para isso você precisa :
- Guardar as informações das pessoas que usaram seu modelo.
- Guardar as predições que o seu modelo fez .
E para isso é uma boa você usar um banco de dados para guardar os dados de uma forma segura e organizada. E como os dados dos nossos modelos são relacionais, talvez seja show usar SQL.
Muitas vezes você vai chegar em um lugar que já tem dados organizados em banco, então é interessante saber como extrair eles de lá da maneira mais vantajosa para o problema que você está querendo atacar.
O básico
O SQL tem algumas palavras-chave, tipo comandos. Você usa esses comandos para fazer as consultas. Os primeiros que você vai ver são SELECT e FROM. O FROM sempre vem depois mas é uma boa dica começar por ele, pois é ele que escolhe a tabela que você vai pegar os dados e o SELECT seleciona as colunas.
As palavras-chave do SQL são escritas em letras maiúsculas por convenção. As consultas vão rodar se você colocar em minúscula, mas seguir o padrão ajuda outras pessoas, e até mesmo você, a lerem seu código.
SELECT *
FROM tabela;+-----------------+-----------------+--------+------+
| artistas | idade_ao_morrer | altura | peso |
+-----------------+-----------------+--------+------+
| Marlon Brando | 80 | 175 | 120 |
| Marlon Brando | 80 | 175 | 66 |
| Natalie Portman | 37 | 160 | 50 |
+-----------------+-----------------+--------+------+Por que tem dois Marlon Brando? É por que ele mudou de peso durante a vida dele.
Eu sempre me perguntei que diabos era esse asterisco. Ele vai retornar todas as colunas da sua tabela. É show pra quando você não sabe os nomes das colunas 😉, mas cuidado que se a tabela for muito grande pode demorar bastante para retornar tudo.
Toda consulta termina com ponto e vírgula (;). Isso é essencial pois no futuro, quando você virar mestre em banco de dados, será útil ao usar consultas múltiplas (superchique).
Ponto principal
A ideia não é pegar tudo e salvar num CSV, por exemplo. O ponto principal de SQL é você fazer a consulta pegando apenas as informações que você precisa do jeito que você precisa, para evitar sobrecarregar o computador e/ou seu banco.
Por exemplo, pode ser que na sua tabela com vários artistas repetidos (tipo o Marlon Brando). Você pode pedir pra sua consulta trazer todo mundo, como no exemplo acima, OU você pode pedir pra sua consulta trazer apenas nomes únicos (evitando que você tenha que eliminar essas linhas dentro do código da sua linguagem favorita). Para isso temos a palavra-chave DISTINCT:
SELECT DISTINCT artistas
FROM tabela;+-----------------+--+
| artistas | |
+-----------------+--+
| Marlon Brando | |
| Natalie Portman | |
+-----------------+--+A consulta acima vai retornar cada artista na sua coluna de artistas sem repetições. Aproveitando que já estamos aqui, que tal contar quantos artistas temos na nossa tabela?
SELECT COUNT(DISTINCT artistas)
FROM tabela;2Você pode usar umas funções no SELECT, tipo COUNT() que calcula a quantidade, SUM() que soma os valores, MAX() que retorna o valor máximo e AVG() que tira a média. Assim você consegue evitar que ele retorne uma coluna enorme com 500 mil artistas quando você só precisava que retornasse o número 500 mil.
Quando você vai rodar uma consulta, o SQL trabalha para buscar as informações e também para mostra-la. Existem maneiras de otimizar a forma como ele busca as informações nas suas consultas, mas isso já é um pouco mais avançado. Nesse primeiro momento é interessante se preocupar em otimizar o que ele vai mostrar, para que o SQL mostre apenas o que você precise e não fique sobrecarregado (fazendo com que você tenha que esperar 10 minutos para ter o retorno).
Onde ta o WHERE?
Para treinar nosso modelo vamos pegar apenas os artistas que sabemos com que idade faleceram. Para tal vamos usar a palavra-chave WHERE:
SELECT idade_ao_morrer, altura, peso
FROM tabela
WHERE idade_ao_morrer IS NOT NULL;+-----------------+--------+------+
| idade_ao_morrer | altura | peso |
+-----------------+--------+------+
| 80 | 175 | 120 |
| 80 | 175 | 66 |
+-----------------+--------+------+A consulta acima pede para retornar uma tabela com a idade ao morrer, altura e peso de cada artista. Mas só para aqueles que tem informação da idade ao morrer preenchida.
Um detalhe importante: tudo o que você usar no WHERE você precisa pedir que apareça no SELECT. Se não o SQL nem olha para aquela coluna e não consegue filtrar.
Podemos usar algumas expressões simples no WHERE como IS NULL. A expressão “é diferente”, que no Python escrevemos como !=, é escrita como <> no SQL e é um outro exemplo de expressão simples.
Vamos agrupar com GROUP BY
Agora nós queremos saber quais artistas estão repetidos. Que tal a gente selecionar a contagem dos nomes dos artistas?
SELECT artistas, count(artistas)
FROM tabela;+---------------+----------------+
| artista | count(artistas) |
+---------------+----------------+
| Marlon Brando | 3 |
+---------------+----------------+É… saiu uma coisa meio bizarra. O que aconteceu foi que o SQL quis juntar a resposta do count (artistas) que é apenas o número 3 (temos apenas 3 artistas) com a seleção de artistas. Para isso acabou pegando só o primeiro artista e jogando o resto fora.
Se queremos uma contagem para cada artista, precisamos agrupar. Para tal vamos usar comando GROUP BY, que assim ele vai agrupar tudo da nossa consulta por artista. Assim, ele vai retornar o count (artistas) para cada artista:
SELECT artistas, count(artistas)
FROM tabela
GROUP BY artistas;+-----------------+----------------+
| artista | COUNT(artista) |
+-----------------+----------------+
| Marlon Brando | 2 |
| Natalie Portman | 1 |
+-----------------+----------------+
O que que esse HAVING tem?
Agora queremos filtrar nossa consulta anterior para que retorne apenas os artistas que aparecem mais de uma vez na nossa tabela.
Beleza, partiu usar WHERE. Mas, como vimos, o WHERE só funciona com expressões mais simples. Para usar expressões mais complexas, como o COUNT() precisamos usar o HAVING:
SELECT artistas, count(artistas)
FROM tabela
GROUP BY artistas
HAVING COUNT(artistas)>1;+-----------------+----------------+
| artista | COUNT(artista) |
+-----------------+----------------+
| Marlon Brando | 2 |
+-----------------+----------------+Mas ok, por que existe WHERE e HAVING já que eles fazem meio que a mesma coisa? Esse é um jeito do SQL te dizer que você está usando uma coisa mais pesada. WHERE é tranqs, são expressões lógicas simples que não taxam tanto o banco.
O SQL te obriga a usar HAVING com expressões mais complexas para você perceber que está inserindo regras de negócio no seu banco. Meio que um "você tem certeza disso?". Pois, à medida que modificamos o banco, podemos inserir uma Natalie Portman nova e os resultados dessa consulta vão mudar. Pode ser que seja melhor fazer isso no código da sua linguagem favorita depois de extrair os dados do banco.
Com essa pincelada inicial já é possível fazer bastante coisa com SQL. Tentei passar algumas intuições para quem está começando, que vão servir lá pra frente, quando você for o(a) mago(a) dos bancos de dados. Espero que tenha gostado!
Finalmente
E é isso aí pessoal! Esse foi mais um post em parceria com o Data Bootcamp. Em breve estará disponível em www.databootcamp.com.br novas turmas para 2019.
Também não deixe de ouvir o Pizza de Dados para saber mais sobre novas tendências da área de ciência de dados.
