Wewnętrzne złącze SQL

Ten artykuł zawiera omówienie INNER JOIN w SQL, a także kilka podstawowych przykładów.

SQL INNER JOIN zwraca wiersze, gdy w obu tabelach znajduje się co najmniej jeden wiersz, który spełnia warunek złączenia. Odrzuca niedopasowane wiersze z obu tabel. To jest domyślny typ przyłączenia.

Składnia

Istnieją dwa sposoby określenia sprzężenia wewnętrznego:w FROM klauzula (za pomocą INNER JOIN składni) lub za pomocą WHERE klauzula.

Aby określić sprzężenie wewnętrzne w FROM klauzula:

SELECT *
FROM Table1 INNER JOIN Table2 
ON Table1.Column = Table2.Column;

Aby określić sprzężenie wewnętrzne w WHERE klauzula:

SELECT *
FROM Table1, Table2 
WHERE Table1.Column = Table2.Column;

Poniżej znajdują się przykłady każdego z nich.

Przykłady

Tutaj mamy przykłady dla każdej metody określania sprzężenia wewnętrznego.

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              |
+-----------+-------------+------------+----------------+-------------------+

Pamiętaj, że:

• PetTypeId kolumna Pets tabela jest kluczem obcym PetTypeId PetTypes tabela (która jest kluczem podstawowym tej tabeli).
• OwnerId kolumna Pets tabela jest kluczem obcym OwnerId kolumna Owners stół.

Przykład użycia składni INNER JOIN

Oto podstawowy przykład określenia sprzężenia wewnętrznego za pomocą INNER JOIN składnia.

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       |
+-----------+-----------+
(8 rows affected)

Aby określić sprzężenie wewnętrzne w FROM klauzula, używamy INNER JOIN . Używamy również ON słowo kluczowe, aby zdefiniować predykat do oceny dla każdej pary połączonych wierszy.

Niezależnie od typu sprzężenia kwalifikujemy nazwy naszych kolumn nazwami tabel. Powodem, dla którego to robimy, jest uniknięcie niejasności dotyczących nazw kolumn między tabelami. Obie tabele mogą mieć kolumny o tej samej nazwie (jak w naszym przykładzie), a w takich przypadkach DBMS nie będzie wiedział, do której kolumny się odnosisz. Poprzedzenie nazw kolumn ich nazwami tabel gwarantuje, że odwołujesz się do właściwej kolumny i zapobiega wszelkim błędom, które mogą wynikać z jakichkolwiek niejasności co do kolumny, do której się odnosisz.

W tym przykładzie obie tabele mają PetTypeId kolumna. Pets.PetTypeId kolumna jest kluczem obcym do PetTypes.PetTypeId kolumna, która jest kluczem podstawowym dla tej tabeli.

W tym przykładzie widzimy, że zwracane są wszystkie zwierzęta, ale nie wszystkie typy zwierząt. W Pets nie ma królików tabela, a więc Rabbits typ zwierzaka nie jest zwracany.

Powód, dla którego Rabbits typ nie jest zwracany, ponieważ INNER JOIN zwraca wiersze tylko wtedy, gdy w obu tabelach znajduje się co najmniej jeden wiersz, który spełnia warunek złączenia. W tym przypadku Rabbits znajduje się tylko w jednej tabeli (PetTypes tabeli).

Typ połączenia jest opcjonalny

Zauważ, że typ łączenia jest opcjonalny. Dlatego większość (jeśli nie wszystkie) DBMS pozwala na pominięcie INNER słowo kluczowe. Gdy to pominiesz (tzn. określ tylko JOIN ), zakłada się, że jest to sprzężenie wewnętrzne.

Dlatego możemy przepisać powyższy przykład do tego:

SELECT
    Pets.PetName,
    PetTypes.PetType
FROM Pets
JOIN PetTypes
ON Pets.PetTypeId = PetTypes.PetTypeId;

Formatowanie

Podobnie jak w przypadku każdej instrukcji SQL, możesz użyć białych znaków, wcięć itp. do formatowania zapytań.

Na przykład FROM klauzula może znajdować się w jednym wierszu, jeśli wolisz:

SELECT
    Pets.PetName,
    PetTypes.PetType
FROM Pets JOIN PetTypes ON Pets.PetTypeId = PetTypes.PetTypeId;

Kiedy piszesz większe tabele, które łączą wiele tabel, wcięcia mogą bardzo pomóc.

Przykład użycia klauzuli WHERE

Powyższe złączenie może być również określane jako equi-join . Złączenie ekwiwalentne to złączenie zawierające tylko porównania równości w predykacie złączenia.

Oto przykład określenia sprzężenia wewnętrznego za pomocą WHERE klauzula:

SELECT
    p.PetName,
    pt.PetType
FROM 
    Pets p, 
    PetTypes pt
WHERE 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)

Zwróciło to ten sam wynik, co w poprzednim przykładzie.

Tutaj po prostu udostępniliśmy listę tabel oddzielonych przecinkami, a następnie WHERE stan :schorzenie. Gdybyśmy pominęli WHERE warunek, otrzymalibyśmy CROSS JOIN .

Dla wielu początkujących powyższa składnia jest znacznie łatwiejsza do zrozumienia niż INNER JOIN składnia. Jeśli wolisz, możesz użyć tej składni, jednak pamiętaj, że większość specjalistów SQL woli używać INNER JOIN składnia z poprzedniego przykładu..

Złączenie wewnętrzne na 3 stołach

Oto przykład wykonania sprzężenia wewnętrznego na 3 stołach.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p INNER JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
INNER JOIN Owners o 
    ON p.OwnerId = o.OwnerId;

Wynik:

+-----------+-----------+---------------+
| PetName   | PetType   | PetOwner      |
|-----------+-----------+---------------|
| Fluffy    | Cat       | Nancy Simpson |
| Fetch     | Dog       | Nancy Simpson |
| Scratch   | Cat       | Bart Pitt     |
| Wag       | Dog       | Nancy Simpson |
| Tweet     | Bird      | Homer Connery |
| Fluffy    | Dog       | Boris Trump   |
| Bark      | Dog       | Bart Pitt     |
| Meow      | Cat       | Boris Trump   |
+-----------+-----------+---------------+
(8 rows affected)

W tym przykładzie wprowadziliśmy Owners tabeli do miksu, ponieważ potrzebowaliśmy tego zapytania, aby zwrócić informacje o właścicielu.

Aby użyć trzeciej tabeli, wystarczyło dodać kolejne INNER JOIN... ON argument wraz z odpowiednimi szczegółami tabeli/kolumny.

W tym przypadku użyłem CONCAT() T-SQLa funkcja łączenia dwóch kolumn, ale nie ma to znaczenia dla łączenia.