Database
 sql >> Base de Dados >  >> RDS >> Database

Consultas SQL básicas


Este artigo contém exemplos de consultas SQL básicas que os iniciantes podem usar para recuperar dados de seus bancos de dados.

Básico SELECT Consulta


Aqui está um exemplo de possivelmente, a consulta mais comumente usada em SQL:
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       |
+---------+-------------+-----------+-----------+------------+

Esta consulta seleciona todas as linhas e todas as colunas do Pets tabela. Isso ocorre porque o asterisco (* ) curinga seleciona todas as colunas.

Selecione os nomes das colunas


Por motivos de desempenho, geralmente é melhor evitar selecionar todas as colunas, a menos que você realmente precise delas. Geralmente é melhor selecionar apenas as colunas que você precisa.

Aqui está um exemplo. 
SELECT PetId, PetName
FROM Pets;

Resultado:
+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 1       | Fluffy    |
| 2       | Fetch     |
| 3       | Scratch   |
| 4       | Wag       |
| 5       | Tweet     |
| 6       | Fluffy    |
| 7       | Bark      |
| 8       | Meow      |
+---------+-----------+

Filtrar os resultados


Você pode adicionar um WHERE cláusula para filtrar os resultados apenas para as linhas que você precisa. 
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';

Resultado:
+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 1       | Fluffy    |
| 6       | Fluffy    |
+---------+-----------+

Aqui está outro exemplo de filtragem dos resultados. Desta vez usamos o operador maior que (> ) para filtrá-lo por data. 
SELECT PetName, DOB 
FROM Pets
WHERE DOB > '2020-01-01';

Resultado:
+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Wag       | 2020-03-15 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
+-----------+------------+

Você pode trocar o operador maior que por outros operadores, como o operador maior ou igual a (>= ), menor que operador (< ), ou menor ou igual ao operador (<= ).

Você também pode usar o BETWEEN operador para filtrar os resultados para um intervalo específico (por exemplo, entre duas datas). 
SELECT
    PetName,
    DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';

Resultado:
+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
+-----------+------------+

Classifique os resultados


Você pode adicionar um ORDER BY cláusula para classificar as linhas que são retornadas pela consulta.

Ordem Ascendente


Use o ASC palavra-chave para classificar os resultados em ordem crescente. Este é o valor padrão, portanto, você também pode omitir essa palavra-chave se desejar os resultados em ordem crescente. 
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;

Ou:
SELECT PetId, PetName
FROM Pets
ORDER BY PetName;

Resultado:
+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 7       | Bark      |
| 2       | Fetch     |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 8       | Meow      |
| 3       | Scratch   |
| 5       | Tweet     |
| 4       | Wag       |
+---------+-----------+

Ordem Decrescente


Use o DESC palavra-chave para classificar os resultados em ordem decrescente. 
SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;

Resultado:
+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 4       | Wag       |
| 5       | Tweet     |
| 3       | Scratch   |
| 8       | Meow      |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 2       | Fetch     |
| 7       | Bark      |
+---------+-----------+

Classificar por várias colunas


Você pode classificar por várias colunas listando cada coluna, separada por uma vírgula. 
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;

SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;

Resultado:
+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 7       | Bark      |
| 2       | Fetch     |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 8       | Meow      |
| 3       | Scratch   |
| 5       | Tweet     |
| 4       | Wag       |
+---------+-----------+
(8 rows affected)
+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 7       | Bark      |
| 2       | Fetch     |
| 6       | Fluffy    |
| 1       | Fluffy    |
| 8       | Meow      |
| 3       | Scratch   |
| 5       | Tweet     |
| 4       | Wag       |
+---------+-----------+
(8 rows affected)

Podemos ver que os dois Fluffys estão em uma ordem diferente em cada resultado (podemos dizer olhando para o PetId valores). Isso ocorre porque o PetName coluna foi classificada primeiro, depois o PetId classificou quaisquer duplicatas da primeira classificação.

Classificar por colunas ocultas


Você pode classificar por colunas que não estão incluídas no SELECT Lista. 
SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;

Resultado:
+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 5       | Tweet     |
| 1       | Fluffy    |
| 6       | Fluffy    |
| 4       | Wag       |
| 2       | Fetch     |
| 3       | Scratch   |
| 7       | Bark      |
| 8       | Meow      |
+---------+-----------+

Nesse caso, podemos inferir desses resultados que Tweet é o animal de estimação mais jovem, e Meow é o mais antigo. Isso ocorre porque classificamos por data de nascimento (DOB ) coluna em ordem decrescente.

Só para ter certeza, aqui está novamente com o DOB coluna incluída no SELECT Lista. 
SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;

Resultado:
+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 5       | Tweet     | 2020-11-28 |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 4       | Wag       | 2020-03-15 |
| 2       | Fetch     | 2019-08-16 |
| 3       | Scratch   | 2018-10-01 |
| 7       | Bark      | NULL       |
| 8       | Meow      | NULL       |
+---------+-----------+------------+

Na verdade, agora podemos ver que Meow e Bark têm NULL valores no DOB coluna. Portanto, não sabemos se eles são realmente mais velhos ou mais jovens.

Mas isso demonstra que NULL os valores são tratados como os valores mais baixos possíveis. Esteja atento a NULL valores ao executar consultas.

Correspondência de padrões


Você pode usar o LIKE operador para usar a correspondência de padrões. 
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';

Resultado:
+---------+-----------+
| PetId   | PetName   |
|---------+-----------|
| 1       | Fluffy    |
| 2       | Fetch     |
| 6       | Fluffy    |
+---------+-----------+

Neste exemplo, procuramos todos os animais de estimação cujos nomes começam com a letra F . O sinal de porcentagem (% ) é um caractere curinga que corresponde a qualquer sequência de zero ou mais caracteres. Ele pode ser usado como prefixo ou sufixo, e também pode ser usado no meio de uma string.

Aqui está outro exemplo. 
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';

Resultado:
+-------------+------------+-------------------+
| FirstName   | LastName   | Email             |
|-------------+------------+-------------------|
| Homer       | Connery    | [email protected] |
| Bart        | Pitt       | [email protected]  |
+-------------+------------+-------------------+

Selecionar de uma lista


O IN O operador determina se um valor especificado corresponde a qualquer valor em uma subconsulta ou lista.

Aqui está um exemplo. 
SELECT 
    PetId, 
    PetName, 
    DOB 
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');

Resultado:
+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 4       | Wag       | 2020-03-15 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Subconsultas


Você pode usar o IN operador ao realizar uma subconsulta (uma consulta aninhada dentro de outra consulta).

Aqui está um exemplo. 
SELECT 
    PetTypeId,
    PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );

Resultado:
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
+-------------+-----------+

Isso retornou colunas de uma tabela (PetTypes ), mas somente quando havia pelo menos uma linha correspondente em outra tabela (Pets ) que correspondia ao PetTypeId coluna.

Para demonstrar isso ainda mais, o conteúdo relevante dessas duas tabelas é mostrado abaixo.

Os PetTypes tabela:
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+

Os Pets tabela:
+-------------+-----------+
| PetTypeId   | PetName   |
|-------------+-----------|
| 2           | Fluffy    |
| 3           | Fetch     |
| 2           | Scratch   |
| 3           | Wag       |
| 1           | Tweet     |
| 3           | Fluffy    |
| 3           | Bark      |
| 2           | Meow      |
+-------------+-----------+

Podemos ver que os PetTypes table contém um tipo de animal de estimação de Rabbit , mas nenhum dos animais de estimação em Pets table foram atribuídos a esse tipo (ou seja, não há valor de 4 no Pets.PetTypeId coluna).

Consulte 12 Operadores SQL comumente usados ​​e esta lista de Operadores SQL para obter mais informações sobre operadores em SQL.

Participações


É discutível se as junções SQL são consideradas “consultas SQL básicas”, mas incluirei uma junção aqui de qualquer maneira.

Então, para encerrar este artigo, aqui está um exemplo de uma junção interna. 
SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;

Resultado:
+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+

Nesse caso, usamos um INNER JOIN para retornar todos os nomes de animais de estimação com seus respectivos tipos de animais de estimação. Usamos o ON cláusula para especificar o predicado a ser avaliado para cada par de linhas unidas. Nesse caso, o p.PetTypeId coluna é uma chave estrangeira do pt.PetTypeId coluna, que é a chave primária para os PetTypes tabela.

Neste exemplo, também usei aliases nas tabelas, o que ajudou a manter o código agradável e conciso.

Veja meu Tutorial de junções SQL para mais exemplos de junções.