Inleiding tot SQL-joins

Traditioneel haalt u gegevens uit twee of meer tabellen met behulp van een WHERE clausule in een query. Maar in een relationeel databasesysteem (RDBMS) kan dit worden bereikt met een enkele SELECT vraag. Dit is de ware kracht van relationele databasesystemen. In deze handleiding leert u over SQL Joins, een krachtige manier om rijen en tabellen te vergelijken en te selecteren.

Wat is een SQL-join?

In SQL, een join clausule breidt de mogelijkheid uit om rijen uit tabellen te vergelijken en te selecteren. Het gebruikt een algebraïsch proces waarbij rijen uit twee of meer tabellen worden gecombineerd op basis van een gerelateerde kolom in die tabellen. Volgens de ANSI-standaard SQL-definitie zijn er vijf soorten joins -Cross-joins , Innerlijke samenvoegingen , Linker (buitenste) joins , Rechts (buitenste) joins , en Volledige (buitenste) joins . Deze joins worden geïmplementeerd in alle relationele databasesystemen en worden behandeld in de onderstaande secties.

Opmerking Joins kunnen worden uitgevoerd op een willekeurig aantal tabellen in een bepaalde query. Voor de beknoptheid en duidelijkheid worden in deze gids joins besproken die op twee tabellen zijn toegepast.

Deze handleiding gebruikt twee tabellen, Employees en Address , respectievelijk, om SQL Joins te demonstreren. Elk van deze tabellen bevat de volgende kolomdefinities en gegevens:

• Medewerkerstabel

  EmployeeId	EmployeeName
  1	Jan
  2	Maria
  3	Robert

• Adrestabel

  Id	Status
  1	New York
  2	New Jersey
  3	Idaho
  4	Hawaï

Opmerking Tenzij anders vermeld, werken alle opdrachten in deze handleiding goed op zowel MySQL en PostgreSQL databases.

SQL Cross Joins

Ook bekend als een Cartesian Join , Cross-joins treden op wanneer u meerdere tabellen opgeeft als bron voor uw SELECT lijst met kolommen. In dit geval laat je de WHERE . weg clausule join-expressie die overeenkomt met rijen op. De resultatenset bevat een rij voor elke combinatie van rijen tussen de tabellen. In een scenario met twee tabellen is elke rij in de ene tabel gekoppeld aan elke rij van de andere tabel. Het resulterende product staat bekend als het Cartesiaanse product van de twee tafels. De syntaxis voor een Cross Join is de volgende:

(# Rows in Table A) TIMES (# of Rows in Table B)

Opmerking

In de verzamelingenleer is het cartesiaanse product een vermenigvuldigingsbewerking die alle geordende paren van de gegeven verzamelingen genereert. Overweeg bijvoorbeeld set A met elementen {a,b} en stel B . in met elementen {1,2,3} . Het cartesiaanse product van A en B wordt aangegeven met AxB en het resultaat is het volgende:

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

De SQL-syntaxis voor een Cross Join is als volgt:

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

Van de bovenstaande syntaxis, Column_1 , Column_2 , Column_N vertegenwoordigen de kolommen in een tabel, en de CROSS JOIN clausule dient om de twee tabellen te combineren, Table_1 en Table_2 . Uit de voorbeeldtabellen hierboven, als u een Cross Join moet uitvoeren op Employees en Address tabellen, gebruik dan de volgende SQL-code:

SELECT EmployeeName, State
FROM Employees
CROSS JOIN Address

De uitvoer van de bovenstaande SQL-code lijkt op het volgende:

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

Een Inner Join retourneert rijen met overeenkomende waarden in beide tabellen. Als er geen overeenkomende records zijn, worden er geen rijen geretourneerd in de resultaten.

De SQL-syntaxis voor Inner Join is als volgt:

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

In het bovenstaande voorbeeld, key is de respectieve sleutel van de tabellen. Als u een inner join moet uitvoeren op Employees en Address tabellen, gebruik dan de volgende SQL-code:

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

De uitvoer van de bovenstaande SQL-code lijkt op het volgende:

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

SQL Left (Outer) Join

Een Left Join retourneert een complete set rijen uit de linkertabel samen met de overeenkomende rijen uit de rechtertabel. Als er geen overeenkomende records zijn, dan NULL waarden worden geretourneerd uit de rechtertabel.

Opmerking Sommige relationele database-implementaties gebruiken de trefwoorden "Left Outer Join", in tegenstelling tot "Left Join", maar ze zijn functioneel equivalent.

De SQL-syntaxis voor Left Join is als volgt:

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

In het bovenstaande voorbeeld, key is de respectieve sleutel van de tabellen. Als u een left join moet uitvoeren op Employees en Address tabellen, gebruik dan de volgende SQL-code:

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

De uitvoer van de bovenstaande SQL-code is als volgt:

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

SQL Right (Outer) Join

Een Right Join retourneert een complete set rijen uit de rechtertabel en de overeenkomende rijen uit de linkertabel. Dit wordt ook wel een Right Outer Join genoemd. Als er geen overeenkomende records zijn, dan NULL waarden worden geretourneerd uit de rechtertabel, voor de betreffende rijen in de linkertabel.

Opmerking Sommige relationele database-implementaties gebruiken de trefwoorden "Right Outer Join", in tegenstelling tot "Right Join", maar ze zijn functioneel equivalent.

De SQL-syntaxis voor een Right Join is als volgt:

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

Van de bovenstaande code, key is de respectieve sleutel van de tabellen. Als u een juiste join moet uitvoeren op Employees en Address tabellen, gebruik dan de volgende SQL-code:

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

De uitvoer van de bovenstaande SQL-code is de volgende:

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

SQL Full (Outer) Join

Een Full Join retourneert alle rijen uit de linkertabel, alle rijen uit de rechtertabel. Dit wordt ook wel een Full Outer Join genoemd. Een Full Join retourneert ook alle overeenkomende records van beide tabellen, indien beschikbaar. Als er geen overeenkomende records zijn, dan NULL waarden worden geretourneerd uit de linkertabel. Het retourneert ook NULL waarden uit de rechtertabel.

Opmerking Sommige relationele database-implementaties gebruiken de trefwoorden "Full Outer Join", in tegenstelling tot "Full Join", maar ze zijn functioneel equivalent.

De SQL-syntaxis voor Full Join is als volgt:

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

In de bovenstaande code, key is de respectieve sleutel van de tabellen. Als u een volledige join moet uitvoeren op Employees en Address tabellen, gebruik dan de volgende SQL-code:

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

De uitvoer van de bovenstaande SQL-code is de volgende:

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

Opmerking Als u tijdens Join-berekeningen tabelgegevens vergelijkt met NULL waarden, ze komen niet met elkaar overeen. Vandaar, NULL waarden worden alleen geretourneerd als onderdeel van Join-resultaten en worden genegeerd tijdens Join-berekeningen.

Prestatievergelijking van SQL-joins

Gezien de bovenstaande voorbeeldtabellen is de Inner Join doorgaans de snelste van de vijf Join-clausules in termen van databaseprestaties. De Left Join en de Right Join zijn de volgende snelste, afhankelijk van de grootte van de twee tabellen. De Full Join is doorgaans langzamer dan de Left Join of de Right Join. De Cross Join, die afhankelijk is van het cartesiaanse product van de twee tabellen, is doorgaans de langzaamste in termen van databaseprestaties. De gespecificeerde prestatiehiërarchie kan verschillen, afhankelijk van de tabelkolomlengte, het kolomgegevenstype en de sleuteldefinities.

Conclusie

Het gebruik van SQL Joins breidt de functionaliteit uit om tabelrijen te kunnen vergelijken, in vergelijking met traditionele WHERE clausule vragen. Joins zijn een waardevol mechanisme om algebraïsche logica toe te passen op twee of meer tabellen.