Ten artykuł zawiera omówienie RIGHT JOIN w SQL, a także kilka podstawowych przykładów.
Znany również jako RIGHT OUTER JOIN , RIGHT JOIN zwraca wiersze, które mają dane w prawej tabeli (na prawo od JOIN słowa kluczowego), nawet jeśli w lewej tabeli nie ma pasujących wierszy.
Składnia
W polu FROM określasz prawidłowe sprzężenie klauzula. Możesz użyć opcji RIGHT JOIN lub RIGHT OUTER JOIN składnia.
Korzystanie z RIGHT JOIN składnia:
SELECT *
FROM Table1 RIGHT JOIN Table2
ON Table1.Column = Table2.Column;
Korzystanie z RIGHT OUTER JOIN składnia:
SELECT *
FROM Table1 RIGHT OUTER JOIN Table2
ON Table1.Column = Table2.Column;
Oba robią dokładnie to samo. Po prostu OUTER słowo kluczowe jest opcjonalne.
Przykłady
Oto kilka przykładów do zademonstrowania.
Przykładowe dane
Najpierw oto tabele, których użyjemy w przykładach.
PetTypes tabela:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | | 4 | Rabbit | +-------------+-----------+ (4 rows affected)
Pets tabela:
+---------+-------------+-----------+-----------+------------+ | 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 | +---------+-------------+-----------+-----------+------------+ (8 rows affected)
Owners tabela:
+-----------+-------------+------------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | |-----------+-------------+------------+----------------+-------------------| | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | +-----------+-------------+------------+----------------+-------------------+
Pamiętaj, że:
PetTypeIdkolumnaPetstabela jest kluczem obcymPetTypeIdPetTypestabela (która jest kluczem podstawowym tej tabeli).OwnerIdkolumnaPetstabela jest kluczem obcymOwnerIdkolumnaOwnersstół.
Właściwe zapytanie przyłączenia
Oto przykład wykonania prawidłowego sprzężenia w przypadku dwóch z tych tabel.
SELECT
p.PetName,
pt.PetType
FROM Pets p
RIGHT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Wynik:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Tweet | Bird | | Fluffy | Cat | | Scratch | Cat | | Meow | Cat | | Fetch | Dog | | Wag | Dog | | Fluffy | Dog | | Bark | Dog | | NULL | Rabbit | +-----------+-----------+ (9 rows affected)
Prawidłowe połączenie powoduje, że otrzymujemy PetType wartość, która nie odpowiada PetName . W szczególności nie ma królików jako zwierząt domowych. Ale prawidłowe połączenie powoduje, że Rabbit do zwrotu, nawet jeśli w Pets nie ma żadnego zwierzaka tabeli tego typu. Powoduje to NULL wartość w PetName kolumna przeciwko Rabbit .
Stało się tak tylko dlatego, że Rabbit znajdował się w prawej tabeli (tj. na prawo od RIGHT JOIN słowa kluczowe).
Oto, co się stanie, jeśli zmienimy kolejność tabel w naszym zapytaniu.
SELECT
p.PetName,
pt.PetType
FROM PetTypes pt
RIGHT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;Wynik:
+-----------+-----------+ | PetName | PetType | |-----------+-----------| | Fluffy | Cat | | Fetch | Dog | | Scratch | Cat | | Wag | Dog | | Tweet | Bird | | Fluffy | Dog | | Bark | Dog | | Meow | Cat | +-----------+-----------+ (8 rows affected)
Tym razem Rabbits nie został zwrócony. To dlatego, że jego tabela (PetTypes ) znajdował się po lewej stronie połączenia.
Musielibyśmy to zmienić na lewe lub pełne, jeśli chcielibyśmy Rabbits do zwrotu przy użyciu tej kolejności tabel.
Prawe dołączanie na 3 stołach
Oto przykład wykonania prawidłowego sprzężenia na wszystkich trzech stołach.
SELECT
p.PetName,
pt.PetType,
CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p RIGHT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId
RIGHT JOIN Owners o
ON p.OwnerId = o.OwnerId;Wynik:
+-----------+-----------+----------------+ | PetName | PetType | PetOwner | |-----------+-----------+----------------| | Tweet | Bird | Homer Connery | | Scratch | Cat | Bart Pitt | | Bark | Dog | Bart Pitt | | Fluffy | Cat | Nancy Simpson | | Fetch | Dog | Nancy Simpson | | Wag | Dog | Nancy Simpson | | Fluffy | Dog | Boris Trump | | Meow | Cat | Boris Trump | | NULL | NULL | Woody Eastwood | +-----------+-----------+----------------+ (9 rows affected)
Tym razem mamy właściciela zwierzaka, który nie ma zwierzaka.
Moglibyśmy ponownie przetasować kolejność stołów i otrzymalibyśmy inny wynik.
SELECT
p.PetName,
pt.PetType,
CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p RIGHT JOIN Owners o
ON p.OwnerId = o.OwnerId
RIGHT JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;Wynik:
+-----------+-----------+---------------+ | PetName | PetType | PetOwner | |-----------+-----------+---------------| | Tweet | Bird | Homer Connery | | Fluffy | Cat | Nancy Simpson | | Scratch | Cat | Bart Pitt | | Meow | Cat | Boris Trump | | Fetch | Dog | Nancy Simpson | | Wag | Dog | Nancy Simpson | | Fluffy | Dog | Boris Trump | | Bark | Dog | Bart Pitt | | NULL | Rabbit | | +-----------+-----------+---------------+ (9 rows affected)
Tym razem otrzymaliśmy dodatkowy typ zwierzaka (Rabbit ), ale nie dodatkowego właściciela.
Jeśli zastanawiasz się, dlaczego ostatni PetOwner nie jest NULL (jak ostatnio PetName jest), to dlatego, że jest wynikiem konkatenacji ciągów. Użyłem T-SQL CONCAT() funkcja łączenia imienia i nazwiska właściciela.
