SQL Vnitřní spojení

Tento článek poskytuje přehled INNER JOIN v SQL a také některé základní příklady.

SQL INNER JOIN vrátí řádky, pokud je v obou tabulkách alespoň jeden řádek, který odpovídá podmínce spojení. Zahodí neshodné řádky z obou tabulek. Toto je výchozí typ spojení.

Syntaxe

Existují dva způsoby, jak určit vnitřní spojení:v FROM klauzule (pomocí INNER JOIN syntaxe), nebo pomocí WHERE doložka.

Chcete-li určit vnitřní spojení v FROM klauzule:

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

Chcete-li zadat vnitřní spojení v WHERE klauzule:

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

Níže jsou uvedeny příklady každého z nich.

Příklady

Zde máme příklady pro každou metodu určení vnitřního spojení.

Ukázková data

Za prvé, zde jsou tabulky, které použijeme pro příklady.

PetTypes tabulka:

+-------------+-----------+| PetTypeId | PetType ||-------------+-----------|| 1 | Pták || 2 | Kočka || 3 | Pes || 4 | Králík |+-------------+-----------+ (dotčené 4 řádky)

Pets tabulka:

+---------+-------------+-----------+---------- -+-------------+| PetId | PetTypeId | OwnerId | Jméno mazlíčka | DOB ||---------+-------------+-----------+------------ +------------|| 1 | 2 | 3 | Načechraný | 2020-11-20 || 2 | 3 | 3 | Načíst | 2019-08-16 || 3 | 2 | 2 | Škrábnout | 2018-10-01 || 4 | 3 | 3 | Wag | 2020-03-15 || 5 | 1 | 1 | Tweet | 2020-11-28 || 6 | 3 | 4 | Načechraný | 2020-09-17 || 7 | 3 | 2 | Kůra | NULL || 8 | 2 | 4 | Mňau | NULL |+---------+-------------+-----------+----------- +------------+(8 řádků ovlivněno)

Owners tabulka:

+-----------+-------------+------------+------- ---------+-------------------+| OwnerId   | Jméno   | Příjmení   | Telefon          | E-mail             ||-----------+-------------+-------------+-------- --------+-------------------|| 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              |+-----------+-------------+------------+--------- --------+-------------------+

Všimněte si, že:

PetTypeId ve sloupci Pets tabulka je cizí klíč PetTypeId z PetTypes tabulka (což je primární klíč této tabulky).
OwnerId ve sloupci Pets tabulka je cizí klíč OwnerId ve sloupci Owners stůl.

Příklad použití syntaxe INNER JOIN

Zde je základní příklad zadání vnitřního spojení pomocí INNER JOIN syntaxe.

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

Výsledek:

-----------+-----------+| Jméno mazlíčka | PetType ||-----------+-----------|| Načechraný | Kočka || Načíst | Pes || Škrábnout | Kočka || Wag | Pes || Tweet | Pták || Načechraný | Pes || Kůra | Pes || Mňau | Kočka |+-----------+-----------+ (8 řádků ovlivněno)

Chcete-li určit vnitřní spojení v FROM klauzule, používáme INNER JOIN . Používáme také ON klíčové slovo pro definování predikátu, který má být vyhodnocen pro každý pár spojených řádků.

Bez ohledu na typ spojení kvalifikujeme naše názvy sloupců názvy tabulek. Důvodem, proč to děláme, je vyhnout se jakékoli nejednoznačnosti ohledně názvů sloupců mezi tabulkami. Obě tabulky mohou mít sloupce se stejným názvem (jako v našem příkladu) a v takových případech DBMS nebude vědět, na který sloupec odkazujete. Přidání názvů sloupců před názvy jejich tabulek zajistí, že odkazujete na správný sloupec, a zabráníte jakýmkoli chybám, které by mohly vzniknout v důsledku nejasností ohledně toho, na který sloupec odkazujete.

V tomto příkladu mají obě tabulky PetTypeId sloupec. Pets.PetTypeId sloupec je cizí klíč k PetTypes.PetTypeId sloupec, což je primární klíč pro tuto tabulku.

V tomto příkladu vidíme, že jsou vrácena všechna domácí zvířata, ale ne všechny typy zvířat jsou vráceny. V Pets nejsou žádní králíci tabulka, a tedy Rabbits pet type není vrácen.

Důvodem jsou Rabbits typ není vrácen, protože INNER JOIN vrátí řádky pouze v případě, že v obou tabulkách existuje alespoň jeden řádek, který odpovídá podmínce spojení. V tomto případě Rabbits je pouze v jedné tabulce (PetTypes tabulka).

Typ připojení je volitelný

Všimněte si, že typ spojení je volitelný. Proto většina (pokud ne všechny) DBMS umožňuje vynechat INNER klíčové slovo. Když toto vynecháte (tj. zadejte pouze JOIN ), předpokládá se, že jde o vnitřní spojení.

Proto bychom mohli výše uvedený příklad přepsat na toto:

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

Formátování

Stejně jako u jakéhokoli příkazu SQL můžete k formátování dotazů použít mezery a odsazení atd.

Například FROM klauzule může být na jednom celém řádku, pokud chcete:

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

Když píšete větší tabulky, které spojují více tabulek, odsazení může hodně pomoci.

Příklad použití klauzule WHERE

Výše uvedené spojení může být také označováno jako equi-join . Rovnocenné spojení je spojení obsahující pouze porovnání rovnosti v predikátu spojení.

Zde je příklad zadání vnitřního spojení pomocí WHERE klauzule:

SELECT
    p.PetName,
    pt.PetType
FROM 
    Pets p, 
    PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId;

Výsledek:

+-----------+-----------+| Jméno mazlíčka   | PetType   ||-----------+-----------|| Načechraný    | Kočka       || Načíst     | Pes       || Scratch   | Kočka       || Wag       | Pes       || Tweet     | Pták      || Načechraný    | Pes       || Kůra      | Pes       || Mňau      | Kočka       |+-----------+-----------+ (8 řádků ovlivněno)

To vrátilo stejný výsledek jako předchozí příklad.

Zde jsme jednoduše poskytli čárkami oddělený seznam tabulek a poté WHERE stav. Pokud bychom vynechali WHERE stavu, skončili bychom s CROSS JOIN .

Pro mnoho začátečníků je výše uvedená syntaxe mnohem srozumitelnější než INNER JOIN syntax. Pokud chcete, klidně použijte tuto syntaxi, mějte však na paměti, že většina SQL profesionálů dává přednost použití INNER JOIN syntaxe z předchozího příkladu..

Vnitřní spojení na 3 stolech

Zde je příklad provedení vnitřního spojení na 3 tabulkách.

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;

Výsledek:

+-----------+-----------+---------------+| Jméno mazlíčka   | PetType   | Majitel zvířat      ||-----------+-----------+---------------|| Načechraný    | Kočka       | Nancy Simpson || Načíst     | Pes       | Nancy Simpson || Scratch   | Kočka       | Bart Pitt     || Wag       | Pes       | Nancy Simpson || Tweet     | Pták      | Homer Connery || Načechraný    | Pes       | Boris Trump   || Kůra      | Pes       | Bart Pitt     || Mňau      | Kočka       | Boris Trump   |+-----------+-----------+---------------+(8 řádků ovlivněno) 
 V tomto příkladu jsme přinesli Owners tabulku do mixu, protože jsme potřebovali, aby tento dotaz vrátil informace o vlastníkovi. 
 
 Abychom mohli použít třetí tabulku, vše, co jsme udělali, bylo přidat další INNER JOIN... ON argument spolu s příslušnými detaily tabulky/sloupce.
 
 V tomto případě jsem použil CONCAT() T-SQL funkce zřetězení dvou sloupců, ale to je pro spojení irelevantní.