Ten artykuł zawiera przykłady podstawowych zapytań SQL, których początkujący mogą używać do pobierania danych ze swoich baz danych.
Podstawowy SELECT Zapytanie
Oto przykład prawdopodobnie najczęściej używanego zapytania w SQL:
SELECT *
FROM Pets;Wynik:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+
To zapytanie wybiera wszystkie wiersze i wszystkie kolumny z Pets stół. Dzieje się tak, ponieważ gwiazdka (* ) symbol wieloznaczny zaznacza wszystkie kolumny.
Wybierz nazwy kolumn
Ze względu na wydajność zazwyczaj najlepiej jest unikać wybierania wszystkich kolumn, chyba że naprawdę ich potrzebujesz. Zwykle lepiej jest wybrać tylko te kolumny, których potrzebujesz.
Oto przykład.
SELECT PetId, PetName
FROM Pets;Wynik:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 3 | Scratch | | 4 | Wag | | 5 | Tweet | | 6 | Fluffy | | 7 | Bark | | 8 | Meow | +---------+-----------+
Filtruj wyniki
Możesz dodać WHERE klauzula, aby filtrować wyniki tylko do potrzebnych wierszy.
SELECT PetId, PetName
FROM Pets
WHERE PetName = 'Fluffy';Wynik:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 6 | Fluffy | +---------+-----------+
Oto kolejny przykład filtrowania wyników. Tym razem używamy operatora większego niż (> ), aby filtrować według daty.
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 | +-----------+------------+
Możesz zamienić operator większy niż na inne operatory, takie jak operator większy lub równy (>= ), mniej niż operator (< ) lub mniejsze lub równe operatorowi (<= ).
Możesz także użyć BETWEEN operator do filtrowania wyników do określonego zakresu (np. 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 | +-----------+------------+
Posortuj wyniki
Możesz dodać ORDER BY klauzula do sortowania wierszy zwracanych przez zapytanie.
Kolejność rosnąco
Użyj ASC słowo kluczowe, aby posortować wyniki w porządku rosnącym. Jest to wartość domyślna, więc możesz również pominąć to słowo kluczowe, jeśli chcesz uzyskać wyniki w kolejności rosnącej.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC;Lub:
SELECT PetId, PetName
FROM Pets
ORDER BY PetName;Wynik:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 7 | Bark | | 2 | Fetch | | 1 | Fluffy | | 6 | Fluffy | | 8 | Meow | | 3 | Scratch | | 5 | Tweet | | 4 | Wag | +---------+-----------+
Kolejność malejąca
Użyj DESC słowo kluczowe, aby posortować wyniki w kolejności malejącej.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName DESC;Wynik:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 4 | Wag | | 5 | Tweet | | 3 | Scratch | | 8 | Meow | | 1 | Fluffy | | 6 | Fluffy | | 2 | Fetch | | 7 | Bark | +---------+-----------+
Sortuj według wielu kolumn
Możesz sortować według wielu kolumn, wymieniając każdą kolumnę oddzieloną przecinkiem.
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId ASC;
SELECT PetId, PetName
FROM Pets
ORDER BY PetName ASC, PetId DESC;Wynik:
+---------+-----------+ | 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)
Widzimy, że dwa puszyste są w innej kolejności w każdym wyniku (możemy to stwierdzić, patrząc na ich PetId wartości). Dzieje się tak, ponieważ PetName kolumna została posortowana jako pierwsza, a następnie PetId posortował wszystkie duplikaty z pierwszego sortowania.
Sortuj według ukrytych kolumn
Możesz sortować według kolumn, które nie są uwzględnione w SELECT lista.
SELECT PetId, PetName
FROM Pets
ORDER BY DOB DESC;Wynik:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 5 | Tweet | | 1 | Fluffy | | 6 | Fluffy | | 4 | Wag | | 2 | Fetch | | 3 | Scratch | | 7 | Bark | | 8 | Meow | +---------+-----------+
W takim przypadku możemy wywnioskować z tych wyników, że Tweet jest najmłodszym zwierzakiem, a Meow jest najstarszy. Dzieje się tak, ponieważ posortowaliśmy według ich daty urodzenia (DOB ) kolumna w porządku malejącym.
Dla pewności, oto znowu z DOB kolumna zawarta w SELECT lista.
SELECT PetId, PetName, DOB
FROM Pets
ORDER BY DOB DESC;Wynik:
+---------+-----------+------------+ | 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 | +---------+-----------+------------+
Właściwie teraz widzimy, że Meow i Bark mają NULL wartości w DOB kolumna. Dlatego nie wiemy, czy faktycznie są starsi czy młodsi.
Ale to pokazuje, że NULL wartości są traktowane jako najniższe możliwe wartości. Uważaj na NULL wartości podczas uruchamiania zapytań.
Dopasowanie wzorca
Możesz użyć LIKE operatora, aby użyć dopasowywania wzorców.
SELECT PetId, PetName
FROM Pets
WHERE PetName LIKE 'F%';Wynik:
+---------+-----------+ | PetId | PetName | |---------+-----------| | 1 | Fluffy | | 2 | Fetch | | 6 | Fluffy | +---------+-----------+
W tym przykładzie szukamy wszystkich zwierząt, których imiona zaczynają się na literę F . Znak procentowy (% ) to znak wieloznaczny, który pasuje do dowolnego ciągu składającego się z zera lub większej liczby znaków. Może być używany jako prefiks lub sufiks, a także może być używany w środku ciągu.
Oto kolejny przykład.
SELECT FirstName, LastName, Email
FROM Owners
WHERE Email LIKE '%@example.%';Wynik:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | example@sqldat.com | | Bart | Pitt | example@sqldat.com | +-------------+------------+-------------------+
Wybierz z listy
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 | +---------+-----------+------------+
Podzapytania
Możesz użyć IN operator podczas wykonywania podzapytania (zapytanie zagnieżdżone w innym zapytaniu).
Oto przykład.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Wynik:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
To zwróciło kolumny z jednej tabeli (PetTypes ), ale tylko wtedy, gdy w innej tabeli był przynajmniej jeden odpowiedni wiersz (Pets ), który miał pasujący PetTypeId kolumna.
Aby dokładniej to zademonstrować, poniżej przedstawiono odpowiednią zawartość tych dwóch tabel.
PetTypes tabela:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+
Pets tabela:
+-------------+-----------+ | PetTypeId | PetName | |-------------+-----------| | 2 | Fluffy | | 3 | Fetch | | 2 | Scratch | | 3 | Wag | | 1 | Tweet | | 3 | Fluffy | | 3 | Bark | | 2 | Meow | +-------------+-----------+
Widzimy, że PetTypes tabela zawiera typ zwierzaka Rabbit , ale żadne ze zwierząt w Pets tabeli zostały przypisane tego typu (tzn. nie ma wartości 4 w Pets.PetTypeId kolumna).
Zobacz 12 często używanych operatorów SQL i tę listę operatorów SQL, aby uzyskać więcej informacji o operatorach w SQL.
Dołączenia
Można się spierać, czy złączenia SQL są uważane za „podstawowe zapytania SQL”, ale i tak dołączę tutaj.
Aby zakończyć ten artykuł, oto przykład sprzężenia wewnętrznego.
SELECT
p.PetName,
pt.PetType
FROM Pets p
INNER JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Wynik:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+
W tym przypadku użyliśmy INNER JOIN aby zwrócić wszystkie imiona zwierzaków z odpowiadającymi im typami zwierzaków. Użyliśmy ON klauzula określająca predykat do oceny dla każdej pary połączonych wierszy. W tym przypadku p.PetTypeId kolumna jest kluczem obcym pt.PetTypeId kolumna, która jest kluczem podstawowym dla PetTypes tabela.
W tym przykładzie użyłem również aliasów na tabelach, co pomogło zachować ładny i zwięzły kod.
Więcej przykładów złączeń znajdziesz w moim samouczku SQL Joins.
