Dit artikel bevat voorbeelden van standaard SQL-query's die beginners kunnen gebruiken om gegevens uit hun databases op te halen.
Basis SELECT Zoekopdracht
Hier is een voorbeeld van mogelijk de meest gebruikte query in SQL:
SELECT *
FROM Pets;Resultaat:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Deze zoekopdracht selecteert alle rijen en alle kolommen uit de Pets tafel. Dit komt omdat het sterretje (* ) jokerteken selecteert alle kolommen.
Kolomnamen selecteren
Om prestatieredenen is het meestal het beste om te voorkomen dat u alle kolommen selecteert, tenzij u ze echt nodig hebt. Het is meestal beter om alleen de kolommen te selecteren die u nodig heeft.
Hier is een voorbeeld.
SELECT PetId, PetName
FROM Pets;Resultaat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 3 | Scratch | | 4 | Wag | | 5 | Tweet | | 6 | Fluffy | | 7 | Bark | | 8 | Meow | +---------+-----------+
Filter de resultaten
U kunt een WHERE . toevoegen clausule om de resultaten te filteren naar alleen de rijen die u nodig hebt.
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';Resultaat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 6 | Fluffy | +---------+-----------+
Hier is nog een voorbeeld van het filteren van de resultaten. Deze keer gebruiken we de operator groter dan (> ) om het op datum te filteren.
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Resultaat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
U kunt de operator groter dan verwisselen voor andere operators, zoals de operator groter dan of gelijk aan (>= ), kleiner dan operator (< ), of kleiner dan of gelijk aan operator (<= ).
U kunt ook de BETWEEN . gebruiken operator om de resultaten te filteren op een specifiek bereik (bijvoorbeeld tussen twee datums).
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Resultaat:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Sorteer de resultaten
U kunt een ORDER BY . toevoegen om de rijen te sorteren die door de query worden geretourneerd.
Oplopende volgorde
Gebruik de ASC trefwoord om de resultaten in oplopende volgorde te sorteren. Dit is de standaardwaarde, dus u kunt dit zoekwoord ook weglaten als u de resultaten in oplopende volgorde wilt weergeven.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;Of:
SELECT PetId, PetName
FROM Pets
ORDER BY PetName;Resultaat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+
Aflopende volgorde
Gebruik de DESC trefwoord om de resultaten in aflopende volgorde te sorteren.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;Resultaat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 4 | Wag | | 5 | Tweet | | 3 | Scratch | | 8 | Meow | | 1 | Fluffy | | 6 | Fluffy | | 2 | Fetch | | 7 | Bark | +---------+-----------+
Sorteren op meerdere kolommen
U kunt sorteren op meerdere kolommen door elke kolom op te sommen, gescheiden door een komma.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;Resultaat:
+---------+-----------+ | 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)
We kunnen zien dat de twee Fluffy's in elk resultaat een andere volgorde hebben (we kunnen zien door te kijken naar hun PetId waarden). Dit komt omdat de PetName kolom werd eerst gesorteerd, daarna de PetId sorteerde eventuele duplicaten van de eerste sortering.
Sorteren op verborgen kolommen
U kunt sorteren op kolommen die niet zijn opgenomen in de SELECT lijst.
SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;Resultaat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 5 | Tweet | | 1 | Fluffy | | 6 | Fluffy | | 4 | Wag | | 2 | Fetch | | 3 | Scratch | | 7 | Bark | | 8 | Meow | +---------+-----------+
In dit geval kunnen we uit deze resultaten afleiden dat Tweet is het jongste huisdier, en Meow is de oudste. Dit komt omdat we hebben gesorteerd op hun geboortedatum (DOB ) kolom in aflopende volgorde.
Voor de zekerheid, hier is het weer met de DOB kolom opgenomen in de SELECT lijst.
SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;Resultaat:
+---------+-----------+------------+ | 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 | +---------+-----------+------------+
Eigenlijk kunnen we nu zien dat Meow en Bark NULL . hebben waarden in de DOB kolom. Daarom weten we niet of ze echt ouder of jonger zijn.
Maar dit toont aan dat NULL waarden worden behandeld als de laagst mogelijke waarden. Houd rekening met NULL waarden bij het uitvoeren van zoekopdrachten.
Patroonovereenkomst
U kunt de LIKE . gebruiken operator om patroonherkenning te gebruiken.
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';Resultaat:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 6 | Fluffy | +---------+-----------+
In dit voorbeeld zoeken we naar alle huisdieren waarvan de naam begint met de letter F . Het procentteken (% ) is een jokerteken dat overeenkomt met een reeks van nul of meer tekens. Het kan worden gebruikt als voorvoegsel of achtervoegsel, en het kan ook in het midden van een tekenreeks worden gebruikt.
Hier is nog een voorbeeld.
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';Resultaat:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Selecteer uit een lijst
De IN operator bepaalt of een opgegeven waarde overeenkomt met een waarde in een subquery of een lijst.
Hier is een voorbeeld.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Resultaat:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Subquery's
U kunt de IN . gebruiken operator bij het uitvoeren van een subquery (een query die in een andere query is genest).
Hier is een voorbeeld.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Resultaat:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Dit leverde kolommen op uit één tabel (PetTypes ), maar alleen als er minstens één corresponderende rij in een andere tabel was (Pets ) die een overeenkomst had met de PetTypeId kolom.
Om dit verder aan te tonen, wordt hieronder de relevante inhoud van deze twee tabellen weergegeven.
De PetTypes tafel:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+
De Pets tafel:
+-------------+-----------+ | PetTypeId | PetName | |-------------+-----------| | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-------------+-----------+
We kunnen zien dat de PetTypes tabel bevat een huisdiertype van Rabbit , maar geen van de huisdieren in de Pets tabel is dat type toegewezen (d.w.z. er is geen waarde van 4 in de Pets.PetTypeId kolom).
Zie 12 veelgebruikte SQL-operators en deze lijst met SQL-operators voor meer informatie over operators in SQL.
Doe mee
Het is discutabel of SQL-joins worden beschouwd als "basis SQL-query's", maar ik zal hier toch een join opnemen.
Dus om dit artikel af te ronden, hier is een voorbeeld van een inner join.
SELECT
p.PetName,
pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Resultaat:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
In dit geval gebruikten we een INNER JOIN om alle namen van huisdieren te retourneren met hun respectieve huisdiertypes. We gebruikten de ON om het predikaat op te geven dat moet worden geëvalueerd voor elk paar samengevoegde rijen. In dit geval is de p.PetTypeId kolom is een externe sleutel van de pt.PetTypeId kolom, de primaire sleutel voor de PetTypes tafel.
In dit voorbeeld heb ik ook aliassen op de tabellen gebruikt, wat hielp om de code mooi en beknopt te houden.
Zie mijn SQL Joins-zelfstudie voor meer voorbeelden van joins.