Тази статия съдържа примери за основни SQL заявки, които начинаещите могат да използват за извличане на данни от своите бази данни.
Основни SELECT Запитване
Ето пример за вероятно най-често използваната заявка в SQL:
SELECT *
FROM Pets;Резултат:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
Тази заявка избира всички редове и всички колони от Pets маса. Това е така, защото звездичката (* ) заместващият знак избира всички колони.
Изберете имена на колони
От съображения за производителност обикновено е най-добре да избягвате да избирате всички колони, освен ако наистина не се нуждаете от тях. Обикновено е по-добре да изберете само колоните, от които се нуждаете.
Ето един пример.
SELECT PetId, PetName
FROM Pets;Резултат:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 3 | Scratch | | 4 | Wag | | 5 | Tweet | | 6 | Fluffy | | 7 | Bark | | 8 | Meow | +---------+-----------+
Филтрирайте резултатите
Можете да добавите WHERE клауза за филтриране на резултатите само до редовете, от които се нуждаете.
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';Резултат:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 6 | Fluffy | +---------+-----------+
Ето още един пример за филтриране на резултатите. Този път използваме оператора по-голямо от (> ), за да го филтрирате по дата.
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 | +-----------+------------+
Можете да размените оператора по-голямо от други оператори, като оператор по-голямо или равно на (>= ), по-малко от оператор (< ), или по-малко или равно на оператор (<= ).
Можете също да използвате 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 | +-----------+------------+
Сортирайте резултатите
Можете да добавите ORDER BY клауза за сортиране на редовете, които се връщат от заявката.
Възходящ ред
Използвайте ASC ключова дума, за да сортирате резултатите във възходящ ред. Това е стойността по подразбиране, така че можете също да пропуснете тази ключова дума, ако искате резултатите във възходящ ред.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;Или:
SELECT PetId, PetName
FROM Pets
ORDER BY PetName;Резултат:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+
Низходящ ред
Използвайте DESC ключова дума, за да сортирате резултатите в низходящ ред.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;Резултат:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 4 | Wag | | 5 | Tweet | | 3 | Scratch | | 8 | Meow | | 1 | Fluffy | | 6 | Fluffy | | 2 | Fetch | | 7 | Bark | +---------+-----------+
Сортиране по множество колони
Можете да сортирате по множество колони, като изброите всяка колона, разделена със запетая.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;Резултат:
+---------+-----------+ | 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)
Можем да видим, че двата Fluffys са в различен ред във всеки резултат (можем да разберем, като погледнем техния PetId стойности). Това е така, защото PetName колоната беше сортирана първо, след това PetId сортира всички дубликати от първото сортиране.
Сортиране по скрити колони
Можете да сортирате по колони, които не са включени в SELECT списък.
SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;Резултат:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 5 | Tweet | | 1 | Fluffy | | 6 | Fluffy | | 4 | Wag | | 2 | Fetch | | 3 | Scratch | | 7 | Bark | | 8 | Meow | +---------+-----------+
В този случай можем да заключим от тези резултати, че Tweet е най-младият домашен любимец и Meow е най-старият. Това е така, защото сортирахме по датата им на раждане (DOB ) колона в низходящ ред.
Само за да сме сигурни, ето го отново с DOB колона, включена в SELECT списък.
SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;Резултат:
+---------+-----------+------------+ | 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 | +---------+-----------+------------+
Всъщност сега можем да видим, че Meow и Bark имат NULL стойности в DOB колона. Следователно не знаем дали всъщност са по-възрастни или по-млади.
Но това демонстрира, че NULL стойностите се третират като най-ниските възможни стойности. Имайте предвид NULL стойности при изпълнение на заявки.
Съвпадение на шаблон
Можете да използвате LIKE оператор за използване на съвпадение на шаблони.
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';Резултат:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 6 | Fluffy | +---------+-----------+
В този пример търсим всички домашни любимци, чиито имена започват с буквата F . Знакът за процент (% ) е заместващ знак, който съответства на всеки низ от нула или повече знака. Може да се използва като префикс или суфикс и може да се използва и в средата на низ.
Ето още един пример.
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';Резултат:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
Изберете от списък
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 | +---------+-----------+------------+
Подзаявки
Можете да използвате IN оператор при изпълнение на подзаявка (заявка, вложена в друга заявка).
Ето един пример.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Резултат:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Това върна колони от една таблица (PetTypes ), но само когато има поне един съответен ред в друга таблица (Pets ), който има съвпадение на PetTypeId колона.
За да демонстрира това допълнително, съответното съдържание на тези две таблици е показано по-долу.
PetTypes таблица:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+
Pets таблица:
+-------------+-----------+ | PetTypeId | PetName | |-------------+-----------| | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-------------+-----------+
Можем да видим, че PetTypes таблицата съдържа тип домашен любимец Rabbit , но нито един от домашните любимци в Pets таблицата е присвоен този тип (т.е. няма стойност на 4 в Pets.PetTypeId колона).
Вижте 12 често използвани SQL оператори и този списък с SQL оператори за повече информация относно операторите в SQL.
Присъединява се
Може да се спори дали SQL присъединяванията се считат за „основни SQL заявки“, но все пак ще включа тук присъединяване.
За да завършим тази статия, ето пример за вътрешно присъединяване.
SELECT
p.PetName,
pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Резултат:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
В този случай използвахме INNER JOIN да върне всички имена на домашни любимци със съответните им типове домашни любимци. Използвахме ON клауза за определяне на предиката, който да бъде оценен за всяка двойка съединени редове. В този случай p.PetTypeId колоната е външен ключ на pt.PetTypeId колона, която е първичен ключ за PetTypes таблица.
В този пример използвах и псевдоними в таблиците, което помогна да запазим кода хубав и сбит.
Вижте моя урок за SQL Joins за повече примери за присъединяване.
