PostgreSQL JOIN

Die PostgreSQL-JOIN-Klausel wird verwendet, um Zeilen aus zwei oder mehr Tabellen basierend auf gemeinsamen Feldern zwischen diesen Tabellen zu kombinieren.

In PostgreSQL gibt es fünf Arten von JOIN:

CROSS JOIN: Kreuz-Join
INNER JOIN: Innerer Join
LEFT OUTER JOIN: Linker äußerer Join
RIGHT OUTER JOIN: Rechter äußerer Join
FULL OUTER JOIN: Vollständiger äußerer Join

Als Nächstes erstellen wir zwei TabellenCOMPANYundDEPARTMENT。

Beispiel

Erstellen Sie die Tabelle COMPANY (COMPANY-SQL-Datei herunterladen), der Dateninhalt ist wie folgt:

exampledb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Fügen wir der Tabelle ein paar Datensätze hinzu:

INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00);
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00);
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00);

Zu diesem Zeitpunkt sind die Datensätze in der COMPANY-Tabelle wie folgt:

 id | name  | age | address      | salary
 ----+-------+-----+--------------+--------
   1 | Paul  |  32 | California   |  20000
   2 | Allen |  25 | Texas        |  15000
   3 | Teddy |  23 | Norway       |  20000
   4 | Mark  |  25 | Rich-Mond    |  65000
   5 | David |  27 | Texas        |  85000
   6 | Kim   |  22 | South-Hall   |  45000
   7 | James |  24 | Houston      |  10000
   8 | Paul  |  24 | Houston      |  20000
   9 | James |  44 | Norway       |   5000
  10 | James |  45 | Texas        |   5000
(10 rows)

Erstellen Sie eine Tabelle DEPARTMENT mit drei Feldern:

CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

Fügen Sie drei Datensätze in die Tabelle DEPARTMENT ein:

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID) VALUES (1, 'IT Billing', 1 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID) VALUES (2, 'Engineering', 2 );

INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID) VALUES (3, 'Finance', 7 );

Zu diesem Zeitpunkt sind die Datensätze in der Tabelle DEPARTMENT wie folgt:

 id | dept        | emp_id
----+-------------+--------
  1 | IT Billing  |  1
  2 | Engineering |  2
  3 | Finance     |  7

Cross Join

CROSS JOIN ordnet jede Zeile der ersten Tabelle jeder Zeile der zweiten Tabelle zu. Wenn die beiden Eingabetabellen x bzw. y Zeilen haben, hat die Ergebnistabelle x*y Zeilen.

Da CROSS JOIN sehr große Tabellen erzeugen kann, müssen Sie bei der Verwendung vorsichtig sein und ihn nur verwenden, wenn es angebracht ist.

Das Folgende ist die grundlegende Syntax von CROSS JOIN:

SELECT ... FROM table1 CROSS JOIN table2 ...

Basierend auf den obigen Tabellen können wir einen CROSS JOIN wie folgt schreiben:

exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;

Das erhaltene Ergebnis lautet wie folgt:

exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;
 emp_id | name  |       dept
--------+-------+--------------------
      1 | Paul  | IT Billing
      1 | Allen | IT Billing
      1 | Teddy | IT Billing
      1 | Mark  | IT Billing
      1 | David | IT Billing
      1 | Kim   | IT Billing
      1 | James | IT Billing
      1 | Paul  | IT Billing
      1 | James | IT Billing
      1 | James | IT Billing
      2 | Paul  | Engineering
      2 | Allen | Engineering
      2 | Teddy | Engineering
      2 | Mark  | Engineering
      2 | David | Engineering
      2 | Kim   | Engineering
      2 | James | Engineering
      2 | Paul  | Engineering
      2 | James | Engineering
      2 | James | Engineering
      7 | Paul  | Finance

Inner Join

INNER JOIN erstellt eine neue Ergebnistabelle, indem er die Spaltenwerte zweier Tabellen (table1 und table2) anhand des Join-Prädikats kombiniert. Die Abfrage vergleicht jede Zeile in table1 mit jeder Zeile in table2, um alle Zeilenpaare zu finden, die das Join-Prädikat erfüllen.

Wenn das Join-Prädikat erfüllt ist, werden die Spaltenwerte jedes übereinstimmenden Zeilenpaars A und B zu einer Ergebniszeile zusammengeführt.

INNER JOIN ist die häufigste Art von Join und der Standard-Join-Typ.

Das Schlüsselwort INNER ist optional.

Die Syntax von INNER JOIN lautet wie folgt:

SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_filed = table2.common_field;

Basierend auf den obigen Tabellen können wir einen Inner Join wie folgt schreiben:

exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
 emp_id | name  |        dept
--------+-------+--------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 | James | Finance
(3 rows)

Left Outer Join

Outer Joins sind eine Erweiterung von Inner Joins. Der SQL-Standard definiert drei Arten von Outer Joins: LEFT, RIGHT und FULL. PostgreSQL unterstützt sie alle.

Bei einem Left Outer Join wird zuerst ein Inner Join durchgeführt. Dann wird für jede Zeile in Tabelle T1, die die Join-Bedingung mit Tabelle T2 nicht erfüllt, zusätzlich eine zusammengeführte Zeile mit NULL-Werten in den Spalten von T2 hinzugefügt. Daher enthält die zusammengeführte Tabelle mindestens eine Zeile für jede Zeile in T1.

Die grundlegende Syntax von LEFT OUTER JOIN lautet wie folgt:

SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...

Basierend auf den beiden obigen Tabellen können wir einen Left Outer Join wie folgt schreiben:

exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
 emp_id | name  |      dept
--------+-------+----------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 | James | Finance
        | James | 
        | David | 
        | Paul  | 
        | Kim   | 
        | Mark  | 
        | Teddy | 
        | James | 
(10 rows)

Right Outer Join

Zuerst wird ein Inner Join durchgeführt. Dann wird für jede Zeile in Tabelle T2, die die Join-Bedingung mit Tabelle T1 nicht erfüllt, zusätzlich eine zusammengeführte Zeile mit NULL-Werten in den Spalten von T1 hinzugefügt. Dies ist das Gegenteil des Left Join; für jede Zeile in T2 enthält die Ergebnistabelle immer eine Zeile.

Die grundlegende Syntax von Right Outer Join (RIGHT OUT JOIN) lautet wie folgt:

SELECT ... FROM table1 RIGHT OUTER JOIN table2 ON conditional_expression ...

Basierend auf den beiden obigen Tabellen erstellen wir einen Right Outer Join:

exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY RIGHT OUTER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
 emp_id | name  |    dept
--------+-------+-----------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 | James | Finance
(3 rows)

Full Outer Join

Zuerst wird ein Inner Join durchgeführt. Dann wird für jede Zeile in Tabelle T1, die die Join-Bedingung mit keiner Zeile in Tabelle T2 erfüllt, zusätzlich eine Zeile mit NULL-Werten in den Spalten von T2 zum Ergebnis hinzugefügt. Darüber hinaus wird für jede Zeile in T2, die die Join-Bedingung mit keiner Zeile in T1 erfüllt, eine Zeile mit NULL-Werten in den Spalten von T1 zum Ergebnis hinzugefügt.

Das Folgende ist die grundlegende Syntax des Full Outer Join:

SELECT ... FROM table1 FULL OUTER JOIN table2 ON conditional_expression ...

Basierend auf den beiden obigen Tabellen können wir einen Full Outer Join erstellen:

exampledb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY FULL OUTER JOIN DEPARTMENT ON COMPANY.ID = DEPARTMENT.EMP_ID;
 emp_id | name  |      dept
--------+-------+-----------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 | James | Finance
        | James | 
        | David | 
        | Paul  | 
        | Kim   | 
        | Mark  | 
        | Teddy | 
        | James | 
(10 rows)

Andere Erweiterungen

PostgreSQL Erweitert