V SQL je operátor speciální znak nebo klíčové slovo určující akci, která se provádí s jedním nebo více výrazy.
Operátory SQL jsou nedílnou součástí SQL a umožňují nám psát dotazy, které vracejí relevantní výsledky.
V tomto článku uvádím 12 nejčastěji používaných SQL operátorů při psaní SQL dotazů.
Je rovno (= ) Operátor
Operátor se rovná (= ) je pravděpodobně nejběžněji používaný operátor v SQL. Porovnává rovnost dvou výrazů. I když jste s SQL jen matně obeznámeni, pravděpodobně tento operátor znáte.
Představte si, že máme databázi pro hotel pro domácí mazlíčky a chceme získat informace o všech mazlíčcích jménem Fluffy.
V tom případě bychom mohli udělat toto:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Výsledek:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Náš dotaz používá operátor rovná se (= ) k porovnání rovnosti hodnoty PetName sloupec a řetězec Fluffy .
V našem případě vidíme, že hotel pro domácí mazlíčky má v současnosti dva mazlíčky jménem Fluffy.
Větší než (> ) Operátor
Operátor větší než (> ) porovná dva výrazy a vrátí TRUE má-li levý operand hodnotu vyšší než pravý operand; jinak je výsledek FALSE .
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 | +-----------+------------+
V tomto případě se porovnává hodnota DOB sloupec a datum 2020-01-01 abyste zjistili, zda DOB sloupec je větší.
Méně než (< ) Operátor
Operátor menší než (< ) dělá opak. Porovná dva výrazy a vrátí TRUE má-li levý operand hodnotu nižší než pravý operand; jinak je výsledek FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Výsledek:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Větší než nebo rovno (>= ) Operátor
Operátor větší než nebo rovno (>= ) porovná dva výrazy a vrátí TRUE jestliže levý operand má hodnotu větší nebo rovnou pravému operandu; jinak vrátí FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Výsledek:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Všimněte si, že vrátil 2020-09-17 a všechna data větší než to. Pokud bychom použili operátor větší než (> ), byly by vráceny pouze první dva řádky.
Menší než nebo rovno (<= ) Operátor
Operátor menší nebo rovno (<= ) porovná dva výrazy a vrátí TRUE pokud má levý operand hodnotu nižší nebo rovnou pravému operandu; jinak je výsledek FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Výsledek:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Všimněte si, že vrátil 2020-09-17 a všechna data méně než to. Pokud bychom použili operátor Less Than (< ), byly by vráceny pouze první tři řádky.
AND Operátor
AND operátor kombinuje dva booleovské výrazy a vrací TRUE když jsou oba výrazy TRUE .
Zde je příklad.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Výsledek:
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
V tomto případě dostaneme pouze podrobnosti o mazlíčcích, jejichž jméno je Fluffy a jejich datum narození je mezi těmito dvěma daty.
OR Operátor
OR operátor kombinuje dva booleovské výrazy a vrací TRUE když je některá z podmínek TRUE .
Zde je příklad.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Výsledek:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Toto je v podstatě opak AND operátor. Pokud bychom použili AND , nebyly by vráceny žádné řádky, protože v jednom sloupci nemůžeme mít současně dvě různé hodnoty.
BETWEEN Operátor
BETWEEN operátor nám umožňuje specifikovat rozsah, který se má testovat. Můžeme jej například použít k vrácení domácích mazlíčků, kteří se narodili 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 | +-----------+------------+
NOT Operátor
NOT operátor neguje booleovský vstup (obrátí hodnotu libovolného booleovského výrazu). Proto vrací TRUE když je výraz FALSE .
Zde je to, co se stane, když přidáme NOT operátor k našemu předchozímu příkladu.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Výsledek:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Tentokrát jsme dostali všechny ostatní domácí mazlíčky – mazlíčky, které nebyly narození mezi těmito daty.
V MariaDB NOT je omezeno na negaci IN , BETWEEN a EXISTS doložky. Většina ostatních DBMS umožňuje NOT negovat jakýkoli výraz.
IN Operátor
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 | +---------+-----------+------------+
Stejného výsledku bychom mohli dosáhnout použitím dvou OR operátoři:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Nicméně IN operátor je stručnější způsob, jak to udělat. IN Operátor je zvláště výhodný, když máte dlouhý seznam hodnot, se kterými můžete porovnávat.
IN Operátor se téměř vždy provádí rychleji než více OR operátorů, zejména u větších datových souborů.
Další výhoda IN operátor je, že může obsahovat další SELECT seznam. Toto je známé jako poddotaz . Poddotaz je dotaz, který je vnořen do jiného dotazu (nebo dokonce jiného poddotazu).
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 | +-------------+-----------+
Tento příklad nám ukazuje, kolik druhů zvířat je v našem hotelu pro domácí mazlíčky.
Mohli bychom použít NOT operátora otočte a uvidíte, kolik typů mazlíčků ne je v našem zvířecím hotelu.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Výsledek:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Naše databáze tedy obsahuje zvířecí typ Rabbit , ale v současné době nemáme žádné králíky jako domácí mazlíčky.
Znaménko + a || Operátory zřetězení řetězců
+ a || Operátory zřetězení řetězců umožňují zřetězení řetězců. Zřetězení řetězců je operace spojování řetězců znaků end-to-end.
Důvod, proč jsem uvedl dva operátory, které dělají totéž, je ten, že + SQL Server podporuje operátor a || Operátor je podporován v DB2, Oracle, PostgreSQL, SQLite.
Zde je příklad, který funguje na serveru SQL.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Výsledek:
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
V tomto případě mají vlastníci své jméno a příjmení uloženo v různých sloupcích. V našem SELECT seznam, nejprve je načteme jednotlivě, ale také je znovu načteme pomocí operátoru zřetězení k jejich spojení.
S našimi výsledky je však několik problémů.
- Mezi jménem a příjmením není mezera.
- Není uveden žádný název sloupce.
Naštěstí to lze snadno opravit.
Můžeme použít stejnou operaci zřetězení k vložení mezery mezi křestní jméno a příjmení.
A ke zřetězenému výsledku můžeme použít alias sloupce, abychom v sadě výsledků poskytli název sloupce.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Výsledek:
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Pokud používáte DB2, Oracle, PostgreSQL, SQLite, zaměňte + pro || a mělo by to fungovat dobře.
Pokud používáte MySQL nebo MariaDB, budete muset použít CONCAT() funkce pro zřetězení řetězců.
LIKE Operátor
LIKE operátor umožňuje provádět porovnávání vzorů. Určuje, zda určitý řetězec znaků odpovídá zadanému vzoru. Vzor může obsahovat běžné znaky a zástupné znaky.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Výsledek:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
V tomto příkladu jsem použil LIKE operátor ve spojení s % zástupný operátor pro návrat vlastníků, jejichž e-mailové adresy končí na .com .
Bonusový operátor! % Operátor zástupných znaků
% Operátor zástupných znaků 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.
Obvykle se používá jako přípona a má omezené použití uprostřed vzorů, ačkoli existují některé platné případy použití pro jeho použití uprostřed vzoru, jako například následující:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Výsledek:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
V tomto případě jsme neznali bartovu e-mailovou adresu, ale věděli jsme, že začíná [email protected] a skončil na .com . Proto jsme mohli použít LIKE ve spojení s % zástupný operátor, který doplní zbytek.
Mějte na paměti, že tato technika může vrátit mnoho irelevantních řádků v závislosti na datech a na tom, jak vytvoříte svůj příkaz SQL.
Uvědomte si také, že dotazy, které obsahují LIKE klauzule může běžet mnohem pomaleji než jiné dotazy a pravděpodobně byste se měli vyhnout použití LIKE klauzule, pokud ji opravdu nepotřebujete. Pomocí % operátor jako prefix může být obzvláště pomalý.
To neznamená, že byste to neměli používat vůbec. LIKE operátor je nedílnou součástí SQL a setkáte se s mnoha scénáři, kdy to bude jediná možnost (nebo alespoň ta nejlepší).
Více operátorů SQL
Podívejte se na můj úplný seznam operátorů SQL pro celou řadu dalších operátorů, které zde nejsou zahrnuty.