Denne artikel indeholder eksempler på grundlæggende SQL-forespørgsler, som begyndere kan bruge til at hente data fra deres databaser.
Grundlæggende SELECT
Forespørgsel
Her er et eksempel på den muligvis mest brugte forespørgsel 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 | +---------+-------------+-----------+-----------+------------+
Denne forespørgsel vælger alle rækker og alle kolonner fra Pets
bord. Dette skyldes, at stjernen (*
) jokertegn vælger alle kolonner.
Vælg kolonnenavne
Af præstationsmæssige årsager er det normalt bedst at undgå at vælge alle kolonner, medmindre du virkelig har brug for dem. Det er normalt bedre at vælge netop de kolonner, du har brug for.
Her er et eksempel.
SELECT PetId, PetName
FROM Pets;
Resultat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 3 | Scratch | | 4 | Wag | | 5 | Tweet | | 6 | Fluffy | | 7 | Bark | | 8 | Meow | +---------+-----------+
Filtrer resultaterne
Du kan tilføje en WHERE
klausul for at filtrere resultaterne til kun de rækker, du har brug for.
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';
Resultat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 6 | Fluffy | +---------+-----------+
Her er et andet eksempel på filtrering af resultaterne. Denne gang bruger vi større end-operatoren (>
) for at filtrere den efter dato.
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 bytte større end-operatoren til andre operatorer, såsom større end eller lig med operatoren (>=
), mindre end operator (<
), eller mindre end eller lig med operatoren (<=
).
Du kan også bruge BETWEEN
operatør for at filtrere resultaterne til et specifikt interval (f.eks. mellem to datoer).
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 | +-----------+------------+
Sortér resultaterne
Du kan tilføje en ORDER BY
klausul for at sortere de rækker, der returneres af forespørgslen.
Stigende rækkefølge
Brug ASC
nøgleord for at sortere resultaterne i stigende rækkefølge. Dette er standardværdien, så du kan også udelade dette søgeord, hvis du vil have resultaterne i stigende rækkefølge.
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 | +---------+-----------+
Faldende rækkefølge
Brug DESC
nøgleord for at sortere resultaterne i faldende rækkefølge.
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 | +---------+-----------+
Sortér efter flere kolonner
Du kan sortere efter flere kolonner ved at angive hver kolonne, adskilt af et komma.
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, at de to Fluffys har en forskellig rækkefølge i hvert resultat (vi kan se ved at se på deres PetId
værdier). Dette skyldes, at PetName
kolonnen blev sorteret først, derefter PetId
sorterede eventuelle dubletter fra den første sortering.
Sortér efter skjulte kolonner
Du kan sortere efter kolonner, der ikke er inkluderet i SELECT
liste.
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 dette tilfælde kan vi udlede af disse resultater, at Tweet
er det yngste kæledyr og Meow
er den ældste. Dette skyldes, at vi sorterede efter deres fødselsdato (DOB
) kolonne i faldende rækkefølge.
Bare for at være sikker, her er den igen med DOB
kolonne inkluderet i SELECT
liste.
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 | +---------+-----------+------------+
Faktisk kan vi nu se, at Meow og Bark har NULL
værdier i DOB
kolonne. Derfor ved vi ikke, om de faktisk er ældre eller yngre.
Men dette viser, at NULL
værdier behandles som de lavest mulige værdier. Vær opmærksom på NULL
værdier, når du kører forespørgsler.
Mønstertilpasning
Du kan bruge LIKE
operatør for at bruge mønstertilpasning.
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';
Resultat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 6 | Fluffy | +---------+-----------+
I dette eksempel søger vi efter alle kæledyr, hvis navne starter med bogstavet F
. Procenttegnet (%
) er et jokertegn, der matcher enhver streng med nul eller flere tegn. Det kan bruges som enten et præfiks eller et suffiks, og det kan også bruges i midten af en streng.
Her er endnu et eksempel.
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';
Resultat:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Vælg fra en liste
IN
operatoren bestemmer, om en specificeret værdi matcher en værdi i en underforespørgsel eller en liste.
Her er et eksempel.
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 | +---------+-----------+------------+
Underforespørgsler
Du kan bruge IN
operator, når du udfører en underforespørgsel (en forespørgsel indlejret i en anden forespørgsel).
Her er et eksempel.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );
Resultat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Dette returnerede kolonner fra én tabel (PetTypes
), men kun når der var mindst én tilsvarende række i en anden tabel (Pets
), der havde et matchende PetTypeId
kolonne.
For at demonstrere dette yderligere er det relevante indhold af disse to tabeller vist nedenfor.
PetTypes
tabel:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+
Pets
tabel:
+-------------+-----------+ | PetTypeId | PetName | |-------------+-----------| | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-------------+-----------+
Vi kan se, at PetTypes
tabel indeholder en kæledyrstype Rabbit
, men ingen af kæledyrene i Pets
tabel er blevet tildelt den type (dvs. der er ingen værdi af 4
i Pets.PetTypeId
kolonne).
Se 12 almindeligt anvendte SQL-operatører og denne liste over SQL-operatører for at få flere oplysninger om operatører i SQL.
Deltager
Det kan diskuteres, om SQL-joins betragtes som "grundlæggende SQL-forespørgsler", men jeg vil alligevel inkludere en join her.
Så for at runde denne artikel af, er her et eksempel på en indre sammenføjning.
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 dette tilfælde brugte vi en INNER JOIN
at returnere alle kæledyrsnavne med deres respektive kæledyrstyper. Vi brugte ON
klausul for at specificere prædikatet, der skal evalueres for hvert par af sammenføjede rækker. I dette tilfælde er p.PetTypeId
kolonnen er en fremmednøgle til pt.PetTypeId
kolonne, som er den primære nøgle til PetTypes
tabel.
I dette eksempel brugte jeg også aliaser på tabellerne, hvilket var med til at holde koden pæn og kortfattet.
Se min SQL Joins Tutorial for flere eksempler på joins.