Den här artikeln innehåller exempel på grundläggande SQL-frågor som nybörjare kan använda för att hämta data från sina databaser.
Grundläggande SELECT Fråga
Här är ett exempel på den kanske mest använda frågan i SQL:
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 | +---------+-------------+-----------+-----------+------------+
Den här frågan väljer alla rader och alla kolumner från Pets tabell. Detta beror på att asterisken (* ) jokertecken väljer alla kolumner.
Välj kolumnnamn
Av prestandaskäl är det vanligtvis bäst att undvika att välja alla kolumner om du inte verkligen behöver dem. Det är vanligtvis bättre att välja just de kolumner du behöver.
Här är ett exempel.
SELECT PetId, PetName
FROM Pets;Resultat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 3 | Scratch | | 4 | Wag | | 5 | Tweet | | 6 | Fluffy | | 7 | Bark | | 8 | Meow | +---------+-----------+
Filtrera resultaten
Du kan lägga till en WHERE för att filtrera resultaten till just de rader du behöver.
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';Resultat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 6 | Fluffy | +---------+-----------+
Här är ett annat exempel på filtrering av resultaten. Den här gången använder vi operatorn större än (> ) för att filtrera den efter datum.
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Resultat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Du kan byta ut operatorn större än till andra operatorer, till exempel operatorn större än eller lika med operatorn (>= ), mindre än operatorn (< ), eller mindre än eller lika med operatorn (<= ).
Du kan också använda BETWEEN operatorn för att filtrera resultaten till ett specifikt intervall (t.ex. mellan två datum).
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Resultat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Sortera resultaten
Du kan lägga till en ORDER BY sats för att sortera raderna som returneras av frågan.
Stigande ordning
Använd ASC nyckelord för att sortera resultaten i stigande ordning. Detta är standardvärdet, så du kan också utelämna detta nyckelord om du vill ha resultaten i stigande ordning.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;Eller:
SELECT PetId, PetName
FROM Pets
ORDER BY PetName;Resultat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+
Fallande ordning
Använd DESC nyckelord för att sortera resultaten i fallande ordning.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;Resultat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 4 | Wag | | 5 | Tweet | | 3 | Scratch | | 8 | Meow | | 1 | Fluffy | | 6 | Fluffy | | 2 | Fetch | | 7 | Bark | +---------+-----------+
Sortera efter flera kolumner
Du kan sortera efter flera kolumner genom att lista varje kolumn, separerade med kommatecken.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;Resultat:
+---------+-----------+ | 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)
Vi kan se att de två Fluffys har olika ordning i varje resultat (vi kan se genom att titta på deras PetId värden). Detta beror på att PetName kolumnen sorterades först, sedan PetId sorterade eventuella dubbletter från den första sorteringen.
Sortera efter dolda kolumner
Du kan sortera efter kolumner som inte ingår i SELECT lista.
SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;Resultat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 5 | Tweet | | 1 | Fluffy | | 6 | Fluffy | | 4 | Wag | | 2 | Fetch | | 3 | Scratch | | 7 | Bark | | 8 | Meow | +---------+-----------+
I det här fallet kan vi från dessa resultat dra slutsatsen att Tweet är det yngsta husdjuret och Meow är den äldsta. Detta beror på att vi sorterade efter deras födelsedatum (DOB ) kolumn i fallande ordning.
Bara för att vara säker, här är den igen med DOB kolumnen som ingår i SELECT lista.
SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;Resultat:
+---------+-----------+------------+ | 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 | +---------+-----------+------------+
Faktiskt kan vi nu se att Meow och Bark har NULL värden i DOB kolumn. Därför vet vi inte om de faktiskt är äldre eller yngre.
Men detta visar att NULL värden behandlas som lägsta möjliga värden. Var uppmärksam på NULL värden när du kör frågor.
Mönstermatchning
Du kan använda LIKE operatör för att använda mönstermatchning.
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';Resultat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 6 | Fluffy | +---------+-----------+
I det här exemplet söker vi efter alla husdjur vars namn börjar med bokstaven F . Procenttecknet (% ) är ett jokertecken som matchar en sträng med noll eller fler tecken. Det kan användas som antingen ett prefix eller ett suffix, och det kan också användas i mitten av en sträng.
Här är ett annat exempel.
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';Resultat:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Välj från en lista
IN operatorn bestämmer om ett angivet värde matchar något värde i en underfråga eller en lista.
Här är ett exempel.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Resultat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Undersökningar
Du kan använda IN operatorn när du utför en underfråga (en fråga kapslad i en annan fråga).
Här är ett exempel.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Resultat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Detta returnerade kolumner från en tabell (PetTypes ), men bara när det fanns minst en motsvarande rad i en annan tabell (Pets ) som hade ett matchande PetTypeId kolumn.
För att demonstrera detta ytterligare visas det relevanta innehållet i dessa två tabeller nedan.
PetTypes tabell:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+
Pets tabell:
+-------------+-----------+ | PetTypeId | PetName | |-------------+-----------| | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-------------+-----------+
Vi kan se att PetTypes Tabellen innehåller en husdjurstyp av Rabbit , men inget av husdjuren i Pets tabellen har tilldelats den typen (dvs. det finns inget värde på 4 i Pets.PetTypeId kolumn).
Se 12 vanliga SQL-operatorer och den här listan över SQL-operatorer för mer information om operatorer i SQL.
Gå med
Det kan diskuteras om SQL-kopplingar anses vara "grundläggande SQL-frågor", men jag kommer att inkludera en koppling här ändå.
Så för att avsluta den här artikeln, här är ett exempel på en inre koppling.
SELECT
p.PetName,
pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Resultat:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
I det här fallet använde vi en INNER JOIN att returnera alla husdjursnamn med sina respektive husdjurstyper. Vi använde ON sats för att specificera predikatet som ska utvärderas för varje par av sammanfogade rader. I det här fallet, p.PetTypeId kolumnen är en främmande nyckel för pt.PetTypeId kolumn, som är den primära nyckeln för PetTypes bord.
I det här exemplet använde jag även alias på tabellerna, vilket hjälpte till att hålla koden snygg och koncis.
Se min självstudie för SQL Joins för fler exempel på joins.