Il SELECT istruzione è quasi senza dubbio l'istruzione più comunemente usata in SQL.
Il SELECT istruzione viene utilizzata per recuperare i dati dal database. Puoi specificare quali righe desideri vengano restituite e quali colonne.
Esempio
Ecco un esempio per dimostrare il SELECT dichiarazione.
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 | +---------+-------------+-----------+-----------+------------+
In questo esempio abbiamo utilizzato l'asterisco (* ) carattere jolly per restituire tutte le colonne. Abbiamo anche usato il FROM clausola per specificare da quale tabella ottenere i dati.
Quindi questa query restituisce tutte le righe e tutte le colonne da Pets tabella.
Specifica le colonne
Puoi specificare le colonne che vorresti fossero restituite.
A tale scopo, sostituisci il carattere jolly asterisco con i nomi delle colonne, ciascuno separato da una virgola, nell'ordine in cui desideri che vengano restituiti.
SELECT PetId, PetName, DOB
FROM Pets;Risultato:
+---------+-----------+------------+ | 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 | +---------+-----------+------------+
È generalmente considerata una buona pratica farlo in questo modo e restituire solo le colonne di cui hai effettivamente bisogno. L'utilizzo del carattere jolly asterisco per restituire tutte le colonne può avere un impatto negativo sulle prestazioni, soprattutto nei database più grandi.
Specifica le righe
Esistono molti modi per filtrare i risultati solo nelle righe che ti interessano. Il modo più comune è utilizzare WHERE clausola. Questa clausola consente di specificare una condizione che una riga deve soddisfare per essere qualificata.
Ecco un esempio da dimostrare.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Risultato:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Nel nostro caso, c'erano due righe che soddisfacevano la nostra condizione di ricerca.
La nostra condizione di ricerca utilizza l'operatore uguale (= ) per specificare che il valore del PetName la colonna deve corrispondere al valore specificato (Fluffy ) esattamente.
Ci sono molti altri operatori che puoi utilizzare nelle tue condizioni di ricerca. Ad esempio, potresti usare il LIKE operatore di restituire animali domestici il cui nome inizia con F o Fluff o altro.
Puoi aggiungere più condizioni a WHERE clausola utilizzando operatori come AND e OR operatori.
Ecco un esempio.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR DOB < '2020-01-01';Risultato:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 2 | Fetch | 2019-08-16 | | 3 | Scratch | 2018-10-01 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
In questo esempio abbiamo restituito tutte le righe in cui il nome dell'animale domestico è Fluffy o dove la data di nascita dell'animale domestico (specificata nel DOB colonna) è inferiore a una certa data. Abbiamo utilizzato l'operatore less than (< ) per specificarlo.
Restituzione di dati non di tabella
Il SELECT L'istruzione può essere utilizzata anche per restituire dati che non sono archiviati in una tabella. Ad esempio, è perfettamente legale farlo:
SELECT 'Hey there!';Risultato:
+--------------------+ | (No column name) | |--------------------| | Hey there! | +--------------------+
Si noti che quando lo facciamo, la colonna non ha nome. Potremmo usare un alias per dare un nome al campo risultante.
Di seguito sono riportati alcuni altri esempi di selezione di dati non di tabella e fornitura di un alias a ciascun campo restituito:
SELECT
2 + 3 AS "2 + 3",
'Fluffy' + ' ' + 'Smith' AS FullName,
SYSDATETIME() AS "Date/time";Risultato:
+---------+--------------+-----------------------------+ | 2 + 3 | FullName | Date/time | |---------+--------------+-----------------------------| | 5 | Fluffy Smith | 2020-12-04 23:58:55.8483734 | +---------+--------------+-----------------------------+
Ecco una rapida carrellata:
- La prima colonna ha semplicemente aggiunto due numeri.
- La seconda colonna concatenava tre stringhe (incluso uno spazio). Se necessario, puoi anche concatenare stringhe con numeri.
- La terza colonna utilizzava
SYSDATETIME()funzione per restituire la data e l'ora correnti. Questa funzione è disponibile in SQL Server. Altri DBMS hanno le proprie funzioni di data e ora. Vedere Funzioni di data/ora di SQLite, Funzioni di data/ora di SQL Server e Funzioni di data/ora di PostgreSQL per un elenco delle funzioni di data e ora disponibili in quei DBMS.
Subquery
È possibile avere più SELECT dichiarazioni in un'unica query. Possiamo farlo usando una sottoquery.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Risultato:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
In questo esempio, abbiamo utilizzato IN operatore per specificare una sottoquery. Quella sottoquery ha selezionato i dati da un'altra tabella e il IN l'operatore lo ha ricollegato alla query esterna.
Ordinare i risultati
Puoi utilizzare il ORDER BY clausola per ordinare i risultati.
Ad esempio, potremmo ordinare i risultati precedenti in base a PetTypeId colonna in ordine decrescente:
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets )
ORDER BY PetTypeId DESC;Risultato:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 3 | Dog | | 2 | Cat | | 1 | Bird | +-------------+-----------+
Vedi SQL ORDER BY Clausola per principianti per ulteriori esempi e una spiegazione dettagliata.
Più avanzato SELECT Dichiarazioni
Il SELECT statement è un'istruzione molto semplice, ma può essere utilizzata per creare query molto complesse.
Ecco una query leggermente più complessa delle precedenti.
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;Risultato:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
Nel mondo delle query SQL, questo è ancora piuttosto semplice, tuttavia contiene molti degli elementi spesso visti nelle query più complesse.
Ad esempio, questa query utilizza un join per recuperare i dati da più tabelle. Utilizza anche il GROUP BY clausola per dividere le righe in gruppi.
Vedi SQL GROUP BY Clausola per principianti per ulteriori esempi di GROUP BY clausola.
Consulta l'esercitazione sui join SQL per vedere come recuperare i dati da più tabelle e restituirli come un unico set di risultati.
Il SELECT INTO Dichiarazione
Alcuni DBMS supportano il SELECT INTO dichiarazione. Questo è leggermente diverso dagli esempi precedenti, in quanto influisce sui dati nel database.
Il SELECT INTO istruzione crea una nuova tabella e inserisce i dati in essa da un'altra tabella.
Fondamentalmente, funziona così:
SELECT * INTO Table2
FROM Table1;
In questo esempio, creiamo una nuova tabella chiamata Table2 e inserisci tutti i dati da Table1 dentro. Table2 avrà la stessa definizione di Table1 .
Vedi SQL SELECT INTO Dichiarazione per ulteriori esempi.
Come ho accennato, non tutti i DBMS supportano questa affermazione. Se il tuo DBMS non supporta il SELECT INTO istruzione, prova a utilizzare CREATE TABLE ... AS SELECT affermazione invece.
Tali istruzioni creano una nuova tabella come parte della loro operazione. Per inserire dati in una tabella già esistente, prova a utilizzare INSERT INTO ... SELECT affermazione invece.
