Questo articolo contiene esempi di query SQL di base che i principianti possono utilizzare per recuperare i dati dai propri database.
Base SELECT Interroga
Ecco un esempio della query forse più comunemente usata in SQL:
SELECT *
FROM Pets;Risultato:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Questa query seleziona tutte le righe e tutte le colonne da Pets tavolo. Questo perché l'asterisco (* ) il carattere jolly seleziona tutte le colonne.
Seleziona i nomi delle colonne
Per motivi di prestazioni, di solito è meglio evitare di selezionare tutte le colonne a meno che non siano realmente necessarie. Di solito è meglio selezionare solo le colonne che ti servono.
Ecco un esempio.
SELECT PetId, PetName
FROM Pets;Risultato:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 3 | Scratch | | 4 | Wag | | 5 | Tweet | | 6 | Fluffy | | 7 | Bark | | 8 | Meow | +---------+-----------+
Filtra i risultati
Puoi aggiungere un WHERE clausola per filtrare i risultati solo nelle righe che ti servono.
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';Risultato:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 6 | Fluffy | +---------+-----------+
Ecco un altro esempio di filtraggio dei risultati. Questa volta utilizziamo l'operatore maggiore di (> ) per filtrarlo per data.
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Risultato:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Puoi scambiare l'operatore maggiore di con altri operatori, come l'operatore maggiore o uguale a (>= ), minore di operatore (< ), o minore o uguale all'operatore (<= ).
Puoi anche usare il BETWEEN per filtrare i risultati in un intervallo specifico (ad es. tra due date).
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Risultato:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Ordina i risultati
Puoi aggiungere un ORDER BY clausola per ordinare le righe restituite dalla query.
Ordine Crescente
Usa il ASC parola chiave per ordinare i risultati in ordine crescente. Questo è il valore predefinito, quindi puoi anche omettere questa parola chiave se desideri che i risultati siano in ordine crescente.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;Oppure:
SELECT PetId, PetName
FROM Pets
ORDER BY PetName;Risultato:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+
Ordine decrescente
Usa il DESC parola chiave per ordinare i risultati in ordine decrescente.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;Risultato:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 4 | Wag | | 5 | Tweet | | 3 | Scratch | | 8 | Meow | | 1 | Fluffy | | 6 | Fluffy | | 2 | Fetch | | 7 | Bark | +---------+-----------+
Ordina per più colonne
Puoi ordinare in base a più colonne elencando ciascuna colonna, separata da una virgola.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;Risultato:
+---------+-----------+ | 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)
Possiamo vedere che i due Fluffy sono un ordine diverso in ogni risultato (lo possiamo dire guardando il loro PetId valori). Questo perché il PetName prima è stata ordinata la colonna, quindi PetId ordinato eventuali duplicati dal primo ordinamento.
Ordina per colonne nascoste
Puoi ordinare per colonne che non sono incluse in SELECT elenco.
SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;Risultato:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 5 | Tweet | | 1 | Fluffy | | 6 | Fluffy | | 4 | Wag | | 2 | Fetch | | 3 | Scratch | | 7 | Bark | | 8 | Meow | +---------+-----------+
In questo caso, possiamo dedurre da questi risultati che Tweet è l'animale più giovane e Meow è il più vecchio. Questo perché abbiamo ordinato la loro data di nascita (DOB ) colonna in ordine decrescente.
Per sicurezza, eccolo di nuovo con il DOB colonna inclusa in SELECT elenco.
SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;Risultato:
+---------+-----------+------------+ | 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 | +---------+-----------+------------+
In realtà, ora possiamo vedere che Meow e Bark hanno NULL valori nel DOB colonna. Pertanto, non sappiamo se siano effettivamente più grandi o più giovani.
Ma questo dimostra che NULL i valori sono trattati come i valori più bassi possibili. Fai attenzione a NULL valori durante l'esecuzione di query.
Corrispondenza del modello
Puoi usare il LIKE operatore per utilizzare la corrispondenza del modello.
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';Risultato:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 6 | Fluffy | +---------+-----------+
In questo esempio, cerchiamo tutti gli animali domestici i cui nomi iniziano con la lettera F . Il segno di percentuale (% ) è un carattere jolly che corrisponde a qualsiasi stringa di zero o più caratteri. Può essere utilizzato sia come prefisso che come suffisso e può essere utilizzato anche nel mezzo di una stringa.
Ecco un altro esempio.
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';Risultato:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Seleziona da un elenco
Il IN determina se un valore specificato corrisponde a qualsiasi valore in una sottoquery o in un elenco.
Ecco un esempio.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Risultato:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Subquery
Puoi usare il IN operatore durante l'esecuzione di una sottoquery (una query annidata all'interno di un'altra query).
Ecco un esempio.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Risultato:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Questo ha restituito colonne da una tabella (PetTypes ), ma solo quando c'era almeno una riga corrispondente in un'altra tabella (Pets ) che aveva una corrispondenza con PetTypeId colonna.
Per dimostrarlo ulteriormente, il contenuto rilevante di queste due tabelle è mostrato di seguito.
I PetTypes tabella:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+
Gli Pets tabella:
+-------------+-----------+ | PetTypeId | PetName | |-------------+-----------| | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-------------+-----------+
Possiamo vedere che i PetTypes la tabella contiene un tipo di animale domestico di Rabbit , ma nessuno degli animali domestici in Pets alla tabella è stato assegnato quel tipo (ovvero non esiste un valore di 4 nel Pets.PetTypeId colonna).
Vedere 12 operatori SQL comunemente usati e questo elenco di operatori SQL per ulteriori informazioni sugli operatori in SQL.
Unisciti
È discutibile se i join SQL siano considerati "query SQL di base", ma includerò comunque un join qui.
Quindi, per completare questo articolo, ecco un esempio di inner join.
SELECT
p.PetName,
pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Risultato:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
In questo caso, abbiamo utilizzato un INNER JOIN per restituire tutti i nomi di animali domestici con i rispettivi tipi di animali domestici. Abbiamo usato ON clausola per specificare il predicato da valutare per ogni coppia di righe unite. In questo caso, il p.PetTypeId column è una chiave esterna di pt.PetTypeId colonna, che è la chiave primaria per i PetTypes tabella.
In questo esempio, ho anche usato gli alias sulle tabelle, il che ha aiutato a mantenere il codice piacevole e conciso.
Vedi il mio tutorial sui join SQL per altri esempi di join.
