Tento článek obsahuje příklady základních SQL dotazů, které mohou začátečníci použít k načtení dat ze svých databází.
Základní SELECT Dotaz
Zde je příklad možná nejběžněji používaného dotazu v SQL:
SELECT *
FROM Pets;Výsledek:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Tento dotaz vybere všechny řádky a všechny sloupce z Pets stůl. Je to proto, že hvězdička (* ) zástupný znak vybere všechny sloupce.
Vyberte Názvy sloupců
Z důvodu výkonu je obvykle nejlepší vyhnout se výběru všech sloupců, pokud je skutečně nepotřebujete. Obvykle je lepší vybrat pouze sloupce, které potřebujete.
Zde je příklad.
SELECT PetId, PetName
FROM Pets;Výsledek:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 3 | Scratch | | 4 | Wag | | 5 | Tweet | | 6 | Fluffy | | 7 | Bark | | 8 | Meow | +---------+-----------+
Filtrovat výsledky
Můžete přidat WHERE klauzule k filtrování výsledků pouze na řádky, které potřebujete.
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';Výsledek:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 6 | Fluffy | +---------+-----------+
Zde je další příklad filtrování výsledků. Tentokrát použijeme operátor větší než (> ) pro filtrování podle data.
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Výsledek:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Operátor větší než můžete zaměnit za jiné operátory, například operátor větší než nebo rovno (>= ), menší než operátor (< ), nebo menší nebo rovno operátoru (<= ).
Můžete také použít BETWEEN operátor pro filtrování výsledků na konkrétní rozsah (např. mezi dvěma daty).
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Výsledek:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Seřadit výsledky
Můžete přidat ORDER BY klauzule k řazení řádků, které jsou vráceny dotazem.
Vzestupně
Použijte ASC klíčové slovo pro seřazení výsledků ve vzestupném pořadí. Toto je výchozí hodnota, takže pokud chcete, aby byly výsledky ve vzestupném pořadí, můžete toto klíčové slovo také vynechat.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;Nebo:
SELECT PetId, PetName
FROM Pets
ORDER BY PetName;Výsledek:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+
Sestupné pořadí
Použijte DESC klíčové slovo pro seřazení výsledků v sestupném pořadí.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;Výsledek:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 4 | Wag | | 5 | Tweet | | 3 | Scratch | | 8 | Meow | | 1 | Fluffy | | 6 | Fluffy | | 2 | Fetch | | 7 | Bark | +---------+-----------+
Řadit podle více sloupců
Můžete třídit podle více sloupců uvedením každého sloupce odděleného čárkou.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;Výsledek:
+---------+-----------+ | 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)
Vidíme, že dva Fluffyové mají různé pořadí v každém výsledku (to zjistíme pohledem na jejich PetId hodnoty). Důvodem je PetName nejprve byl seřazen sloupec a poté PetId seřadí všechny duplikáty z prvního řazení.
Řadit podle skrytých sloupců
Můžete třídit podle sloupců, které nejsou zahrnuty v SELECT seznam.
SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;Výsledek:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 5 | Tweet | | 1 | Fluffy | | 6 | Fluffy | | 4 | Wag | | 2 | Fetch | | 3 | Scratch | | 7 | Bark | | 8 | Meow | +---------+-----------+
V tomto případě můžeme z těchto výsledků odvodit, že Tweet je nejmladší mazlíček a Meow je nejstarší. Je to proto, že jsme třídili podle jejich data narození (DOB ) sloupec v sestupném pořadí.
Pro jistotu zde je to znovu s DOB sloupec zahrnutý do SELECT seznam.
SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;Výsledek:
+---------+-----------+------------+ | 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 | +---------+-----------+------------+
Ve skutečnosti nyní vidíme, že Meow a Bark mají NULL hodnoty v DOB sloupec. Proto nevíme, jestli jsou ve skutečnosti starší nebo mladší.
Ale to ukazuje, že NULL hodnoty jsou považovány za nejnižší možné hodnoty. Pamatujte na NULL hodnoty při spouštění dotazů.
Párování vzorů
Můžete použít LIKE operátora k použití shody vzorů.
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';Výsledek:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 6 | Fluffy | +---------+-----------+
V tomto příkladu hledáme všechna domácí zvířata, jejichž jména začínají písmenem F . Znak procenta (% ) je zástupný znak, který odpovídá libovolnému řetězci nula nebo více znaků. Může být použit buď jako předpona, nebo jako přípona a může být také použit uprostřed řetězce.
Zde je další příklad.
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';Výsledek:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Vybrat ze seznamu
IN operátor určuje, zda zadaná hodnota odpovídá jakékoli hodnotě v poddotazu nebo seznamu.
Zde je příklad.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Výsledek:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Poddotazy
Můžete použít IN operátor při provádění dílčího dotazu (dotazu vnořeného do jiného dotazu).
Zde je příklad.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Výsledek:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
To vrátilo sloupce z jedné tabulky (PetTypes ), ale pouze v případě, že v jiné tabulce byl alespoň jeden odpovídající řádek (Pets ), který měl odpovídající PetTypeId sloupec.
Abychom to dále demonstrovali, příslušný obsah těchto dvou tabulek je uveden níže.
PetTypes tabulka:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+
Pets tabulka:
+-------------+-----------+ | PetTypeId | PetName | |-------------+-----------| | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-------------+-----------+
Vidíme, že PetTypes tabulka obsahuje typ domácího mazlíčka Rabbit , ale žádné z domácích mazlíčků v Pets tabulce byl přiřazen tento typ (tj. neexistuje žádná hodnota 4 v Pets.PetTypeId sloupec).
Další informace o operátorech v SQL naleznete v části 12 běžně používaných operátorů SQL a v tomto seznamu operátorů SQL.
Připojuje se
Je sporné, zda jsou SQL spojení považována za „základní SQL dotazy“, ale i tak sem spojení zahrnu.
Abychom tento článek uzavřeli, zde je příklad vnitřního spojení.
SELECT
p.PetName,
pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Výsledek:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
V tomto případě jsme použili INNER JOIN vrátit všechna jména zvířat s příslušnými typy zvířat. Použili jsme ON klauzule k určení predikátu, který má být vyhodnocen pro každý pár spojených řádků. V tomto případě p.PetTypeId sloupec je cizí klíč pt.PetTypeId sloupec, což je primární klíč pro PetTypes tabulka.
V tomto příkladu jsem také použil aliasy na tabulkách, což pomohlo udržet kód pěkný a stručný.
Další příklady spojení najdete v mém výukovém programu SQL Joins.