O
SELECT A instrução é quase sem dúvida a instrução mais usada em SQL. O
SELECT A instrução é usada para recuperar dados do banco de dados. Você pode especificar quais linhas deseja retornar e quais colunas. Exemplo
Aqui está um exemplo para demonstrar o
SELECT demonstração. SELECT *
FROM Pets;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Neste exemplo usamos o asterisco (
* ) curinga para retornar todas as colunas. Também usamos o FROM cláusula para especificar de qual tabela obter dados. Portanto, esta consulta retorna todas as linhas e todas as colunas do
Pets tabela. Especifique as colunas
Você pode especificar as colunas que deseja retornar.
Para fazer isso, substitua o curinga asterisco pelos nomes das colunas, cada um separado por uma vírgula, na ordem em que deseja que sejam retornados.
SELECT PetId, PetName, DOB
FROM Pets;Resultado:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 2 | Fetch | 2019-08-16 | | 3 | Scratch | 2018-10-01 | | 4 | Wag | 2020-03-15 | | 5 | Tweet | 2020-11-28 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | | 8 | Meow | NULL | +---------+-----------+------------+
Geralmente, é considerado uma boa prática fazer isso dessa maneira e retornar apenas as colunas que você realmente precisa. Usar o curinga asterisco para retornar todas as colunas pode ter um impacto adverso no desempenho, especialmente em bancos de dados maiores.
Especifique as linhas
Há muitas maneiras de filtrar os resultados apenas para as linhas em que você está interessado. A maneira mais comum é usar o
WHERE cláusula. Esta cláusula permite especificar uma condição que uma linha deve satisfazer para se qualificar. Aqui está um exemplo para demonstrar.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Resultado:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
No nosso caso, havia duas linhas que satisfizeram nossa condição de pesquisa.
Nossa condição de pesquisa usa o operador igual (
= ) para especificar que o valor do PetName a coluna deve corresponder ao valor especificado (Fluffy ) exatamente. Existem muitos outros operadores que você pode usar em suas condições de pesquisa. Por exemplo, você pode usar o
LIKE operador para devolver animais de estimação cujo nome comece com F ou Fluff como queiras. Você pode adicionar mais condições ao
WHERE cláusula usando operadores como o AND e OR operadores. Aqui está um exemplo.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR DOB < '2020-01-01';Resultado:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 2 | Fetch | 2019-08-16 | | 3 | Scratch | 2018-10-01 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Neste exemplo retornamos todas as linhas onde o nome do pet é Fluffy ou onde a data de nascimento do animal de estimação (especificada no
DOB coluna) é inferior a uma determinada data. Usamos o operador menor que (< ) para especificar isso. Retornando dados que não são de tabela
O
SELECT também pode ser usada para retornar dados que não estão armazenados em uma tabela. Por exemplo, é perfeitamente legal fazer isso:SELECT 'Hey there!';Resultado:
+--------------------+ | (No column name) | |--------------------| | Hey there! | +--------------------+
Observe que quando fazemos isso, a coluna não tem nome. Poderíamos usar um alias para dar um nome ao campo resultante.
Aqui estão mais alguns exemplos de como selecionar dados que não são de tabela e fornecer um alias para cada campo retornado:
SELECT
2 + 3 AS "2 + 3",
'Fluffy' + ' ' + 'Smith' AS FullName,
SYSDATETIME() AS "Date/time";Resultado:
+---------+--------------+-----------------------------+ | 2 + 3 | FullName | Date/time | |---------+--------------+-----------------------------| | 5 | Fluffy Smith | 2020-12-04 23:58:55.8483734 | +---------+--------------+-----------------------------+
Aqui está um resumo rápido:
- A primeira coluna simplesmente adicionou dois números.
- A segunda coluna concatenou três strings (incluindo um caractere de espaço). Você também pode concatenar strings com números, se necessário.
- A terceira coluna usou o
SYSDATETIME()função para retornar a data e hora atuais. Esta função está disponível no SQL Server. Outros SGBDs têm suas próprias funções de data e hora. Consulte Funções de data/hora do SQLite, Funções de data/hora do SQL Server e Funções de data/hora do PostgreSQL para obter uma lista de funções de data e hora disponíveis nesses SGBDs.
Subconsultas
É possível ter vários
SELECT declarações em uma única consulta. Podemos fazer isso usando uma subconsulta. SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Resultado:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Neste exemplo, usamos o
IN operador para especificar uma subconsulta. Essa subconsulta selecionou dados de outra tabela e o IN O operador o relacionou de volta à consulta externa. Ordenando os resultados
Você pode usar o
ORDER BY cláusula para classificar os resultados. Por exemplo, poderíamos classificar os resultados anteriores pelo
PetTypeId coluna em ordem decrescente:SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets )
ORDER BY PetTypeId DESC;Resultado:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 3 | Dog | | 2 | Cat | | 1 | Bird | +-------------+-----------+
Veja SQL
ORDER BY Cláusula para Iniciantes para mais exemplos e uma explicação detalhada. Mais avançado SELECT Declarações
O
SELECT declaração é uma declaração muito simples, mas pode ser usada para criar consultas muito complexas. Aqui está uma consulta que é um pouco mais complexa do que as anteriores.
SELECT
PetTypes.PetType,
COUNT(Pets.PetTypeId) AS Count
FROM Pets
LEFT JOIN PetTypes
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType
ORDER BY Count DESC;Resultado:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
No mundo das consultas SQL, isso ainda é bastante simples, no entanto, contém muitos dos elementos frequentemente vistos em consultas mais complexas.
Por exemplo, essa consulta usa uma junção para recuperar dados de várias tabelas. Ele também usa o
GROUP BY cláusula para dividir as linhas em grupos. Veja SQL
GROUP BY Cláusula para Iniciantes para mais exemplos do GROUP BY cláusula. Consulte Tutorial de junções de SQL para ver como recuperar dados de várias tabelas e retorná-los como um conjunto de resultados.
O SELECT INTO Declaração
Alguns DBMSs suportam o
SELECT INTO demonstração. Isso é um pouco diferente dos exemplos anteriores, pois afeta os dados no banco de dados. O
SELECT INTO A instrução cria uma nova tabela e insere dados de outra tabela nela. Basicamente, fica assim:
SELECT * INTO Table2
FROM Table1;Neste exemplo, criamos uma nova tabela chamada
Table2 , e insira todos os dados de Table1 afim disso. Table2 terá a mesma definição que Table1 . Veja SQL
SELECT INTO Declaração para mais exemplos. Como mencionei, nem todos os SGBDs suportam esta afirmação. Se o seu DBMS não suportar o
SELECT INTO instrução, tente usar o CREATE TABLE ... AS SELECT declaração em vez disso. Essas instruções criam uma nova tabela como parte de sua operação. Para inserir dados em uma tabela que já existe, tente usar o
INSERT INTO ... SELECT declaração em vez disso. 
