W SQL operator jest znakiem specjalnym lub słowem kluczowym określającym akcję wykonywaną na jednym lub większej liczbie wyrażeń.
Operatory SQL są integralną częścią SQL i umożliwiają nam pisanie zapytań, które zwracają odpowiednie wyniki.
W tym artykule przedstawiam 12 najczęściej używanych operatorów SQL podczas pisania zapytań SQL.
Równe (= ) Operator
Operator równości (= ) jest prawdopodobnie najczęściej używanym operatorem w SQL. Porównuje równość dwóch wyrażeń. Nawet jeśli nie znasz języka SQL, prawdopodobnie znasz ten operator.
Wyobraź sobie, że mamy bazę danych dla hotelu dla zwierząt i chcemy uzyskać informacje o wszystkich zwierzakach o imieniu Fluffy.
W takim przypadku możemy to zrobić:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Wynik:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Nasze zapytanie używa operatora równości (= ), aby porównać równość wartości PetName kolumna i ciąg Fluffy .
W naszym przypadku widzimy, że hotel dla zwierząt ma obecnie dwa zwierzęta o nazwie Fluffy.
Większy niż (> ) Operator
Operator Większy niż (> ) porównuje dwa wyrażenia i zwraca TRUE jeśli lewy operand ma wartość wyższą niż prawy operand; w przeciwnym razie wynik to FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Wynik:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
W tym przypadku jest to porównanie wartości DOB kolumna i data 2020-01-01 aby sprawdzić, czy DOB kolumna jest większa.
Mniej niż (< ) Operator
Operator Mniej niż (< ) działa odwrotnie. Porównuje dwa wyrażenia i zwraca TRUE jeśli lewy operand ma wartość niższą niż prawy operand; w przeciwnym razie wynik to FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Wynik:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Większy lub równy (>= ) Operator
Operator większe niż lub równe (>= ) porównuje dwa wyrażenia i zwraca TRUE jeśli lewy operand ma wartość większą lub równą prawemu operandowi; w przeciwnym razie zwraca FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Wynik:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Zauważ, że zwrócił 2020-09-17 i wszystkie daty późniejsze. Gdybyśmy użyli operatora Większe niż (> ), zwrócone zostałyby tylko dwa pierwsze wiersze.
Mniejsze lub równe (<= ) Operator
Operator mniejsze niż lub równe (<= ) porównuje dwa wyrażenia i zwraca TRUE jeśli lewy operand ma wartość mniejszą lub równą prawemu operandowi; w przeciwnym razie wynik to FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Wynik:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Zauważ, że zwrócił 2020-09-17 i wszystkie daty mniej. Gdybyśmy użyli operatora Less Than (< ), zwrócone zostałyby tylko pierwsze trzy wiersze.
AND Operator
AND operator łączy dwa wyrażenia logiczne i zwraca TRUE gdy oba wyrażenia są TRUE .
Oto przykład.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Wynik:
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
W tym przypadku otrzymujemy tylko dane zwierząt, których imię to Puszysty i ich data urodzenia jest między tymi dwiema datami.
OR Operator
OR operator łączy dwa wyrażenia logiczne i zwraca TRUE gdy którykolwiek z warunków jest TRUE .
Oto przykład.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Wynik:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Jest to w zasadzie przeciwieństwo AND operator. Gdybyśmy użyli AND , nie zostałyby zwrócone żadne wiersze, ponieważ nie możemy jednocześnie mieć dwóch różnych wartości w jednej kolumnie.
BETWEEN Operator
BETWEEN Operator pozwala nam określić zakres do przetestowania. Na przykład możemy go użyć do zwrotu zwierząt urodzonych między dwiema datami.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Wynik:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
NOT Operator
NOT operator neguje dane wejściowe typu Boolean (odwraca wartość dowolnego wyrażenia Boolean). Dlatego zwraca TRUE gdy wyrażenie to FALSE .
Oto, co się stanie, gdy dodamy NOT operator do naszego poprzedniego przykładu.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Wynik:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Tym razem mamy wszystkie inne zwierzaki – te, których nie było urodzony między tymi datami.
W MariaDB NOT ogranicza się do zanegowania IN , BETWEEN i EXISTS klauzule. Większość innych DBMS zezwala na NOT aby zanegować dowolne wyrażenie.
IN Operator
IN operator określa, czy określona wartość pasuje do dowolnej wartości w podzapytaniu lub liście.
Oto przykład.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Wynik:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Ten sam wynik możemy osiągnąć, używając dwóch OR operatorzy:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Jednak IN operator jest bardziej zwięzłym sposobem na zrobienie tego. IN Operator jest szczególnie przydatny, gdy masz długą listę wartości, z którymi można porównywać.
IN operator prawie zawsze wykonuje się szybciej niż wiele OR operatorów, zwłaszcza na większych zbiorach danych.
Kolejna zaleta IN operator, może zawierać inny SELECT lista. Jest to znane jako podzapytanie . Podzapytanie to zapytanie zagnieżdżone w innym zapytaniu (lub nawet innym podzapytaniu).
Oto przykład.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Wynik:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Ten przykład pokazuje nam, ile rodzajów zwierząt znajduje się w naszym hotelu dla zwierząt.
Moglibyśmy użyć NOT operatora, aby odwrócić to i zobaczyć, ile typów zwierząt nie w naszym hotelu dla zwierząt.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Wynik:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Tak więc nasza baza danych zawiera rodzaj zwierzaka Rabbit , ale obecnie nie mamy żadnych królików jako zwierząt domowych.
+ i || Operatory konkatenacji ciągów
+ i || Operatory konkatenacji ciągów umożliwiają łączenie ciągów. Łączenie ciągów to operacja łączenia ciągów znaków od końca do końca.
Powodem, dla którego wymieniłem dwa operatory, które robią to samo, jest to, że + operator jest obsługiwany w SQL Server, a || operator jest obsługiwany w DB2, Oracle, PostgreSQL, SQLite.
Oto przykład, który działa w SQL Server.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Wynik:
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
W takim przypadku właściciele mają swoje imię i nazwisko przechowywane w różnych kolumnach. W naszym SELECT listy, najpierw pobieramy je pojedynczo, ale również pobieramy je ponownie, używając operatora konkatenacji, aby je połączyć.
Jest jednak kilka problemów z naszymi wynikami.
- Nie ma spacji między imieniem a nazwiskiem.
- Nie ma nazwy kolumny.
Na szczęście można to łatwo naprawić.
Możemy użyć tej samej operacji konkatenacji, aby wstawić spację między imieniem a nazwiskiem.
Możemy użyć aliasu kolumny do połączonego wyniku, aby podać nazwę kolumny w zestawie wyników.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Wynik:
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Jeśli używasz DB2, Oracle, PostgreSQL, SQLite, zamień + dla || i powinno działać dobrze.
Jeśli używasz MySQL lub MariaDB, musisz użyć CONCAT() funkcja do łączenia ciągów znaków.
LIKE Operator
LIKE operator pozwala na dopasowanie wzorca. Określa, czy określony ciąg znaków pasuje do określonego wzorca. Wzór może zawierać zwykłe znaki i symbole wieloznaczne.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Wynik:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
W tym przykładzie użyłem LIKE operator w połączeniu z % operator symboli wieloznacznych do zwracania właścicieli, których adresy e-mail kończą się na .com .
Operator bonusowy! % Operator wieloznaczny
% operator symboli wieloznacznych dopasowuje dowolny ciąg składający się z zera lub więcej znaków. Może być używany jako prefiks lub sufiks, a także może być używany w środku ciągu.
Zwykle jest używany jako sufiks i ma ograniczone zastosowanie w środku wzorców, chociaż istnieją pewne uzasadnione przypadki użycia go w środku wzorca, takie jak:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Wynik:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
W tym przypadku nie znaliśmy adresu e-mail Barta, ale wiedzieliśmy, że zaczyna się od [email protected] i zakończył się na .com . Dlatego mogliśmy użyć LIKE w połączeniu z % operator wieloznaczny, aby wypełnić resztę.
Pamiętaj, że ta technika może zwrócić wiele nieistotnych wierszy, w zależności od danych i sposobu konstruowania instrukcji SQL.
Należy również pamiętać, że zapytania zawierające LIKE klauzula może działać znacznie wolniej niż inne zapytania i prawdopodobnie powinieneś unikać używania LIKE klauzula, chyba że naprawdę tego potrzebujesz. Korzystanie z % operator jako prefiks może być szczególnie powolny.
Nie oznacza to, że w ogóle nie powinieneś go używać. LIKE Operator jest integralną częścią SQL i napotkasz wiele scenariuszy, w których będzie to jedyna opcja (lub przynajmniej najlepsza opcja).
Więcej operatorów SQL
Zobacz moją pełną listę operatorów SQL, aby znaleźć całą masę innych operatorów, które nie są tutaj uwzględnione.
