SELECT sætning er næsten uden tvivl den mest almindeligt anvendte sætning i SQL.
SELECT sætning bruges til at hente data fra databasen. Du kan angive, hvilke rækker du vil have returneret, og hvilke kolonner.
Eksempel
Her er et eksempel for at demonstrere SELECT erklæring.
SELECT *
FROM Pets;Resultat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
I dette eksempel brugte vi stjernen (* ) jokertegn for at returnere alle kolonner. Vi brugte også FROM klausul for at angive, hvilken tabel der skal hentes data fra.
Så denne forespørgsel returnerer alle rækker og alle kolonner fra Kæledyr tabel.
Angiv kolonnerne
Du kan angive de kolonner, du gerne vil have returneret.
For at gøre dette skal du erstatte stjerne-jokertegnet med kolonnenavnene, hver adskilt af et komma, i den rækkefølge, du ønsker, at de skal returneres.
SELECT PetId, PetName, DOB
FROM Pets;Resultat:
+---------+-----------+------------+ | 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 | +---------+-----------+------------+
Det anses generelt for at være god praksis at gøre det på denne måde og kun returnere de kolonner, som du rent faktisk har brug for. Brug af jokertegnet for stjerne til at returnere alle kolonner kan have en negativ indvirkning på ydeevnen, især i større databaser.
Angiv rækkerne
Der er mange måder at filtrere resultaterne til netop de rækker, du er interesseret i. Den mest almindelige måde er at bruge WHERE klausul. Denne klausul giver dig mulighed for at angive en betingelse, som en række skal opfylde for at kvalificere sig.
Her er et eksempel til at demonstrere.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Resultat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
I vores tilfælde var der to rækker, der opfyldte vores søgebetingelse.
Vores søgebetingelse bruger lig-operatoren (= ) for at angive, at værdien af PetName kolonne skal matche den angivne værdi (Fluffy ) præcis.
Der er mange andre operatører, som du kan bruge i dine søgebetingelser. For eksempel kan du bruge LIKE operatør for at returnere kæledyr, hvis navn starter med F eller Fluff eller hvad som helst.
Du kan tilføje flere betingelser til WHERE klausul ved at bruge operatorer såsom AND og ELLER operatører.
Her er et eksempel.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR DOB < '2020-01-01';Resultat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 2 | Fetch | 2019-08-16 | | 3 | Scratch | 2018-10-01 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
I dette eksempel returnerede vi alle rækker, hvor kæledyrets navn er Fluffy eller hvor kæledyrets fødselsdato er angivet i DOB kolonne) er mindre end en bestemt dato. Vi brugte mindre end-operatoren (< ) for at angive det.
Returnering af ikke-tabeldata
SELECT sætning kan også bruges til at returnere data, der ikke er gemt i en tabel. For eksempel er det helt lovligt at gøre dette:
SELECT 'Hey there!';Resultat:
+--------------------+ | (No column name) | |--------------------| | Hey there! | +--------------------+
Bemærk, at når vi gør det, har kolonnen ikke noget navn. Vi kunne bruge et alias til at give et navn til det resulterende felt.
Her er et par flere eksempler på valg af ikke-tabeldata og angivelse af et alias til hvert felt, der returneres:
SELECT
2 + 3 AS "2 + 3",
'Fluffy' + ' ' + 'Smith' AS FullName,
SYSDATETIME() AS "Date/time";Resultat:
+---------+--------------+-----------------------------+ | 2 + 3 | FullName | Date/time | |---------+--------------+-----------------------------| | 5 | Fluffy Smith | 2020-12-04 23:58:55.8483734 | +---------+--------------+-----------------------------+
Her er en hurtig oversigt:
- Den første kolonne tilføjede blot to tal.
- Den anden kolonne sammenkædede tre strenge (inklusive et mellemrumstegn). Du kan også sammenkæde strenge med tal, hvis det kræves.
- Den tredje kolonne brugte
SYSDATETIME()funktion for at returnere den aktuelle dato og tid. Denne funktion er tilgængelig i SQL Server. Andre DBMS'er har deres egne dato- og tidsfunktioner. Se SQLite Dato/Time Functions, SQL Server Date/Time Functions og PostgreSQL Date/Time Functions for en liste over dato- og tidsfunktioner, der er tilgængelige i disse DBMS'er.
Underforespørgsler
Det er muligt at have flere SELECT udsagn i en enkelt forespørgsel. Vi kan gøre dette ved at bruge en underforespørgsel.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Resultat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
I dette eksempel brugte vi IN operatør for at angive en underforespørgsel. Denne underforespørgsel valgte data fra en anden tabel og IN operatør relaterede det tilbage til den ydre forespørgsel.
Bestilling af resultaterne
Du kan bruge ORDER BY klausul for at sortere resultaterne.
For eksempel kunne vi sortere de tidligere resultater efter PetTypeId kolonne i faldende rækkefølge:
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets )
ORDER BY PetTypeId DESC;Resultat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 3 | Dog | | 2 | Cat | | 1 | Bird | +-------------+-----------+
Se SQL ORDER BY Klausul for begyndere for flere eksempler og en detaljeret forklaring.
Mere avanceret SELECT Erklæringer
SELECT statement er et meget simpelt udsagn, men det kan bruges til at oprette meget komplekse forespørgsler.
Her er en forespørgsel, der er lidt mere kompleks end de foregående.
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;Resultat:
+-----------+---------+ | PetType | Count | |-----------+---------| | Dog | 4 | | Cat | 3 | | Bird | 1 | +-----------+---------+
I en verden af SQL-forespørgsler er dette stadig ret simpelt, men det indeholder mange af de elementer, der ofte ses i mere komplekse forespørgsler.
For eksempel bruger denne forespørgsel en joinforbindelse til at hente data fra flere tabeller. Den bruger også GROUP BY klausul for at opdele rækkerne i grupper.
Se SQL GROUP BY Klausul for begyndere for flere eksempler på GROUP BY klausul.
Se SQL Joins Tutorial for at se, hvordan du henter data fra flere tabeller og returnerer dem som ét resultatsæt.
SELECT INTO Erklæring
Nogle DBMS'er understøtter SELECT INTO udmelding. Dette er lidt anderledes end de foregående eksempler, idet det påvirker dataene i databasen.
SELECT INTO sætning opretter en ny tabel og indsætter data i den fra en anden tabel.
Grundlæggende går det sådan her:
SELECT * INTO Table2
FROM Table1;
I dette eksempel opretter vi en ny tabel kaldet Tabel2 , og indsæt alle data fra Tabel1 ind i det. Tabel2 vil have samme definition som Tabel1 .
Se SQL SELECT INTO Udtalelse for flere eksempler.
Som jeg hentydede til, understøtter ikke alle DBMS'er denne erklæring. Hvis dit DBMS ikke understøtter SELECT INTO sætning, prøv at bruge CREATE TABLE ... AS SELECT erklæring i stedet for.
Disse udsagn opretter en ny tabel som en del af deres drift. For at indsætte data i en tabel, der allerede eksisterer, prøv at bruge INSERT INTO ... SELECT erklæring i stedet for.