Course
Exemplos e tutoriais de consultas SQL
O que é uma consulta SQL?
SQL significa Structured Query Language (Linguagemde consulta estruturada). As pessoas geralmente o pronunciam como "S-Q-L" ou "sequel". O SQL é usado em programação e foi projetado para gerenciar dados armazenados em um banco de dados usando consultas SQL.
O tipo mais comum de sistema de gerenciamento de banco de dados(DBMS) é um sistema de gerenciamento de banco de dados relacional(RDBMS), no qual armazenamos dados estruturados, ou seja, dados que incorporam relações entre entidades e variáveis. Essas entidades e variáveis são organizadas como um conjunto de tabelas com colunas e linhas. Alguns dos RDBMS mais populares são os bancos de dados MYSQL, Oracle, IBM DB2 e Microsoft SQL Server.
Os dados no RDBMS são armazenados em um objeto de banco de dados chamado tabela. Um banco de dados geralmente contém várias tabelas. Cada tabela é identificada por um nome exclusivo e contém uma coleção de entradas de dados relacionadas, estruturadas como linhas e colunas.
Uma coluna é uma entidade vertical; elas são chamadas de campos e contêm todas as informações associadas a um campo específico em uma tabela. Cada linha de uma tabela é conhecida como registro; é a entidade horizontal da tabela.
A estrutura de um banco de dados pode ser muito parecida com a do Excel. Entretanto, os bancos de dados, em geral, são mais avançados do que as planilhas do Excel. Aqui estão três razões pelas quais você poderia dizer isso:
- Os bancos de dados podem interagir com muitas outras linguagens de programação, o que dá ao programador mais poder para gerenciar e recuperar informações dos dados.
- Os bancos de dados podem processar mais dados do que as planilhas do Excel. O Excel pode lidar com até 1 milhão de linhas de dados, enquanto um banco de dados pode lidar com mais de um bilhão de linhas.
- Os bancos de dados podem ser conectados mais facilmente à Internet, permitindo que centenas de usuários e aplicativos os acessem simultaneamente.
Animado para começar a usar o SQL? O DataCamp tem um material incrível para você começar; o Learn SQL destaca as trilhas que você pode seguir para aprimorar suas habilidades em SQL!
Vamos nos aprofundar nas consultas SQL agora...
Uma consulta SQL é uma instrução criada pela combinação de vários comandos SQL. Esses comandos SQL juntos executam uma tarefa específica para acessar, gerenciar, modificar, atualizar, controlar e organizar os dados armazenados em um banco de dados e gerenciados por meio de um DBMS.
Por que usar o SQL?
O SQL é incrivelmente versátil e usado por todos, desde cientistas de dados e engenheiros até profissionais de marketing e equipes de recursos humanos - basicamente, qualquer pessoa que simplesmente queira ser mais alfabetizada em dados!
Ele não é usado apenas nos setores de tecnologia ou limitado a grandes empresas. Vários setores de todos os tamanhos o utilizam direta ou indiretamente. Por exemplo, os profissionais que trabalham nos setores financeiro e de saúde costumam usar SQL, dada a grande quantidade de dados que produzem.
Os dados são a nova commodity, e o SQL é uma ferramenta muito poderosa quando se trata de lidar e trabalhar com big data. Está se perguntando como você pode aproveitar o SQL ao máximo? Confira o tutorial do DataCamp O que você pode fazer com o SQL para ajudá-lo a responder a essa pergunta.
Como escrever consultas SQL
Antes de entrarmos na formulação da consulta propriamente dita, vamos considerar a pergunta: "Onde escrevo e executo minha consulta SQL?"
O hub Learn SQL da DataCamp pode ser um bom ponto de partida para trabalhar com SQL em uma máquina Mac ou Windows e começar a trabalhar.
Mas se você quiser simplesmente começar a aprender as linguagens nativas dos bancos de dados - SQL, pode começar com o curso Introduction to SQL do DataCamp. Este curso ensina a sintaxe em SQL compartilhada por muitos tipos de bancos de dados, como PostgreSQL, MySQL, SQL Server e Oracle. Você trabalhará com a interface SQL integrada da DataCamp e não precisará lidar com os problemas de configuração inicial de um RDBMS.
O DataCamp também tem um espaço de trabalho incrível onde você pode criar seus próprios notebooks. O Workspace é um notebook colaborativo baseado na nuvem que permite analisar dados, colaborar com sua equipe e compartilhar insights. O Workspace foi projetado para levá-lo do aprendizado à prática da ciência de dados. Com conjuntos de dados incorporados, você pode começar a analisar os dados em minutos.
Agora vamos dar uma olhada no conjunto de dados com o qual trabalharemos neste tutorial.
Começaremos com "films", uma tabela SQL que contém dados de 10 filmes.
Esses dados são apenas um pequeno subconjunto de dados do conjunto de dados IMDb Film usado no curso de Introdução ao SQL da DataCamp que mencionamos anteriormente.
título |
release_year |
orçamento |
bruto |
imdb_score |
|
1 |
O Poderoso Chefão |
1972 |
6000000 |
134821952 |
9.2 |
2 |
O Cavaleiro das Trevas |
2008 |
185000000 |
533316061 |
9 |
3 |
O Poderoso Chefão: Parte II |
1974 |
13000000 |
57300000 |
9 |
4 |
A Lista de Schindler |
1993 |
22000000 |
96067179 |
8.9 |
5 |
Pulp Fiction |
1994 |
8000000 |
107930000 |
8.9 |
6 |
O Senhor dos Anéis: O retorno do rei |
2003 |
94000000 |
377019252 |
8.9 |
7 |
Clube da Luta |
1999 |
63000000 |
37023395 |
8.8 |
8 |
Início |
2010 |
160000000 |
292568851 |
8.8 |
9 |
Guerra nas Estrelas: Episódio V - O Império Contra-Ataca |
1980 |
18000000 |
290158751 |
8.8 |
10 |
O resgate de Shawshank |
1994 |
25000000 |
28341469 |
9.3 |
A tabela "films" tem dez registros - os nomes dos filmes armazenados em 10 linhas. Os campos são as cinco colunas da tabela, que contêm as informações relacionadas ao filme.
- 'title' é o nome do filme
- 'release_year' é o ano em que o filme foi lançado
- "orçamento" é o custo de produção do filme em dólares americanos
- "bruto" é quanto o filme ganhou em dólares americanos.
- 'imdb_score' mostra as classificações produzidas a partir de votos enviados por usuários da IMDb, não por críticos de cinema.
Vamos começar o exercício com alguns comandos SQL básicos, usando-os para explorar a tabela "films" acima. Não esperamos que você execute as consultas de solução imediatamente... mas sim que as use como base para aprender alguns conceitos-chave. Portanto, não se preocupe se você ainda não tiver decidido em qual plataforma deseja executar as consultas.
Consultas SQL básicas
Lembre-se de que as palavras-chave ou os comandos SQL não diferenciam maiúsculas de minúsculas; escrever "select" é o mesmo que escrever "SELECT".
Usaremos um ponto e vírgula no final de cada instrução SQL que escrevermos. Essa é a norma em alguns sistemas de banco de dados e é feita para separar cada instrução SQL, de modo que elas possam ser executadas na mesma chamada ao servidor.
Vamos começar com uma pergunta. Q1: Quais são os filmes armazenados na tabela?
SELECT - FROM
O comando SELECT é usado para escolher os campos que você deseja ver na tabela do banco de dados. Para o Q1, você deseja o campo "title" (título).
O comando/palavra-chave FROM especifica a tabela específica no banco de dados de onde você deseja extrair os dados. Lembre-se de que um banco de dados pode consistir em várias tabelas.
Syntax: SELECT column1, column2, ... FROM table_name;
Consulta SQL: SELECT title FROM films;
Resultado:
título |
|
1 |
O Poderoso Chefão |
2 |
O Cavaleiro das Trevas |
3 |
O Poderoso Chefão: Parte II |
4 |
A Lista de Schindler |
5 |
Pulp Fiction |
6 |
O Senhor dos Anéis: O retorno do rei |
7 |
Clube da Luta |
8 |
Início |
9 |
Guerra nas Estrelas: Episódio V - O Império Contra-Ataca |
10 |
O resgate de Shawshank |
Você deve estar se perguntando: e se você nunca viu a tabela acima e não sabe os nomes das colunas a serem especificadas na instrução SELECT? Bem visto! Aprenderemos sobre o mágico '*' (asterisco) mais adiante no tutorial.
ONDE
Q2: Quais são os filmes que serão lançados em 2010?
Para essa pergunta, você deseja "filtrar" os filmes de modo a obter nomes de filmes que atendam à condição: 'release_year' é 2010.
É possível usar a cláusula "WHERE" para extrair apenas os registros que atendem a uma condição especificada.
Syntax: SELECT column1, column2, ... FROM table_name WHERE condition;
Consulta SQL: SELECT title, release_year FROM films WHERE release_year = 2010;
Resultado:
título |
release_year |
|
1 |
Início |
2010 |
Operadores na cláusula WHERE
Os operadores a seguir podem ser usados na cláusula WHERE:
Operador |
Descrição |
= |
Igual a |
> |
Maior que |
< |
Menos de |
>= |
Maior ou igual |
<= |
Menor ou igual |
<> ou != |
Não é igual. |
BETWEEN |
Entre um determinado intervalo |
LIKE |
Pesquisar um padrão que corresponda ao padrão fornecido |
IN |
Especifica vários valores possíveis |
Aritmética em SQL
Você pode realizar aritmética simples no SQL usando os símbolos matemáticos: +, -, *, /. No entanto, você só pode realizar operações entre colunas usando esses símbolos aritméticos. Você também pode usar parênteses para gerenciar a ordem das operações.
Mas não se preocupe, para operações mais complicadas, o SQL tem funções de agregação que permitem que você execute operações dentro da mesma linha. Abordaremos esse tópico mais adiante no tutorial.
Q3: Calcule o lucro obtido por cada filme na tabela "filmes".
Dica: Execute Gross - Budget e salve o resultado em uma coluna chamada "movie_profit" usando AS
Consulta SQL: SELECT title, (gross - budget) AS movie_profit FROM films
Resultado:
título |
movie_profit |
|
1 |
O Poderoso Chefão |
128821952 |
2 |
O Cavaleiro das Trevas |
348316061 |
3 |
O Poderoso Chefão: Parte II |
44300000 |
4 |
A Lista de Schindler |
74067179 |
5 |
Pulp Fiction |
99930000 |
6 |
O Senhor dos Anéis: O retorno do rei |
283019252 |
7 |
Clube da Luta |
-25976605 |
8 |
Início |
132568851 |
9 |
Guerra nas Estrelas: Episódio V - O Império Contra-Ataca |
272158751 |
10 |
O resgate de Shawshank |
3341469 |
Isenção de responsabilidade: Os cinéfilos podem estar incomodados com os lucros negativos do Clube da Luta. A fórmula usada ((bruto - orçamento) COMO lucro do filme) é muito simples e, de fato, considerando a fórmula e os dados, é o resultado correto.
Mas o exemplo acima serve para lembrá-lo de estar atento ao processo de coleta de dados! Até mesmo a simples exploração de dados pode revelar erros de dados que podem ser causados por um erro na coleta de dados ou no processo de armazenamento de dados (alteração do tipo de dados, etc.) - como pode ter sido o caso ao criar o conjunto de dados em uso.
Sempre preste atenção aos dados com os quais está trabalhando!
E, OU, NÃO
A cláusula WHERE pode ser combinada com outras cláusulas condicionais usando os operadores AND, OR e NOT. Os operadores AND e OR são usados para filtrar registros com base em mais de uma condição, e o operador NOT é usado para negar uma condição.
Vamos ver seu uso com exemplos:
Q4: Quais são os filmes que serão lançados em 2010 e têm uma classificação superior a 9?
Syntax: SELECT column1, column2, ... FROM table_name WHERE condition1 AND condition2 AND condition3 AND condition4.....;
Consulta SQL: SELECT title, release_year, imdb_score FROM films WHERE release_year = 2010 AND imdb_score >= 9;
O operador AND exibe um registro se todas as condições separadas por AND forem verdadeiras.
Na tabela "films", temos o filme "Inception". Esse é o único valor que é verdadeiro para release_year = 2010, mas é falso para imdb_score >= 9 e, portanto, não atende à condição de conjunto E. Assim, a consulta retorna um conjunto de resultados vazio.
Q5: Quais são os filmes que serão lançados em 2010 ou que têm uma classificação superior a 9?
Syntax: SELECT column1, column2, ... FROM table_name WHERE condition1 OR condition2 OR condition3 OR condition4.....;
Consulta SQL: SELECT title, release_year, imdb_score FROM films WHERE release_year = 2010 OR imdb_score >= 9;
Resultado:
título |
release_year |
imdb_score |
|
1 |
O Poderoso Chefão |
1972 |
9.2 |
2 |
O Cavaleiro das Trevas |
2008 |
9 |
3 |
O Poderoso Chefão: Parte II |
1974 |
9 |
4 |
Início |
2010 |
8.8 |
5 |
O resgate de Shawshank |
1994 |
9.3 |
O operador OR exibe um registro se qualquer uma das condições separadas por OR for VERDADEIRA.
Os filmes: O Poderoso Chefão, O Cavaleiro das Trevas, O Poderoso Chefão: Part II, The Shawshank Redemption são verdadeiras para imdb_score >= 9, enquanto Inception é verdadeira para release_year = 2010 e, portanto, fazem parte da condição OR.
Q6: Quais são os filmes que têm um ano de lançamento diferente de 2010?
Syntax: SELECT column1, column2, ... FROM table_name WHERE NOT condition1;
Consulta SQL: SELECT title, release_year FROM films WHERE NOT release_year = 2010;
Resultado:
título |
release_year |
|
1 |
O Poderoso Chefão |
1972 |
2 |
O Cavaleiro das Trevas |
2008 |
3 |
O Poderoso Chefão: Parte II |
1974 |
4 |
A Lista de Schindler |
1993 |
5 |
Pulp Fiction |
1994 |
6 |
O Senhor dos Anéis: O retorno do rei |
2003 |
7 |
Clube da Luta |
1999 |
8 |
Guerra nas Estrelas: Episódio V - O Império Contra-Ataca |
1980 |
9 |
O resgate de Shawshank |
1994 |
Você também poderia escrever: SELECT title, release_year FROM films WHERE release_year != 2010;
Isso também daria o mesmo resultado que o anterior.
Pode haver várias maneiras de obter o mesmo resultado no SQL. No entanto, algumas consultas podem ter mais desempenho do que outras. O desempenho pode depender de vários fatores: a quantidade de dados, os comandos usados na consulta, como o banco de dados está estruturado, o tipo de dados etc. Esse é um tópico um pouco mais complicado e avançado que não abordaremos neste tutorial de consulta SQL.
Mas se você estiver interessado, o curso Database Design da DataCamp se aprofunda nesses tópicos.
ORDER BY
A palavra-chave ORDER BY é usada para classificar o resultado em ordem crescente (usando a palavra-chave ASC) ou decrescente (usando a palavra-chave DESC). Por padrão, a classificação é feita em ordem crescente.
Q7: Quais são os filmes armazenados na tabela? Classifique em ordem decrescente de release_year.
Syntax: SELECT column1, column2, ... FROM table_name ORDER BY column1, column2, ... ASC|DESC;
Consulta SQL: SELECT title, release_year FROM films ORDER BY release_year DESC;
Resultado:
título |
release_year |
|
1 |
Início |
2010 |
2 |
O Cavaleiro das Trevas |
2008 |
3 |
O Senhor dos Anéis: O retorno do rei |
2003 |
4 |
Clube da Luta |
1999 |
5 |
Pulp Fiction |
1994 |
6 |
O resgate de Shawshank |
1994 |
7 |
A Lista de Schindler |
1993 |
8 |
Guerra nas Estrelas: Episódio V - O Império Contra-Ataca |
1980 |
9 |
O Poderoso Chefão: Parte II |
1974 |
10 |
O Poderoso Chefão |
1972 |
LIMIT
Às vezes, pode levar muito tempo para que o banco de dados execute sua consulta, especialmente se a quantidade de dados armazenados no banco de dados for muito grande.
Uma maneira fácil e rápida de testar uma consulta ou de obter uma amostra do tipo de resultado obtido é usar a função LIMIT. LIMIT permite que você limite o número de resultados obtidos.
Q8: Quais são os 5 filmes mais recentes armazenados na tabela?
Dica: Classifique o conjunto de resultados em ordem decrescente de acordo com release_year e, em seguida, use LIMIT.
Syntax: SELECT column1, column2, … FROM table_name LIMIT x;
Consulta SQL: SELECT title, release_year FROM films ORDER BY release_year DESC LIMIT 5;
Resultado:
título |
release_year |
|
1 |
Início |
2010 |
2 |
O Cavaleiro das Trevas |
2008 |
3 |
O Senhor dos Anéis: O retorno do rei |
2003 |
4 |
Clube da Luta |
1999 |
5 |
Pulp Fiction |
1994 |
INSERT INTO
O INSERT INTO é usado para adicionar novos registros a uma tabela de banco de dados. Você pode escrever uma instrução INSERT INTO de duas maneiras:
- Especifique os nomes das duas colunas junto com os valores correspondentes
Syntax: INSERT INTO nome_da_tabela (coluna1, coluna2, coluna3, ...) VALUES (valor1, valor2, valor3, ...);
- Se você estiver adicionando valores para TODAS as colunas da tabela, não precisará especificar os nomes das colunas na consulta. Tenha cuidado ao usar esse método e certifique-se de que a ordem dos valores esteja na mesma ordem das colunas da tabela.
Syntax: INSERT INTO nome_da_tabela VALUES (valor1, valor2, valor3, ...);
Q9: Adicione uma entrada para 'The Godfather: Parte III" na tabela com os detalhes: ('The Godfather: Part III', 1990, 54000000, 136900000, 7.6)
Syntax: SELECT column1, column2, ... FROM table_name ORDER BY column1, column2,... ASC|DESC;
Consulta SQL: INSERT INTO films (title, release_year, budget, gross, imdb_score)
VALUES ('O Poderoso Chefão: Part III', 1970, 54000000, 136900000, 7.6);
Tabela resultante:
título |
release_year |
orçamento |
bruto |
imdb_score |
|
1 |
O Poderoso Chefão |
1972 |
6000000 |
134821952 |
9.2 |
2 |
O Cavaleiro das Trevas |
2008 |
185000000 |
533316061 |
9 |
3 |
O Poderoso Chefão: Parte II |
1974 |
13000000 |
57300000 |
9 |
4 |
A Lista de Schindler |
1993 |
22000000 |
96067179 |
8.9 |
5 |
Pulp Fiction |
1994 |
8000000 |
107930000 |
8.9 |
6 |
O Senhor dos Anéis: O retorno do rei |
2003 |
94000000 |
377019252 |
8.9 |
7 |
Clube da Luta |
1999 |
63000000 |
37023395 |
8.8 |
8 |
Início |
2010 |
160000000 |
292568851 |
8.8 |
9 |
Guerra nas Estrelas: Episódio V - O Império Contra-Ataca |
1980 |
18000000 |
290158751 |
8.8 |
10 |
O resgate de Shawshank |
1994 |
25000000 |
28341469 |
9.3 |
11 |
O Poderoso Chefão: Parte III |
1970 |
54000000 |
136900000 |
7.6 |
ATUALIZAÇÃO
Usamos o comando UPDATE para modificar os registros existentes em uma tabela.
Q10: Corrija o ano de lançamento de "O Poderoso Chefão": Parte III" deve ser 1990 em vez de 1970
Syntax: UPDATE table_name SET column1 = value1, column2 = value2, ...WHERE condition;
Consulta SQL: UPDATE films SET release_year = 1990 WHERE title = 'The Godfather: Parte III";
Tabela resultante:
título |
release_year |
orçamento |
bruto |
imdb_score |
|
1 |
O Poderoso Chefão |
1972 |
6000000 |
134821952 |
9.2 |
2 |
O Cavaleiro das Trevas |
2008 |
185000000 |
533316061 |
9 |
3 |
O Poderoso Chefão: Parte II |
1974 |
13000000 |
57300000 |
9 |
4 |
A Lista de Schindler |
1993 |
22000000 |
96067179 |
8.9 |
5 |
Pulp Fiction |
1994 |
8000000 |
107930000 |
8.9 |
6 |
O Senhor dos Anéis: O retorno do rei |
2003 |
94000000 |
377019252 |
8.9 |
7 |
Clube da Luta |
1999 |
63000000 |
37023395 |
8.8 |
8 |
Início |
2010 |
160000000 |
292568851 |
8.8 |
9 |
Guerra nas Estrelas: Episódio V - O Império Contra-Ataca |
1980 |
18000000 |
290158751 |
8.8 |
10 |
O resgate de Shawshank |
1994 |
25000000 |
28341469 |
9.3 |
11 |
O Poderoso Chefão: Parte III |
1990 |
54000000 |
136900000 |
7.6 |
DELETE
O comando DELETE é usado para excluir um registro existente em uma tabela.
Q11: Excluir a entrada para 'O Poderoso Chefão': Parte III" da tabela "filmes".
Syntax: DELETE FROM nome_da_tabela WHERE condição;
Consulta SQL: DELETE FROM films WHERE title = 'O Poderoso Chefão': Parte III";
Tabela resultante: Igual à tabela original que começamos com um total de 10 registros.
Consultas SQL avançadas
Lembra que colocamos o "*" mágico para uma discussão posterior no final do Q1? O * é um asterisco. É um personagem abrangente que poderíamos ler como "todos".
Trazendo de volta o Q1: Quais são os filmes armazenados na tabela?
Usamos o SELECT - FROM com a sintaxe : SELECT column1, column2, ... FROM table_name;
Usamos a consulta: SELECT title FROM films;
Mas e se você não soubesse que "title" é um campo da tabela "films"? Ou o nome de qualquer campo da tabela? Ou você simplesmente quer todos os campos da tabela para ter uma ideia dos dados?
Bem, é aqui que o * é útil.
Poderíamos reescrever a consulta como: SELECT * FROM films;
Isso nos forneceria todos os campos disponíveis na tabela.
Caracteres curinga do SQL
LIKE
O operador LIKE é usado em uma cláusula WHERE para pesquisar um padrão especificado em uma coluna.
Q12: Recuperar todos os nomes do filme que começam com "The
Syntax: SELECT column1, column2, … FROM table_name WHERE column1 LIKE patternToMatch;
Consulta SQL: Select * FROM films WHERE title LIKE 'The%';
Tabela resultante:
título |
release_year |
orçamento |
bruto |
imdb_score |
|
1 |
O Poderoso Chefão |
1972 |
6000000 |
134821952 |
9.2 |
2 |
O Cavaleiro das Trevas |
2008 |
185000000 |
533316061 |
9 |
3 |
O Poderoso Chefão: Parte II |
1974 |
13000000 |
57300000 |
9 |
4 |
O Senhor dos Anéis: O retorno do rei |
2003 |
94000000 |
377019252 |
8.9 |
5 |
O resgate de Shawshank |
1994 |
25000000 |
28341469 |
9.3 |
Caractere curinga |
Descrição |
Uso: Exemplo |
% (Porcentagem) |
Representa zero ou mais caracteres |
A%: O, O Poderoso Chefão, Theodore |
_ (abaixo da pontuação) |
Representa um único caractere |
T_e: O, Gravata |
[ ] (colchetes) |
Representa qualquer caractere único dentro dos colchetes |
C[ao]t: Gato, berço, mas não casaco |
^ (Cunha) |
Representa qualquer caractere que não esteja entre colchetes |
Ca[^r]: Cat, Cab, Can, mas não Car |
- (Dash) |
Representa qualquer caractere único dentro do intervalo especificado |
C[a-o]: Can, Cab, mas não Car, Cat |
O que é ótimo é que podemos usar curingas em combinações! Portanto, você pode criar instruções de correspondência bastante complexas usando caracteres curinga junto com LIKE.
Funções agregadas
O SQL é excelente para agregar dados, como você faria em uma tabela dinâmica no Excel. As funções de agregação podem realizar cálculos não entre duas colunas, mas dentro de uma coluna, trabalhando assim com todas ou algumas linhas na mesma coluna.
Essas são as funções de agregação no SQL:
Função |
Descrição |
CONTAGEM |
Conta o número de registros em uma coluna específica |
SUM |
Adiciona todos os valores em uma coluna específica |
MIN |
Retorna o valor mais baixo em uma coluna específica |
MAX |
Retorna os valores mais altos em uma coluna específica |
AVG |
Retorna o valor médio de um grupo selecionado |
Q13: Qual é o último filme armazenado na tabela?
Consulta SQL: SELECT title AS latest_movie, MAX(release_year) AS released_in FROM films;
Resultado:
latest_movie |
released_in |
|
1 |
Início |
2010 |
GRUPO POR
As funções de agregação do SQL agregam em uma coluna inteira. Mas e se você quiser agregar apenas parte de uma coluna? Por exemplo, talvez você queira contar o número de filmes lançados em um ano.
É aqui que você precisaria de uma cláusula GROUP BY. O GROUP BY permite que você separe os dados em grupos, que podem ser agregados independentemente uns dos outros.
Q13: Conte o número de filmes lançados em um ano.
Consulta SQL: SELECT release_year, COUNT(*) AS number_of_movies FROM films GROUP BY release_year;
Resultado:
release_year |
number_of_movies |
|
1 |
1972 |
1 |
2 |
2008 |
1 |
3 |
1974 |
1 |
4 |
1993 |
1 |
5 |
1994 |
2 |
6 |
2003 |
1 |
7 |
1999 |
1 |
8 |
2010 |
1 |
9 |
1980 |
1 |
Exemplos de consultas SQL de várias tabelas
Até agora, trabalhamos com apenas uma tabela de cada vez. Mas o verdadeiro poder dos bancos de dados e do SQL vem da capacidade de trabalhar com dados de várias tabelas.
O termo "banco de dados relacional" em RDBMS vem do fato de que as tabelas dentro do banco de dados se relacionam entre si. Elas têm identificadores comuns que permitem que os dados de várias tabelas sejam combinados facilmente. É aqui que usamos os JOINS da tabela SQL.
Vamos ver um exemplo simples para nos familiarizarmos com a sintaxe JOIN e também aprender um pouco sobre os diferentes tipos de JOINS possíveis.
Vamos considerar outra tabela chamada "movieDirectors" que contém o nome do diretor de alguns dos filmes que temos na tabela "films".
título |
diretor |
|
1 |
O Poderoso Chefão |
Francis Ford Coppola |
2 |
O Poderoso Chefão: Parte II |
Francis Ford Coppola |
3 |
O Poderoso Chefão: Parte III |
Francis Ford Coppola |
4 |
A Lista de Schindler |
Steven Spielberg |
5 |
O Cavaleiro das Trevas Ressurge |
Christopher Nolan |
Poderíamos combinar os dados dessas duas tabelas usando um identificador comum: "title".
Q14: Adicione uma coluna à tabela "films", preenchendo-a com o nome do diretor da tabela "movieDirectors".
Syntax: SELECT leftTable.column1, rightTable.column1, leftTable.column2.... FROM leftTable INNER JOIN rightTable ON leftTable.commonIdentifier = rightTable.commonIdentifier;
Consulta SQL: Select films.title, films.release_year, movieDirectors.director FROM films INNER JOIN movieDirectors ON films.title = movieDirectors.title
Resultado:
título |
release_year |
diretor |
|
1 |
O Poderoso Chefão |
1972 |
Francis Ford Coppola |
2 |
O Poderoso Chefão: Parte II |
1974 |
Francis Ford Coppola |
3 |
A Lista de Schindler |
1993 |
Steven Spielberg |
Diferentes tipos de junções SQL
JUNTAR |
Descrição |
Diagrama |
Inner Join |
Retorna apenas os registros que têm valores correspondentes em ambas as tabelas |
|
União esquerda (externa) |
Retorna todos os registros da tabela à esquerda e os registros correspondentes da tabela à direita |
|
União direita (externa) |
Retorna todos os registros da tabela da direita e os registros correspondentes da tabela da esquerda |
|
União completa (externa) |
Retorna todos os registros quando há uma correspondência na tabela da esquerda ou da direita |
Na consulta de exemplo acima, "films" é a tabela da esquerda e "movieDirectors" é a tabela da direita. Portanto, com o INNER JOIN que realizamos, só recebemos de volta os filmes que existiam em ambas as tabelas. O conjunto de resultados foi uma interseção das duas tabelas.
SQL UNION
Os SQL JOINS permitem que você combine dois conjuntos de dados lado a lado. Mas com o SQL UNION, você pode empilhar um conjunto de dados sobre o outro. O operador UNION é usado para combinar o conjunto de resultados de dois ou mais comandos SELECT quando as seguintes "regras" são atendidas:
- Todo comando SELECT deve ter o mesmo número de colunas.
- As colunas também devem ter tipos de dados semelhantes.
- As colunas usadas nos comandos SELECT devem estar na mesma ordem.
Syntax: SELECT nome_da_coluna(s) FROM table1 UNION ALL SELECT nome_da_coluna(s) FROM table2;
Vamos considerar a tabela "movies_2000s":
título |
release_year |
orçamento |
bruto |
imdb_score |
|
1 |
Início |
2010 |
160000000 |
292568851 |
8.8 |
2 |
O julgamento do Chicago 7 |
2020 |
35000000 |
7.7 |
Agora, se combinássemos as duas tabelas...
Consulta SQL: SELECT title FROM films UNION SELECT title FROM movies_2000s;
Resultado:
título |
|
1 |
O Poderoso Chefão |
2 |
O Cavaleiro das Trevas |
3 |
O Poderoso Chefão: Parte II |
4 |
A Lista de Schindler |
5 |
Pulp Fiction |
6 |
O Senhor dos Anéis: O retorno do rei |
7 |
Clube da Luta |
8 |
Início |
9 |
Guerra nas Estrelas: Episódio V - O Império Contra-Ataca |
10 |
O resgate de Shawshank |
12 |
O julgamento do Chicago 7 |
Você deve ter notado que "Inception" apareceu apenas uma vez no conjunto de resultados. Isso ocorre porque o UNION seleciona apenas valores distintos; se você quiser todos os valores, poderá usar o UNION ALL.
Consultas SQL NESTED
O SQL é capaz de fazer maravilhas com os dados. As consultas aninhadas são mais uma ferramenta do SQL que faz dele uma linguagem que vale a pena conhecer. Uma consulta aninhada nada mais é do que uma consulta dentro de uma consulta (mais ou menos como os sonhos em Inception!).
Com as consultas aninhadas, você pode executar operações muito complicadas, mas em várias etapas, mantendo intactas a legibilidade e a compreensibilidade do código.
Q15: Determine a lucratividade média dos filmes na tabela "filmes".
Dica: Você calculou a lucratividade anteriormente, com o Q3. Agora você precisa pegar o resultado dessa consulta e aplicar a função AVG a ele.
Consulta aninhada SQL:
SELECT AVG(*) AS average_profit FROM
(SELECT title, (gross - budget) AS movie_profit FROM films where gross > budget);
Removemos o valor negativo de "Fight Club" no cálculo dentro da consulta SQL interna, adicionando bruto > orçamento.
Na consulta aninhada acima, primeiro a consulta interna é executada e, em seguida, esse conjunto de resultados é usado como uma tabela temporária para a consulta externa consultar e obter dados.
Não vamos nos aprofundar muito no tópico da consulta SQL aninhada. Mas recomendamos que você faça o curso SQL Intermediário da DataCamp para dominar as consultas SQL. Você vai brincar com o banco de dados de futebol europeu e aprender mais sobre consultas aninhadas. Você também aprenderá sobre instruções CASE e funções de janela - tópicos que não pudemos abordar neste tutorial de consulta SQL.
Considerações finais
Você aprendeu muito sobre consultas SQL e está em uma ótima posição para iniciar sua jornada com a resolução de problemas reais usando SQL. Neste tutorial de consulta SQL, você aprendeu o que é uma consulta SQL e como escrever consultas SQL.
Você viu a sintaxe da consulta e respondeu a algumas perguntas ao longo do caminho. Começamos com exemplos de consultas SQL simples usando instruções SELECT - FROM - WHERE e avançamos para consultas SQL um pouco mais complexas usando junções, uniões e consultas aninhadas.
Abordamos muitas coisas no tutorial, mas essa NÃO é uma lista exaustiva de todas as consultas SQL simples e avançadas possíveis - há mais. E é altamente recomendável seguir o curso SQL Fundamentals do DataCamp para obter uma compreensão mais profunda e abrangente do SQL.
Lembre-se de que a prática é a chave para dominar qualquer habilidade, e o SQL não é exceção! O Practise levará suas habilidades em SQL do nível iniciante ao avançado.
Portanto, comece a trabalhar e boas consultas!
Cursos para SQL
Course
Analyzing Business Data in SQL
Course
Exploratory Data Analysis in SQL
blog
O que é SQL? - A linguagem essencial para o gerenciamento de bancos de dados
Summer Worsley
16 min
tutorial
Tutorial de visão geral do banco de dados SQL
DataCamp Team
3 min
tutorial
Tutorial do MySQL: Um guia abrangente para iniciantes
tutorial
Tutorial de como executar consultas SQL em Python e R
tutorial
Tutorial de SQLAlchemy com exemplos
tutorial
Introdução aos acionadores SQL: Um guia para desenvolvedores
Oluseye Jeremiah
13 min