22 exercícios para praticar comandos SQL

Deseja aprimorar seus conhecimentos de SQL? Pratique os comandos SQL nestes 22 exercícios realistas!

Há um velho ditado que diz que "não há substituto para a experiência". Mas como obter essa experiência quando se está apenas começando a aprender algo novo? A melhor maneira é praticar, praticar e praticar mais! Neste artigo, forneceremos a você alguns exercícios práticos de comandos SQL do mundo real.

Todos os nossos exercícios práticos foram retirados de cursos em LearnSQL.com.br. Oferecemos cursos interativos de SQL em diferentes trilhas. Alguns cursos são voltados para iniciantes; nosso SQL para Iniciantes nosso curso inclui mais de 120 exercícios que abrangem comandos básicos de SQL. Os usuários intermediários podem se beneficiar de trilhas como Trilha de Práticas em SQLque inclui dez cursos interativos e mais de 100 horas de prática! E para profissionais experientes, os três cursos da trilha SQL Avançado (com quase 400 exercícios práticos) ajudarão a dominar os recursos mais detalhados do SQL.

Vamos começar a aprimorar nosso conhecimento dos comandos SQL!

Trabalhando com uma tabela: SELECT, WHERE, ORDER BY, GROUP BY

Nos próximos exercícios, consultaremos os dados de uma única tabela que contém informações sobre gatos. A tabela é denominada Cat e tem as seguintes colunas:

• id - O ID de um determinado gato. Essa é a chave primária da tabela.
• name - O nome do gato
• breed - O gato
• coloration - O gato
• age - O gato
• sex - O gato
• fav_toy - O brinquedo favorito do gato.

Exercício nº 1: Seleção de colunas e filtragem de dados numéricos

Exercício: Selecione o nome, a raça e a coloração de cada gato com menos de cinco anos de idade.

Solução:

SELECT 
  name, 
  breed, 
  coloration
FROM cat
WHERE age < 5;

Explicação: Liste as colunas necessárias (name, breed e coloration) na cláusula SELECT; separe-as com vírgulas. Faça referência à tabela Cat na cláusula FROM e use a condição obrigatória age < 5 na cláusula WHERE.

Exercício nº 2: Seleção de todas as colunas e filtragem de dados de texto

Exercício: Selecione todos os dados de gatos cujo:

• A raça começa com um "R".
• O brinquedo favorito começa com a palavra "ball" (bola).
• A coloração termina com um "m".

Solução:

SELECT *
FROM cat
WHERE breed LIKE 'R%'
  AND fav_toy LIKE 'ball%'
  AND coloration LIKE '%m';

Explicação: Como queremos obter todas as colunas da tabela no resultado, usamos o símbolo * para representar todas as colunas disponíveis na tabela. Fazemos referência à tabela Cat na cláusula FROM e incluímos as três condições de filtro necessárias usando o operador LIKE e o curinga %. O uso do operador AND significa que cada condição está relacionada à anterior; todas as três devem ser verdadeiras para que a linha seja incluída no resultado.

Lembre-se de que os valores de texto precisam ser colocados entre aspas simples.

Exercício nº 3: Seleção de colunas e filtragem de dados NULL

Exercício: Selecione os nomes de todos os gatos machos que não têm um brinquedo favorito - ou seja, o valor do campo fav_toy é NULL para esses gatos.

Solução:

SELECT name
FROM cat
WHERE sex = 'M'
  AND fav_toy IS NULL;

Explicação: Inclua somente a coluna name na cláusula SELECT. Use duas condições de filtro com o operador AND na cláusula WHERE. A primeira condição é fazer a correspondência da coluna sex com o literal 'M'. A segunda condição filtra as linhas em que a coluna fav_toy tem um valor NULL.

Importante: não é possível comparar NULLs com outros valores usando operadores de comparação como equal; você precisa perguntar se um valor IS NULL ou IS NOT NULL.

Exercício nº 4: ordenando os dados retornados por um SELECT

Exercício: Selecione o nome, a idade, a raça e o sexo de todos os gatos, mostrando primeiro os mais velhos.

Solução:

SELECT 
  name, 
  age, 
  breed, 
  sex
FROM cat
ORDER BY age DESC;

Explicação: Liste as colunas necessárias (name, age, breed e sex) na cláusula SELECT. Faça referência à tabela Cat na cláusula FROM e ordene as linhas usando a cláusula ORDER BY< seguida da coluna age.

Como a ordem padrão é ascendente, precisamos incluir a palavra-chave opcional DESC para classificar os dados em ordem descendente, ou seja, recuperar os gatos mais velhos primeiro.

Exercício nº 5: Agrupamento de dados e ordenação por agregação

Exercício: Mostre a contagem de gatos por cada tipo de coloração, usando number_of_cats como um pseudônimo para a função de agregação que calcula essa informação. Mostre primeiro as colorações com menos gatos.

Solução:

SELECT 
  coloration, 
  COUNT(*) AS number_of_cats
FROM cat
GROUP BY coloration
ORDER BY number_of_cats DESC;

Explicação: Inclua a coluna de coloração e a função de agregação COUNT(*) na cláusula SELECT. Use o alias AS number_of_cats para retornar um nome de fácil utilização para a coluna COUNT(*).

Use a cláusula GROUP BY seguida da coluna coloration para agrupar os dados com base na coloração. Ordene os resultados com a cláusula ORDER BY seguida de um nome de coluna ou alias - nesse caso, number_of_cats.

Exercício nº 6: Agrupamento de dados e filtragem por agregação

Exercício: Mostre a idade média dos gatos em cada raça; use Average_Age como um alias para a função de agregação. Mostre apenas as raças em que a idade média é maior que cinco anos.

Solução:

SELECT 
  breed, 
  AVG(age) AS Average_Age
FROM cat
GROUP BY breed
HAVING AVG(age) > 5;

Explicação: Inclua a coluna breed e a função de agregação AVG(age) na cláusula SELECT. Use um alias para retornar um nome de coluna fácil de usar para a função de agregação. Use a cláusula GROUP BY seguida da coluna breed para agrupar os dados com base em cada raça de gato.

Como precisamos filtrar com base nos resultados da agregação, não podemos usar a cláusula WHERE; ela filtra as linhas BEFORE que estão agrupadas. Em vez disso, precisamos usar a cláusula HAVING; ela é aplicada depois que as linhas são agrupadas.

Saiba mais: Encontre mais exemplos práticos GROUP BY no artigo 10 exercícios GROUP BY Trilha de Práticas em SQL com soluções.

Trabalho com várias tabelas: JOIN

Nos próximos exercícios, consultaremos dados de mais de uma tabela. Usaremos um modelo muito simples que inclui funcionários, salários e benefícios.

Vamos ver a employee estrutura da tabela:

• id - O ID de um determinado funcionário.
• first_name - O primeiro nome do funcionário.
• last_name - O sobrenome do funcionário.
• salary - O nome do funcionário.
• manager_id - O ID do gerente do funcionário.

Em seguida, a tabela salgrade mantém as informações de nível salarial:

• grau - O grau de um salário.
• lower_limit - O limite inferior da escala salarial.
• upper_limit - O limite superior da nota salarial.

E a última tabela, benefitstem apenas duas colunas:

• benefit_name - O nome de um determinado benefício.
• salary_req - O salário mínimo necessário para obter esse benefício.

Exercício nº 7: Unindo implicitamente dados de várias tabelas

Exercício: Selecione o nome, o sobrenome, o salário e o nível salarial dos funcionários cujo salário se enquadre entre lower_limit e upper_limit na tabela. salgrade tabela.

Solução:

SELECT 
  first_name, 
  last_name, 
  salary, 
  grade
FROM employee, salgrade
WHERE salary BETWEEN lower_limit AND upper_limit;

Explicação: Liste as colunas necessárias (first_name, last_name, salary, grade) na cláusula SELECT. Faça referência a ambas as cláusulas employee e salgrade na cláusula FROM. Estamos usando a cláusula WHERE para definir os critérios de união entre as duas tabelas, especificando que o salário do funcionário deve estar entre os limites inferior e superior da tabela salgrade tabela.

Exercício nº 8: Unindo explicitamente dados de várias tabelas

Exercício: Mostre todos os benefícios que o funcionário com id = 5 receberia. Selecione o nome e o sobrenome desse funcionário junto com os nomes dos benefícios.

Solução:

SELECT 
  first_name, 
  last_name, 
  benefits.benefit_name
FROM employee
JOIN benefits 
ON employee.salary > benefits.salary_req
WHERE employee.id = 5;

Explicação: Liste as colunas necessárias (first_name, last_name, benefits.benefit_name) na cláusula SELECT. Faça referência à tabela employee na cláusula FROM e, em seguida, junte explicitamente as linhas à tabela de benefícios usando a palavra-chave JOIN.

A condição que define a relação entre as duas tabelas é especificada após a palavra-chave ON. Isso mantém as condições de relação da tabela separadas das condições de filtragem, o que melhora a clareza da consulta. As condições de filtragem ainda são definidas na cláusula WHERE; nesse caso, usamos a condição employee.id = 5.

Exercício nº 9: Unindo e agrupando dados de várias tabelas

Exercício: Para cada benefício, encontre o número de funcionários que o recebem. Mostre duas colunas: a benefit_name e o número de funcionários que o recebem (nomeie essa coluna como employee_count). Não se esqueça dos benefícios que não são recebidos por ninguém.

Solução:

SELECT 
  benefits.benefit_name, 
  COUNT(employee.id) AS employee_count
FROM benefits
LEFT JOIN employee 
ON salary_req <= employee.salary
GROUP BY benefits.benefit_name;

Explicação: Inclua a coluna benefit_name e a função de agregação COUNT() (aplicada à coluna employee.id ) na cláusula SELECT. Use um alias para os resultados da função de agregação: AS employee_count. Faça referência à tabela benefits na cláusula FROM e, em seguida, junte a tabela employee tabela usando um LEFT JOIN.

Lembre-se de que as operações LEFT (e RIGHT) JOIN recuperam todos os dados do lado esquerdo (ou direito) dos critérios JOIN - mesmo que não existam linhas correspondentes na outra tabela. Você pode saber mais no artigo SQL JOIN Types Explained.

O critério de junção é especificado após a palavra-chave ON. Por fim, use a cláusula GROUP BY para agregar os dados no nível benefit_name.

Exercício nº 10: Unir uma tabela a ela mesma (Self-Joins)

Exercício: Mostre o nome, o sobrenome, o salário e o nome e o sobrenome do gerente direto de cada funcionário na mesma linha. Para os funcionários que não têm um gerente (por exemplo, o CEO), mostre NULL como o nome e o sobrenome do gerente.

Use um alias para prefixar as colunas do funcionário com employee_ e as do gerente com manager_ (por exemplo, employee_first_name).

Solução:

SELECT 
  e.first_name AS employee_first_name, 
  e.last_name AS employee_last_name, 
  e.salary AS employee_salary,
  m.first_name AS manager_first_name,
  m.last_name AS manager_last_name
FROM employee e
LEFT JOIN employee m 
ON e.manager_id = m.id;

Explicação: Inclua o nome, o sobrenome e o salário do funcionário usando e como o employee alias de tabela. Inclua o nome e o sobrenome do gerente usando m como alias de tabela. Na cláusula FROM, use a tabela employee com o alias e para fazer referência aos dados do funcionário; na cláusula LEFT JOIN, use a tabela employee com um alias m para fazer referência às informações do gerente. A condição de união é que o valor manager_id do funcionário deve corresponder ao valor de id do gerente.

Saiba mais: Unir uma tabela a ela mesma é uma operação comum. Ela pode parecer complicada, mas é mais simples de entender quando você usa os aliases corretos para a tabela envolvida! Para obter mais ajuda com JOINs, confira nosso curso SQL JOINS. Ele tem mais de 90 exercícios interativos, incluindo dez exemplos gratuitos para você começar a praticar agora mesmo.

Uso de subconsultas

Nesta seção, usaremos subconsultas para consultar dados com base em condições que dependem de outros dados armazenados no banco de dados. Usaremos as seguintes tabelas, começando com a tabela orchestras tabela:

• id - O ID da orquestra.
• name - O nome da orquestra.
• rating - A classificação da orquestra nos últimos dez anos.
• city_origin - A cidade de origem da orquestra (por exemplo, "Berlim" para a Filarmônica de Berlim).
• country_origin - O país de origem da orquestra (por exemplo, "Alemanha" para a Filarmônica de Berlim).
• year - O ano em que a orquestra foi criada.

A tabela concert mantém informações sobre os concertos realizados pelas orquestras:

• id - O ID do concerto.
• city - O nome da cidade onde o concerto foi realizado. Isso pode ser diferente da cidade de origem da orquestra.
• country - O nome do país onde o concerto foi realizado.
• year - O ano em que o concerto foi realizado.
• rating - A classificação que os críticos deram ao concerto.
• orchestra_id - A identificação da orquestra que realizou o concerto.

A tabela members mantém informações sobre cada membro da orquestra:

• id - O ID de um determinado membro.
• name - O nome do membro.
• position - A posição do membro na orquestra (por exemplo, segunda flauta, viola principal).
• wage - Um pagamento mensal fixo dado ao membro da orquestra.
• experience - O número de anos de experiência que esse membro da orquestra tem.
• orchestra_id - A identificação da orquestra.

Exercício nº 11: Uso de subconsultas para filtrar dados

Exercício: Mostrar os nomes das orquestras que foram criadas depois da "Chamber Orchestra" e que têm uma classificação maior que 7,5.

Solução:

SELECT name
FROM orchestras 
WHERE year > 
(SELECT year 
FROM orchestras 
WHERE name = 'Chamber Orchestra') 
  AND rating > 7.5;

Explicação: As cláusulas SELECT e FROM deste exercício são muito simples, mas a parte complicada é a cláusula WHERE. Temos duas condições para avaliar e sabemos exatamente uma delas (rating > 7.5). A segunda é desconhecida para nós, pois não é um valor definido como 7,5, mas algo que precisa ser obtido a partir dos dados, ou seja, o ano de fundação da Orquestra de Câmara.

Nesses cenários, usamos uma subconsulta, ou seja, uma consulta que é executada "dentro" de uma consulta maior. Este exercício requer uma subconsulta que obtenha o ano de fundação da orquestra quando o nome for igual a "Chamber Orchestra". Usamos o resultado dessa subconsulta para filtrar o ano de fundação de cada orquestra.

Dica profissional: Ao trabalhar com subconsultas, é uma boa prática começar a criar a subconsulta primeiro. Quando ela retornar o resultado desejado, incorpore-a na consulta principal!

Exercício nº 12: Uso de subconsultas em FROM

Exercício: Encontre o número médio de membros por orquestra.

Solução:

SELECT AVG(d.count) 
FROM (SELECT 
        orchestra_id, 
        COUNT(id) 
FROM members 
GROUP BY orchestra_id) d;

Explicação: Comece com a subconsulta que obtém a contagem de membros para cada orquestra e o identificador da orquestra. Coloque a subconsulta na cláusula FROM da consulta principal e dê a ela um alias. A cláusula SELECT só precisa calcular o número médio de membros usando a função de agregação AVG() nos resultados da contagem da subconsulta.

Exercício nº 13: Subconsultas correlacionadas

Exercício: Selecionar o nome, o salário e a experiência dos membros mais bem pagos de cada orquestra.

Solução:

SELECT 
  name, 
  wage, 
  experience
FROM members m1
WHERE wage = (SELECT MAX(wage) 
             FROM members m2 
		WHERE m1.orchestra_id = m2.orchestra_id);

Explicação: Inclua as colunas name, wage e experience na cláusula principal SELECT. Coloque a tabela members na cláusula FROM e coloque o pseudônimo m1. Na cláusula WHERE, compare o valor do salário (da consulta principal) com os resultados da subconsulta correlacionada.

A subconsulta correlacionada obtém o salário máximo usando a função de agregação MAX() para todas as linhas da tabela de membros (com o alias m2) em que o orchestra_id corresponde ao da consulta principal.

Diferentemente das subconsultas regulares que são executadas uma vez antes da consulta principal, as subconsultas correlacionadas são executadas uma vez para cada linha da consulta principal. Isso ocorre porque elas fazem referência a valores da consulta principal.

Exercício nº 14: usar filtros, junções, GROUP BY e subconsultas

Exercício: Para cada orquestra, mostre seu nome, o nome da cidade em que a orquestra recebeu a classificação mais alta por seu desempenho e essa classificação.

Solução:

SELECT 
  o.name, 
  c.city, 
  c.rating
FROM orchestras o
JOIN concerts c 
ON o.id = c.orchestra_id
WHERE c.rating IN ( SELECT MAX(con.rating)
			FROM concerts con
			WHERE con.orchestra_id = o.id) ;

Explicação: Inclua o nome da orquestra, o concerto city e as colunas rating na cláusula SELECT da consulta principal. Na cláusula FROM, inclua a tabela orchestras e JOIN a tabela concerts usando os IDs da orquestra.

Use a cláusula WHERE para igualar o valor de concert rating com a classificação máxima do concerto obtida pela orquestra. Para obter isso, use uma subconsulta correlacionada que aplique a função MAX() à coluna de classificação. Na cláusula WHERE da subconsulta, faça a correspondência entre o ID da orquestra do concerto e o ID da orquestra da consulta principal.

Comandos SQL de modificação de dados: INSERIR, ATUALIZAR, EXCLUIR

Nas seções anteriores, usamos o comando SELECT. Nesta seção, praticaremos o uso de outros comandos SQL, como INSERT, UPDATE e DELETE. Usaremos a tabela dish que contém informações sobre refeições em um restaurante. Ela tem as seguintes colunas:

• id - O ID de cada prato e a chave primária dessa tabela.
• type - O tipo de prato (por exemplo, entrada, prato principal, sobremesa).
• name - O número do prato
• price - O prato

Exercício nº 15: Inserção de uma única linha sem especificar colunas

Exercício: Adicione um prato chamado Cevapcici com um ID de 9 e um preço de 27. É um prato principal.

Solução:

INSERT INTO dish 
VALUES (9, 'main course', 'Cevapcici', 27);

Explicação: A cláusula INSERT INTO, seguida pelo nome da tabela, indica a tabela na qual queremos inserir dados. Como não fornecemos uma lista de colunas, os valores de todas as colunas devem ser fornecidos na cláusula VALUES. Liste-os na ordem em que estão definidos na tabela e coloque a lista entre colchetes. Nesse caso, estamos inserindo o ID, o tipo, o nome e o preço do prato na tabela.

Exercício nº 16: Inserção de uma única linha e especificação de colunas

Exercício: A culinária dos Bálcãs está ficando popular, portanto, precisamos de outro item dos Bálcãs no cardápio. Adicione o pão de Kosovo com ID 10; é uma entrada. Ainda não decidimos o preço, portanto, omita-o por enquanto.

Solução:

INSERT INTO dish (id, type, name) 
VALUES (10, 'starter', 'Kosovo Bread');

Explicação: Após a cláusula INSERT INTO e o nome da tabela, coloque a lista de colunas a serem inseridas. (Lembre-se dos colchetes!) As colunas não incluídas na lista receberão um valor NULL.

Na cláusula VALUES, os valores são fornecidos para cada uma das colunas especificadas na lista.

Exercício nº 17: Atualização de determinadas linhas

Exercício: É happy hour em nosso restaurante! Altere o preço de todos os pratos principais para 20.

Solução:

UPDATE dish 
SET price = 20 
WHERE type = 'main course';

Explicação: Use a frase UPDATE seguida do nome da tabela que deseja atualizar. Na cláusula SET, especifique a coluna que deseja atualizar (nesse caso, apenas price) seguida do novo valor a ser atribuído a ela.

A cláusula WHERE funciona da mesma forma que a sentença SELECT, mas aqui ela identifica as linhas a serem atualizadas em vez das linhas a serem retornadas.

Exercício nº 18: Atualização de várias colunas

Exercício: Os rolinhos primavera estão vendendo muito bem, mas ninguém mais está interessado na salada de camarão (ID 1). Precisamos mudar seu nome para algo mais exótico - vamos tentar Green Sea Dragon. Defina o preço em 10 para incentivar os clientes a experimentar esse prato.

Solução:

UPDATE dish 
SET name = 'Green Sea Dragon', price = 10 
WHERE id = 1;

Explicação: Use a frase UPDATE seguida do nome da tabela que você deseja atualizar. Na cláusula SET, especifique as colunas que deseja atualizar (name e price) seguidas do(s) novo(s) valor(es) que estamos atribuindo; separe cada par de nome e valores com uma vírgula. A cláusula WHERE funciona da mesma forma que a sentença SELECT.

Exercício nº 19: Exclusão de uma única linha

Exercício: As ostras Bienville (ID 7) não são muito populares. Vamos removê-las do cardápio.

Solução:

DELETE FROM dish 
WHERE id = 7;

Explicação: Use a cláusula DELETE FROM seguida do nome da tabela para indicar a tabela em que os dados serão excluídos.

A cláusula WHERE funciona da mesma forma com DELETE e com SELECT. Nesse caso, ela compara a coluna id com um único valor. Assim, apenas uma ou zero linhas serão excluídas (dependendo se a linha com id = 7 existe ou não).

Exercício nº 20: Exclusão de várias linhas

Exercício: Ops, acabou-se o açúcar! Exclua todas as sobremesas de nosso menu.

Solução:

DELETE FROM dish 
WHERE type = 'dessert';

Explicação: Use a cláusula DELETE FROM seguida do nome da tabela para indicar a tabela em que os dados serão excluídos. A cláusula WHERE funciona da mesma forma que o comando SELECT; nesse caso, o comando SQL excluirá todas as linhas com o valor "dessert" (sobremesa) na coluna type (tipo).

Saiba mais: Dê uma olhada no curso Usando Comandos INSERT, UPDATE e DELETE em SQL para mais de 50 exercícios sobre inserção, atualização e exclusão de dados.

Comandos CREATE TABLE e ALTER TABLE

Agora podemos praticar o uso de dois comandos SQL adicionais que nos permitem criar e alterar tabelas.

Exercício nº 21: Criação de uma tabela simples

Exercício: Crie uma tabela chamada result com duas colunas INTEGER (id e score) e uma coluna DATE (score_date).

Solução:

CREATE TABLE result (
  id integer,
  score integer,
  score_date date
);

Explicação: Use a frase CREATE TABLE seguida do nome da tabela que você deseja criar. Forneça uma lista de nomes de colunas com o tipo de dados apropriado, separados por vírgulas. Certifique-se de que toda a lista de colunas esteja entre colchetes.

Exercício nº 22: Adicionar uma coluna NOT NULL

Exercício: Modifique a tabela result tornando a coluna id NOT NULL e adicionando uma nova coluna VARCHAR chamada name com um limite de 32 caracteres.

Solução:

ALTER TABLE result ALTER COLUMN id SET NOT NULL;
ALTER TABLE result ADD COLUMN name varchar(32);

Explicação: Use o comando ALTER TABLE seguido do nome da tabela. Use a cláusula ALTER COLUMN seguida do nome da coluna que você deseja modificar. Nesse caso, você definiu a coluna como NOT NULL.

Use o comando ALTER TABLE novamente. Dessa vez, coloque a cláusula ADD COLUMN seguida do nome da nova coluna e de seu tipo de dados e limite de caracteres (varchar(32)).

Saiba mais: O curso The Basics of Creating Tables in SQL inclui mais de 80 exercícios e 10 horas de prática sobre criação e alteração de tabelas de banco de dados.

Pronto para praticar mais comandos SQL?

Abordamos os comandos SQL que permitem que você consulte uma ou várias tabelas, filtre dados, agrupe e ordene dados, insira e atualize dados e exclua dados. Também mostramos opções básicas para criar e alterar tabelas de banco de dados.

Entretanto, ainda há muito conhecimento a ser adquirido sobre os comandos SQL. Consulte o Your Guide to Trilha de Práticas em SQL em LearnSQL.com para encontrar dezenas de artigos que oferecem prática adicional sobre comandos SQL.

Para um aprendizado abrangente, considere adquirir nosso pacoteIlimitado Vitalício SQL Package. Esse pacote lhe dá acesso a todos os cursos atuais e futuros, garantindo que você tenha os recursos para aprimorar continuamente suas habilidades em SQL. Não perca essa oportunidade de estar sempre à frente!