sql >> Database teknologi >  >> RDS >> Mysql

Introduktion til SQL Joins

Traditionelt trækker du data fra to eller flere tabeller ved hjælp af en WHERE klausul i en forespørgsel. Men i et relationsdatabasesystem (RDBMS) kan dette opnås ved hjælp af en enkelt SELECT forespørgsel. Dette er den sande kraft af relationelle databasesystemer. I denne guide lærer du om SQL Joins, en effektiv måde at sammenligne og vælge rækker og tabeller på.

Hvad er en SQL Join?

I SQL, en join klausul udvider muligheden for at sammenligne og vælge rækker fra tabeller. Den bruger en algebraisk proces til at kombinere rækker fra to eller flere tabeller baseret på en relateret kolonne i disse tabeller. I henhold til ANSI-standarden SQL-definition er der fem typer joins –Cross Joins , Indre sammenføjninger , venstre (ydre) joinforbindelser , Højre (ydre) sammenføjninger , og Fuld (ydre) tilslutning . Disse Joins er implementeret på tværs af alle relationelle databasesystemer og er dækket i sektionerne nedenfor.

Bemærk Joins kan udføres på et vilkårligt antal tabeller i en given forespørgsel. For kortheds skyld og klarhed diskuterer denne vejledning Joins anvendt på to tabeller.

Denne vejledning bruger to tabeller, Employees og Address , henholdsvis for at demonstrere SQL Joins. Hver af disse tabeller indeholder følgende kolonnedefinitioner og data:

  • Tabel med medarbejdere

    Medarbejder-id Medarbejdernavn
    1 John
    2 Mary
    3 Robert
  • Adressetabel

    Id State
    1 New York
    2 New Jersey
    3 Idaho
    4 Hawaii
Bemærk Medmindre andet er nævnt, fungerer alle kommandoerne i denne guide godt på både MySQL og PostgreSQL databaser.

SQL Cross Joins

Også kendt som en Cartesian Join , Cross Joins opstår, når du angiver flere tabeller som en kilde til din SELECT kolonneliste. I dette tilfælde udelader du WHERE klausul join-udtryk for at matche rækker på. Resultatsættet indeholder en række for hver kombination af rækker mellem tabellerne. I et scenarie med to tabeller er hver række i den ene tabel parret med hver række i den anden tabel. Det resulterende produkt er kendt som det kartesiske produkt af de to borde. Syntaksen for en Cross Join er følgende:

(# Rows in Table A) TIMES (# of Rows in Table B)
 
Bemærk

I mængdeteori er det kartesiske produkt en multiplikationsoperation, der genererer alle ordnede par af de givne sæt. Overvej f.eks. sæt A med elementerne {a,b} og indstil B med elementerne {1,2,3} . Det kartesiske produkt af A og B er angivet med AxB og resultatet er følgende:

AxB ={(a,1), (a,2), (a,3), (b,1), (b,2), (b,3)}
 

SQL-syntaksen for en Cross Join er som følger:

SELECT ColumnName_1,
       ColumnName_2,
       ColumnName_N
FROM [Table_1]
     CROSS JOIN [Table_2]
 

Fra ovenstående syntaks, Column_1 , Column_2 , Column_N repræsentere kolonnerne i en tabel og CROSS JOIN klausul tjener til at kombinere de to tabeller, Table_1 og Table_2 . Fra eksempeltabellerne ovenfor, hvis du har brug for at udføre en Cross Join på Employees og Address tabeller, skal du bruge følgende SQL-kode:

SELECT EmployeeName, State
FROM Employees
CROSS JOIN Address
 

Outputtet af ovenstående SQL-kode ligner følgende:

+--------------+--------------+ | EmployeeName | State | +---------------+-------------+ | John | New York | | John | New Jersey | | John | Idaho | | John | Hawaii | | John | New York | | Mary | New York | | Mary | New Jersey | | Mary | Idaho | | Mary | Hawaii | | Robert | New York | | Robert | New Jersey | | Robert | Idaho | | Robert | Hawaii | +------------+----------------+

SQL Indre Join

En indre forbindelse returnerer rækker, der har matchende værdier i begge tabeller. Hvis der ikke er nogen matchende poster, returneres ingen rækker i resultaterne.

SQL-syntaksen for Inner Join er som følger:

SELECT ColumnName_1,
       ColumnName_2,
       ColumnName_N
FROM Table_1
INNER JOIN Table_2
ON Table_1.key = Table_2.key;
 

I eksemplet ovenfor, key er den respektive nøgle i tabellerne. Hvis du skal udføre en indre tilslutning på Employees og Address tabeller, skal du bruge følgende SQL-kode:

SELECT EmployeeName, State
FROM Employees
INNER JOIN Address
ON Employees.EmployeeId = Address.Id
 

Outputtet af ovenstående SQL-kode ligner følgende:

+--------------+--------------+ | EmployeeName | State | +---------------+-------------+ | John | New York | | Mary | New Jersey | +------------+----------------+

SQL venstre (ydre) join

En Left Join returnerer et komplet sæt rækker fra den venstre tabel sammen med de matchende rækker fra den højre tabel. Hvis der ikke er nogen matchende poster, så NULL værdier returneres fra den højre tabel.

Bemærk Nogle relationelle databaseimplementeringer bruger nøgleordene "Left Outer Join", i modsætning til "Left Join", men de er funktionelt ækvivalente.

SQL-syntaksen for Left Join er som følger:

SELECT * FROM Table_1
LEFT JOIN Table_2
ON Table_1.key = Table_2.key
 

I eksemplet ovenfor, key er den respektive nøgle i tabellerne. Hvis du har brug for at udføre en venstre-tilmelding på Employees og Address tabeller, skal du bruge følgende SQL-kode:

SELECT EmployeeName, State
FROM Employees
LEFT JOIN Address
ON Employees.EmployeeId = Address.Id
 

Outputtet af ovenstående SQL-kode er som følger:

+--------------+--------------+ | EmployeeName | State | +---------------+-------------+ | John | New York | | Mary | New Jersey | | Robert | NULL | +------------+----------------+

SQL højre (ydre) join

En Right Join returnerer et komplet sæt rækker fra den højre tabel og de matchende rækker fra den venstre tabel. Dette er også kendt som en Right Outer Join. Hvis der ikke er nogen matchende poster, så NULL værdier returneres fra den højre tabel for de berørte rækker i den venstre tabel.

Bemærk Nogle relationelle databaseimplementeringer bruger nøgleordene "Right Outer Join", i modsætning til "Right Join", men de er funktionelt ækvivalente.

SQL-syntaksen for en Right Join er som følger:

SELECT * FROM Table_1
RIGHT JOIN Table_2
ON Table_1.key = Table_2.key
 

Fra ovenstående kode, key er den respektive nøgle i tabellerne. Hvis du har brug for at udføre en ret tilmelding på Employees og Address tabeller, skal du bruge følgende SQL-kode:

SELECT EmployeeName, State
FROM Employees
RIGHT JOIN Address
ON Employees.EmployeeId = Address.Id
 

Outputtet af ovenstående SQL-kode er følgende:

+--------------+--------------+ | EmployeeName | State | +---------------+-------------+ | John | New York | | Mary | New Jersey | | NULL | Idaho | | NULL | Hawaii | +------------+----------------+

SQL fuld (ydre) deltagelse

En Full Join returnerer alle rækker fra venstre tabel, alle rækker fra højre tabel. Dette er også kendt som også kendt som en Full Outer Join. A Full Join returnerer også alle matchende poster fra begge borde, hvor de er tilgængelige. Hvis der ikke er nogen matchende poster, så NULL værdier returneres fra den venstre tabel. Det returnerer også NULL værdier fra den højre tabel.

Bemærk Nogle relationelle databaseimplementeringer bruger nøgleordene "Full Outer Join", i modsætning til "Full Join", men de er funktionelt ækvivalente.

SQL-syntaksen for Full Join er som følger:

SELECT * FROM Table1
FULL JOIN Table2
ON Table1.key = Table2.key
 

I ovenstående kode, key er den respektive nøgle i tabellerne. Hvis du har brug for at udføre en fuld tilslutning på Employees og Address tabeller, skal du bruge følgende SQL-kode:

SELECT EmployeeName, State
FROM Employees
FULL JOIN Address
ON Employees.EmployeeId = Address.Id
 

Outputtet af ovenstående SQL-kode er følgende:

+--------------+--------------+ | EmployeeName | State | +---------------+-------------+ | John | New York | | Mary | New Jersey | | Robert | NULL | | NULL | Idaho | | NULL | Hawaii | +------------+----------------+
Bemærk Under Join-beregninger, hvis du sammenligner tabeldata med NULL værdier, matcher de ikke hinanden. Derfor NULL værdier returneres kun som en del af Join-resultater og ignoreres under Join-beregninger.

Sammenligning af ydeevne af SQL-joins

I betragtning af ovenstående eksempeltabeller er Inner Join typisk den hurtigste af de fem Join-klausuler med hensyn til databaseydelse. Left Join og Right Join er de næsthurtigste afhængigt af størrelsen på de to borde. Full Join er typisk langsommere end Left Join eller Right Join. Cross Join, der er afhængig af det kartesiske produkt af de to tabeller, er typisk den langsomste med hensyn til databaseydelse. Det angivne ydeevnehierarki kan variere afhængigt af tabelkolonnelængden, kolonnedatatypen og nøgledefinitionerne.

Konklusion

Brugen af ​​SQL Joins udvider funktionaliteten ved at være i stand til at sammenligne tabelrækker over traditionelle WHERE klausul forespørgsler. Joins er en værdifuld mekanisme til at anvende algebraisk logik på to eller flere tabeller.


  1. Fordele ved NoSQL-databaser – Alt hvad du behøver at vide

  2. LOBBEHOLDELSE

  3. Opdeling af en tabel med milliardrækker med fodbolddata ved hjælp af datakontekst

  4. Brug af JavaFX-tabeller til at organisere data