SELECT satsen är nästan utan tvekan den mest använda satsen i SQL.
SELECT uttalande används för att hämta data från databasen. Du kan ange vilka rader du vill returnera och vilka kolumner.
Exempel
Här är ett exempel för att demonstrera SELECT uttalande.
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 det här exemplet använde vi asterisken (* ) jokertecken för att returnera alla kolumner. Vi använde också FROM sats för att specificera vilken tabell data ska hämtas från.
Så den här frågan returnerar alla rader och alla kolumner från Pets bord.
Ange kolumnerna
Du kan ange vilka kolumner du vill ha returnerat.
För att göra detta, byt ut asteriskens jokertecken med kolumnnamnen, var och en avgränsade med ett kommatecken, i den ordning du vill att de ska returneras.
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 allmänt som god praxis att göra på det här sättet och bara returnera de kolumner som du faktiskt behöver. Att använda asteriskens jokertecken för att returnera alla kolumner kan ha en negativ inverkan på prestanda, särskilt i större databaser.
Ange raderna
Det finns många sätt att filtrera resultaten till just de rader du är intresserad av. Det vanligaste sättet är att använda WHERE klausul. Den här klausulen låter dig ange ett villkor som en rad måste uppfylla för att kvalificera sig.
Här är ett exempel att visa.
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Resultat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
I vårt fall fanns det två rader som uppfyllde vårt sökvillkor.
Vårt sökvillkor använder lika-operatorn (= ) för att ange att värdet för PetName kolumnen måste matcha det angivna värdet (Fluffy ) exakt.
Det finns många andra operatorer som du kan använda i dina sökvillkor. Till exempel kan du använda LIKE operatör för att returnera husdjur vars namn börjar med F eller Fluff eller vad som helst.
Du kan lägga till fler villkor i WHERE sats genom att använda operatorer som AND och OR operatörer.
Här är ett exempel.
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 det här exemplet returnerade vi alla rader där husdjurets namn är Fluffy eller där husdjurets födelsedatum (anges i DOB). kolumn) är mindre än ett visst datum. Vi använde mindre än-operatorn (< ) för att ange det.
Returnera icke-tabelldata
SELECT uttalande kan också användas för att returnera data som inte är lagrade i en tabell. Det är till exempel helt lagligt att göra detta:
SELECT 'Hey there!';Resultat:
+--------------------+ | (No column name) | |--------------------| | Hey there! | +--------------------+
Lägg märke till att när vi gör det har kolumnen inget namn. Vi skulle kunna använda ett alias för att ge ett namn till det resulterande fältet.
Här är några fler exempel på att välja icke-tabelldata och tillhandahålla ett alias för varje returnerat fält:
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 | +---------+--------------+-----------------------------+
Här är en snabb sammanfattning:
- Den första kolumnen lade helt enkelt till två siffror.
- Den andra kolumnen sammanlänkade tre strängar (inklusive ett blanksteg). Du kan också sammanfoga strängar med siffror om det behövs.
- Den tredje kolumnen använde
SYSDATETIME()funktion för att returnera aktuellt datum och tid. Denna funktion är tillgänglig i SQL Server. Andra DBMS har sina egna datum- och tidsfunktioner. Se SQLite Date/Time Functions, SQL Server Date/Time Functions och PostgreSQL Date/Time Functions för en lista över datum- och tidsfunktioner som är tillgängliga i dessa DBMS.
Undersökningar
Det är möjligt att ha flera SELECT uttalanden i en enda fråga. Vi kan göra detta med hjälp av en underfråga.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Resultat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
I det här exemplet använde vi IN operatör för att ange en underfråga. Den underfrågan valde data från en annan tabell och IN operatören kopplade det tillbaka till den yttre frågan.
Beställa resultaten
Du kan använda ORDER BY klausul för att sortera resultaten.
Till exempel kan vi sortera de tidigare resultaten efter PetTypeId kolumn i fallande ordning:
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 för nybörjare för fler exempel och en detaljerad förklaring.
Mer avancerad SELECT Uttalanden
SELECT uttalande är ett mycket enkelt uttalande, men det kan användas för att skapa mycket komplexa frågor.
Här är en fråga som är något mer komplex än de tidigare.
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 värld av SQL-frågor är detta fortfarande ganska enkelt, men det innehåller många av de element som ofta ses i mer komplexa frågor.
Till exempel använder den här frågan en koppling för att hämta data från flera tabeller. Den använder också GROUP BY sats för att dela in raderna i grupper.
Se SQL GROUP BY Klausul för nybörjare för fler exempel på GROUP BY klausul.
Se självstudiekursen för SQL Joins för att se hur du hämtar data från flera tabeller och returnerar dem som en resultatuppsättning.
Koden SELECT INTO Uttalande
Vissa DBMS:er stöder SELECT INTO påstående. Detta skiljer sig något från de tidigare exemplen, eftersom det påverkar data i databasen.
SELECT INTO uttalande skapar en ny tabell och infogar data i den från en annan tabell.
I grund och botten går det så här:
SELECT * INTO Table2
FROM Table1;
I det här exemplet skapar vi en ny tabell som heter Table2 , och infoga all data från Table1 Gillar det. Table2 kommer att ha samma definition som Table1 .
Se SQL SELECT INTO Uttalande för fler exempel.
Som jag antydde, stöder inte alla DBMS detta påstående. Om din DBMS inte stöder SELECT INTO testa att använda CREATE TABLE ... AS SELECT uttalande istället.
Dessa uttalanden skapar en ny tabell som en del av deras operation. För att infoga data i en tabell som redan finns, försök använda INSERT INTO ... SELECT uttalande istället.