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 | example@sqldat.com | | Bart | Pitt | example@sqldat.com | +-------------+------------+-------------------+
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.