В SQL операторът е специален знак или ключова дума, указваща действие, което се извършва върху един или повече изрази.
SQL операторите са неразделна част от SQL и ни позволяват да пишем заявки, които връщат подходящи резултати.
В тази статия представям 12 от най-често използваните SQL оператори при писане на SQL заявки.
Равните (= ) Оператор
Операторът Equals (= ) е може би най-често използваният оператор в SQL. Той сравнява равенството на два израза. Дори ако не сте запознати само бегло със SQL, вероятно ще познавате този оператор.
Представете си, че имаме база данни за хотел за домашни любимци и искаме да получим информация за всички домашни любимци на име Fluffy.
В такъв случай бихме могли да направим това:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Резултат:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
Нашата заявка използва оператора Equals (= ), за да сравните равенството на стойността на PetName колона и низ Fluffy .
В нашия случай можем да видим, че хотелът за домашни любимци в момента има два домашни любимци, наречени Fluffy.
По-голямото от (> ) Оператор
Операторът по-голямо от (> ) сравнява два израза и връща TRUE ако левият операнд има стойност по-висока от десния операнд; в противен случай резултатът е FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Резултат:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
В този случай се сравнява стойността на DOB колона и датата 2020-01-01 за да видите дали DOB колоната е по-голяма.
По-малко от (< ) Оператор
Операторът по-малко от (< ) прави обратното. Той сравнява два израза и връща TRUE ако левият операнд има стойност по-ниска от десния операнд; в противен случай резултатът е FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Резултат:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
По-голямото от или равно на (>= ) Оператор
Операторът по-голямо от или равно на (>= ) сравнява два израза и връща TRUE ако левият операнд има стойност, по-голяма или равна на десния операнд; в противен случай връща FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Резултат:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Имайте предвид, че върна 2020-09-17 и всички дати по-големи от това. Ако бяхме използвали оператора по-голямо от (> ), само първите два реда биха били върнати.
По-малко или равно на (<= ) Оператор
Операторът по-малко или равен на (<= ) сравнява два израза и връща TRUE ако левият операнд има стойност, по-ниска или равна на десния операнд; в противен случай резултатът е FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Резултат:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Имайте предвид, че върна 2020-09-17 и всички дати по-малко от това. Ако бяхме използвали оператора по-малко от (< ), само първите три реда биха били върнати.
AND Оператор
AND оператор комбинира два булеви израза и връща TRUE когато и двата израза са TRUE .
Ето един пример.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Резултат:
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
В този случай получаваме само подробности за домашните любимци, където името им е Fluffy и датата им на раждане е между двете дати.
OR Оператор
OR оператор комбинира два булеви израза и връща TRUE когато някое от условията е TRUE .
Ето един пример.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Резултат:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Това е основно обратното на AND оператор. Ако използвахме AND , нямаше да бъдат върнати редове, защото не можем да имаме две различни стойности в една колона едновременно.
BETWEEN Оператор
BETWEEN оператор ни позволява да посочим диапазон за тестване. Например, можем да го използваме, за да върнем домашни любимци, които са родени между две дати.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Резултат:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
NOT Оператор
NOT Операторът отрича булев вход (той обръща стойността на всеки булев израз). Следователно връща TRUE когато изразът е FALSE .
Ето какво се случва, когато добавим NOT оператор към предишния ни пример.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Резултат:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Този път имаме всички други домашни любимци – домашните любимци, които не бяха родени между тези дати.
В MariaDB NOT е ограничен до отричане на IN , BETWEEN и EXISTS клаузи. Повечето други СУБД позволяват NOT за отричане на всеки израз.
IN Оператор
IN операторът определя дали дадена стойност съвпада с която и да е стойност в подзаявка или списък.
Ето един пример.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Резултат:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Можем да постигнем същия резултат, като използваме две OR оператори:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Въпреки това, IN operator е по-сбит начин да го направите. IN операторът е особено полезен, когато имате дълъг списък от стойности, с които да сравните.
IN операторът почти винаги се изпълнява по-бързо от множество OR оператори, особено при по-големи набори от данни.
Друго предимство на IN оператор, е, че може да съдържа друг SELECT списък. Това е известно като подзаявка . Подзаявката е заявка, която е вложена в друга заявка (или дори друга подзаявка).
Ето един пример.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Резултат:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Този пример ни показва колко вида домашни любимци има в нашия хотел за домашни любимци.
Можем да използваме NOT оператор, за да обърне това и да види колко вида домашни любимци не в нашия хотел за домашни любимци.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Резултат:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Така че нашата база данни съдържа домашен любимец тип Rabbit , но в момента нямаме зайци като домашни любимци.
+ и || Оператори за конкатенация на низове
+ и || Операторите за конкатенация на низове ви позволяват да свързвате низове. Конкатенацията на низове е операцията за свързване на низове от символи от край до край.
Причината, поради която изброих два оператора, които правят едно и също нещо, е, че + операторът се поддържа в SQL Server, а || операторът се поддържа в DB2, Oracle, PostgreSQL, SQLite.
Ето пример, който работи в SQL Server.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Резултат:
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
В този случай собствениците имат своето име и фамилия, съхранявани в различни колони. В нашия SELECT списък, ние първо ги извличаме поотделно, но също така ги извличаме отново, като използваме оператор за конкатенация, за да ги обединим заедно.
Има обаче няколко проблема с нашите резултати.
- Няма интервал между собственото и фамилното име.
- Няма име на колоната.
За щастие това е лесно за поправяне.
Можем да използваме същата операция на конкатенация, за да включим интервал между собственото и фамилното име.
И можем да използваме псевдоним на колона към конкатенирания резултат, за да предоставим име на колона в набора от резултати.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Резултат:
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Ако използвате DB2, Oracle, PostgreSQL, SQLite, сменете + за || и би трябвало да работи добре.
Ако използвате MySQL или MariaDB, ще трябва да използвате CONCAT() функция за конкатениране на низове.
LIKE Оператор
LIKE оператор ви позволява да правите съвпадение на шаблони. Той определя дали конкретен символен низ съответства на определен модел. Моделът може да включва обикновени знаци и заместващи знаци.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Резултат:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
В този пример използвах LIKE оператор във връзка с % заместващ знак за връщане на собственици, чиито имейл адреси завършват на .com .
Бонус оператор! % Оператор за заместващи знаци
% Операторът за заместващ знак съответства на всеки низ от нула или повече знака. Може да се използва като префикс или суфикс и може да се използва и в средата на низ.
Той има тенденция да се използва по-често като суфикс и има ограничена употреба в средата на шаблони, въпреки че има някои валидни случаи на използване в средата на шаблон, като например следното:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Резултат:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
В този случай не знаехме имейл адреса на Барт, но знаехме, че започва с [email protected] и завършва на .com . Затова успяхме да използваме LIKE във връзка с % заместващ знак за попълване на останалото.
Имайте предвид, че тази техника може да върне много неподходящи редове в зависимост от данните и начина, по който конструирате своя SQL израз.
Също така имайте предвид, че заявките, които съдържат LIKE клаузата може да работи много по-бавно от другите заявки и вероятно трябва да избягвате използването на LIKE клауза, освен ако наистина не се нуждаете от нея. Използване на % операторът като префикс може да бъде особено бавен.
Това не означава, че изобщо не трябва да го използвате. LIKE операторът е неразделна част от SQL и ще срещнете много сценарии, при които той ще бъде единствената опция (или поне най-добрата опция).
Още SQL оператори
Вижте пълния ми списък с SQL оператори за цял куп други оператори, които не са включени тук.
