Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich. # JOIN-Klausel Eine SQL JOIN-Klausel wird verwendet, um die Daten aus zwei oder mehr Tabellen basierend auf gemeinsamen Feldern zu kombinieren. Die Ergebnisse können sich je nach festgelegter Join-Methode ändern oder nicht. Externe Joins nach links und rechts behalten die Werte aus einer der Tabellen, für die ein Join ausgeführt wurde, wenn in der anderen Tabelle keine Übereinstimmung gefunden wurde. Die Kombination aus dem JOIN-Typ und der Join-Bedingung bestimmt, welche Zeilen in der endgültigen Ergebnismenge enthalten sind. Die SELECT- und WHERE-Klauseln steuern dann, welche Spalten zurückgegeben werden und wie die Zeilen gefiltert werden. Das Verständnis der verschiedenen JOIN-Typen und deren effektive Verwendung ist eine wichtige Fähigkeit in SQL, da Sie damit Daten aus mehreren Tabellen auf flexible und leistungsstarke Weise kombinieren können. ## Syntax ``` SELECT column1, column2, ..., columnn FROM table1 join_type table2 ON table1.column = table2.column; ``` ## Parameters *WÄHLEN SIE Spalte1, Spalte2,..., SpalteN* Die Spalten, die Sie in die Ergebnismenge aufnehmen möchten. Sie können Spalten aus einer oder beiden der am JOIN beteiligten Tabellen auswählen. *AUS Tabelle1* Die erste (linke) Tabelle in der JOIN-Operation. *[VERKNÜPFEN \$1 INNERE VERKNÜPFUNG \$1 LINKE [ÄUSSERE] VERKNÜPFUNG \$1 RECHTE [ÄUSSERE] VERKNÜPFUNG \$1 VOLLSTÄNDIGE [ÄUSSERE] VERKNÜPFUNG] Tabelle2:* Der Typ des auszuführenden JOINS. JOIN oder INNER JOIN gibt nur die Zeilen mit übereinstimmenden Werten in beiden Tabellen zurück. LEFT [OUTER] JOIN gibt alle Zeilen aus der linken Tabelle mit übereinstimmenden Zeilen aus der rechten Tabelle zurück. RIGHT [OUTER] JOIN gibt alle Zeilen aus der rechten Tabelle mit den entsprechenden Zeilen aus der linken Tabelle zurück. FULL [OUTER] JOIN gibt alle Zeilen aus beiden Tabellen zurück, unabhängig davon, ob eine Übereinstimmung vorliegt oder nicht. CROSS JOIN erzeugt ein kartesisches Produkt der Zeilen aus den beiden Tabellen. *ON Tabelle1.Spalte = Tabelle2.Spalte* Die Join-Bedingung, die angibt, wie die Zeilen in den beiden Tabellen abgeglichen werden. Die Join-Bedingung kann auf einer oder mehreren Spalten basieren. *WHERE-Bedingung:* Eine optionale Klausel, mit der die Ergebnismenge anhand einer bestimmten Bedingung weiter gefiltert werden kann. ## Beispiel Das folgende Beispiel ist ein Join zwischen zwei Tabellen mit der USING-Klausel. In diesem Fall werden die Spalten listid und eventid als Join-Spalten verwendet. Die Ergebnisse sind auf 5 Zeilen begrenzt. ``` select listid, listing.sellerid, eventid, listing.dateid, numtickets from listing join sales using (listid, eventid) order by 1 limit 5; listid | sellerid | eventid | dateid | numtickets -------+----------+---------+--------+----------- 1 | 36861 | 7872 | 1850 | 10 4 | 8117 | 4337 | 1970 | 8 5 | 1616 | 8647 | 1963 | 4 5 | 1616 | 8647 | 1963 | 4 6 | 47402 | 8240 | 2053 | 18 ``` # JOIN-Typen ## INNER Dies ist der Standard-Join-Typ. Gibt die Zeilen zurück, deren Werte in beiden Tabellenverweisen übereinstimmen. Der INNER JOIN ist der in SQL am häufigsten verwendete Join-Typ. Es ist eine leistungsstarke Methode, um Daten aus mehreren Tabellen auf der Grundlage einer gemeinsamen Spalte oder einer Gruppe von Spalten zu kombinieren. **Syntax:** ``` SELECT column1, column2, ..., columnn FROM table1 INNER JOIN table2 ON table1.column = table2.column; ``` Die folgende Abfrage gibt alle Zeilen zurück, in denen ein übereinstimmender customer\$1id-Wert zwischen den Tabellen „customers“ und „orders“ vorhanden ist. Das Resultset wird die Spalten customer\$1id, name, order\$1id und order\$1date enthalten. ``` SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date FROM customers INNER JOIN orders ON customers.customer_id = orders.customer_id; ``` Die folgende Abfrage ist ein innerer Join (ohne das Schlüsselwort JOIN) zwischen den Tabellen LISTING und SALES, wobei die LISTID aus der Tabelle LISTING zwischen 1 und 5 liegt. Diese Abfrage gleicht LISTID-Spaltenwerte in der Tabelle LISTING (linke Tabelle) und der Tabelle SALES (rechte Tabelle) ab. Die Ergebnisse zeigen, dass LISTID 1, 4 und 5 den Kriterien entsprechen. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing, sales where listing.listid = sales.listid and listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` Bei dem folgenden Beispiel handelt es sich um einen inneren Join mit der ON-Klausel. In diesem Fall werden NULL-Zeilen nicht zurückgegeben. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from sales join listing on sales.listid=listing.listid and sales.eventid=listing.eventid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` Die folgende Abfrage ist ein interner Join zweiter Unterabfragen in der FROM-Klausel. Die Abfrage ermittelt die Zahl der verkauften und nicht verkauften Tickets für verschiedene Veranstaltungskategorien (Konzerte und Shows). Die Unterabfragen mit FROM-Klausel sind *Tabellen*-Unterabfragen und können mehrere Spalten und Zeilen zurückgeben. ``` select catgroup1, sold, unsold from (select catgroup, sum(qtysold) as sold from category c, event e, sales s where c.catid = e.catid and e.eventid = s.eventid group by catgroup) as a(catgroup1, sold) join (select catgroup, sum(numtickets)-sum(qtysold) as unsold from category c, event e, sales s, listing l where c.catid = e.catid and e.eventid = s.eventid and s.listid = l.listid group by catgroup) as b(catgroup2, unsold) on a.catgroup1 = b.catgroup2 order by 1; catgroup1 | sold | unsold ----------+--------+-------- Concerts | 195444 |1067199 Shows | 149905 | 817736 ``` ## LINKS [AUSSEN] Gibt alle Werte aus der linken Tabellenreferenz und die übereinstimmenden Werte aus der rechten Tabellenreferenz zurück oder hängt NULL an, wenn es keine Übereinstimmung gibt. Es wird auch als *Left Outer Join* bezeichnet. Es gibt alle Zeilen aus der linken (ersten) Tabelle und die passenden Zeilen aus der rechten (zweiten) Tabelle zurück. Wenn es in der rechten Tabelle keine Übereinstimmung gibt, enthält die Ergebnismenge NULL-Werte für die Spalten aus der rechten Tabelle. Das Schlüsselwort OUTER kann weggelassen werden, und der Join kann einfach als LEFT JOIN geschrieben werden. Das Gegenteil von LEFT OUTER JOIN ist RIGHT OUTER JOIN, bei dem alle Zeilen aus der rechten Tabelle und die passenden Zeilen aus der linken Tabelle zurückgegeben werden. **Syntax:** ``` SELECT column1, column2, ..., columnn FROM table1 LEFT [OUTER] JOIN table2 ON table1.column = table2.column; ``` Die folgende Abfrage gibt alle Zeilen aus der Kundentabelle zusammen mit den entsprechenden Zeilen aus der Bestelltabelle zurück. Wenn ein Kunde keine Bestellungen hat, enthält das Resultset dennoch die Informationen dieses Kunden mit NULL-Werten für die Spalten order\$1id und order\$1date. ``` SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date FROM customers LEFT OUTER JOIN orders ON customers.customer_id = orders.customer_id; ``` Bei der folgenden Abfrage handelt es sich um einen linken, externen Join. Externe Joins nach links und rechts behalten die Werte aus einer der Tabellen, für die ein Join ausgeführt wurde, wenn in der anderen Tabelle keine Übereinstimmung gefunden wurde. Die Tabellen links und rechts werden in der Syntax als erste und zweite Tabelle aufgelistet. Es werden NULL-Werte verwendet, um die „Lücken“ im Ergebnissatz zu füllen. Diese Abfrage gleicht LISTID-Spaltenwerte in der Tabelle LISTING (linke Tabelle) und der Tabelle SALES (rechte Tabelle) ab. Die Ergebnisse zeigen, dass LISTIDs 2 und 3 zu keinen Verkäufen geführt haben. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing left outer join sales on sales.listid = listing.listid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 2 | NULL | NULL 3 | NULL | NULL 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` ## RECHTS [AUSSEN] Gibt alle Werte aus der rechten Tabellenreferenz und die übereinstimmenden Werte aus der linken Tabellenreferenz zurück oder hängt NULL an, wenn es keine Übereinstimmung gibt. Es wird auch als *rechter äußerer Join* bezeichnet. Es gibt alle Zeilen aus der rechten (zweiten) Tabelle und die passenden Zeilen aus der linken (ersten) Tabelle zurück. Wenn es in der linken Tabelle keine Übereinstimmung gibt, enthält die Ergebnismenge NULL-Werte für die Spalten aus der linken Tabelle. Das Schlüsselwort OUTER kann weggelassen werden, und der Join kann einfach als RIGHT JOIN geschrieben werden. Das Gegenteil von RIGHT OUTER JOIN ist LEFT OUTER JOIN, bei dem alle Zeilen aus der linken Tabelle und die passenden Zeilen aus der rechten Tabelle zurückgegeben werden. **Syntax:** ``` SELECT column1, column2, ..., columnn FROM table1 RIGHT [OUTER] JOIN table2 ON table1.column = table2.column; ``` Die folgende Abfrage gibt alle Zeilen aus der Kundentabelle zusammen mit den entsprechenden Zeilen aus der Bestelltabelle zurück. Wenn ein Kunde keine Bestellungen hat, enthält das Resultset dennoch die Informationen dieses Kunden mit NULL-Werten für die Spalten order\$1id und order\$1date. ``` SELECT orders.order_id, orders.order_date, customers.customer_id, customers.name FROM orders RIGHT OUTER JOIN customers ON orders.customer_id = customers.customer_id; ``` Bei der folgenden Abfrage handelt es sich um einen rechten, externen Join. Diese Abfrage gleicht LISTID-Spaltenwerte in der Tabelle LISTING (linke Tabelle) und der Tabelle SALES (rechte Tabelle) ab. Die Ergebnisse zeigen, dass LISTIDs 1, 4 und 5 den Kriterien entsprechen. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing right outer join sales on sales.listid = listing.listid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` ## VOLL [ÄUSSERLICH] Gibt alle Werte aus beiden Beziehungen zurück und fügt NULL-Werte auf der Seite an, für die es keine Übereinstimmung gibt. Es wird auch als *vollständiger äußerer Join* bezeichnet. Es gibt alle Zeilen sowohl aus der linken als auch aus der rechten Tabelle zurück, unabhängig davon, ob eine Übereinstimmung vorliegt oder nicht. Wenn es keine Übereinstimmung gibt, enthält die Ergebnismenge NULL-Werte für die Spalten aus der Tabelle, die keine passende Zeile hat. Das Schlüsselwort OUTER kann weggelassen werden, und der Join kann einfach als FULL JOIN geschrieben werden. Der FULL OUTER JOIN wird seltener verwendet als der LEFT OUTER JOIN oder RIGHT OUTER JOIN, kann aber in bestimmten Szenarien nützlich sein, in denen Sie alle Daten aus beiden Tabellen sehen müssen, auch wenn es keine Treffer gibt. **Syntax:** ``` SELECT column1, column2, ..., columnn FROM table1 FULL [OUTER] JOIN table2 ON table1.column = table2.column; ``` Die folgende Abfrage gibt alle Zeilen aus den Tabellen „Kunden“ und „Bestellungen“ zurück. Wenn ein Kunde keine Bestellungen hat, enthält das Resultset dennoch die Informationen dieses Kunden mit NULL-Werten für die Spalten order\$1id und order\$1date. Wenn einer Bestellung kein Kunde zugeordnet ist, enthält das Resultset diese Bestellung mit NULL-Werten für die Spalten customer\$1id und name. ``` SELECT customers.customer_id, customers.name, orders.order_id, orders.order_date FROM customers FULL OUTER JOIN orders ON customers.customer_id = orders.customer_id; ``` Bei der folgenden Abfrage handelt es sich um einen vollständigen Join. Vollständige Joins behalten die Werte aus einer der Tabellen bei, für die ein Join ausgeführt wurde, wenn in der anderen Tabelle keine Übereinstimmung gefunden wurde. Die Tabellen links und rechts werden in der Syntax als erste und zweite Tabelle aufgelistet. Es werden NULL-Werte verwendet, um die „Lücken“ im Ergebnissatz zu füllen. Diese Abfrage gleicht LISTID-Spaltenwerte in der Tabelle LISTING (linke Tabelle) und der Tabelle SALES (rechte Tabelle) ab. Die Ergebnisse zeigen, dass LISTIDs 2 und 3 zu keinen Verkäufen geführt haben. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing full join sales on sales.listid = listing.listid where listing.listid between 1 and 5 group by 1 order by 1; listid | price | comm -------+--------+-------- 1 | 728.00 | 109.20 2 | NULL | NULL 3 | NULL | NULL 4 | 76.00 | 11.40 5 | 525.00 | 78.75 ``` Bei der folgenden Abfrage handelt es sich um einen vollständigen Join. Diese Abfrage gleicht LISTID-Spaltenwerte in der Tabelle LISTING (linke Tabelle) und der Tabelle SALES (rechte Tabelle) ab. Nur Zeilen, die zu keinen Verkäufen führen (LISTIDs 2 und 3), sind in den Ergebnissen enthalten. ``` select listing.listid, sum(pricepaid) as price, sum(commission) as comm from listing full join sales on sales.listid = listing.listid where listing.listid between 1 and 5 and (listing.listid IS NULL or sales.listid IS NULL) group by 1 order by 1; listid | price | comm -------+--------+-------- 2 | NULL | NULL 3 | NULL | NULL ``` ## [LINKS] HALB Gibt Werte von der linken Seite der Tabellenreferenz zurück, die mit der rechten Seite übereinstimmen. Es wird auch als *linke Semi-Verknüpfung* bezeichnet. Es werden nur die Zeilen aus der linken (ersten) Tabelle zurückgegeben, für die eine entsprechende Zeile in der rechten (zweiten) Tabelle vorhanden ist. Es werden keine Spalten aus der rechten Tabelle zurückgegeben, sondern nur die Spalten aus der linken Tabelle. Der LEFT SEMI JOIN ist nützlich, wenn Sie die Zeilen in einer Tabelle suchen möchten, die eine Übereinstimmung in einer anderen Tabelle haben, ohne Daten aus der zweiten Tabelle zurückgeben zu müssen. Der LEFT SEMI JOIN ist eine effizientere Alternative zur Verwendung einer Unterabfrage mit einer IN- oder EXISTS-Klausel. **Syntax:** ``` SELECT column1, column2, ..., columnn FROM table1 LEFT SEMI JOIN table2 ON table1.column = table2.column; ``` Die folgende Abfrage gibt nur die Spalten customer\$1id und name aus der Kundentabelle für die Kunden zurück, die mindestens eine Bestellung in der Bestelltabelle haben. Das Resultset wird keine Spalten aus der Bestelltabelle enthalten. ``` SELECT customers.customer_id, customers.name FROM customers LEFT SEMI JOIN orders ON customers.customer_id = orders.customer_id; ``` ## CROSS JOIN Gibt das kartesische Produkt zweier Beziehungen zurück. Das bedeutet, dass die Ergebnismenge alle möglichen Kombinationen von Zeilen aus den beiden Tabellen enthält, ohne dass eine Bedingung oder ein Filter angewendet wird. Der CROSS JOIN ist nützlich, wenn Sie alle möglichen Kombinationen von Daten aus zwei Tabellen generieren müssen, z. B. wenn Sie einen Bericht erstellen möchten, der alle möglichen Kombinationen von Kunden- und Produktinformationen anzeigt. Der CROSS JOIN unterscheidet sich von anderen Join-Typen (INNER JOIN, LEFT JOIN usw.), da er in der ON-Klausel keine Join-Bedingung enthält. Die Join-Bedingung ist für einen CROSS JOIN nicht erforderlich. **Syntax:** ``` SELECT column1, column2, ..., columnn FROM table1 CROSS JOIN table2; ``` Die folgende Abfrage gibt ein Resultset zurück, das alle möglichen Kombinationen von customer\$1id, customer\$1name, product\$1id und product\$1name aus den Tabellen Customers und Products enthält. Wenn die Kundentabelle 10 Zeilen und die Produkttabelle 20 Zeilen hat, enthält die Ergebnismenge von CROSS JOIN 10 x 20 = 200 Zeilen. ``` SELECT customers.customer_id, customers.name, products.product_id, products.product_name FROM customers CROSS JOIN products; ``` Bei der folgenden Abfrage handelt es sich um einen Cross Join oder kartesischen Join der LISTING- und der SALES-Tabelle mit einem Prädikat zur Begrenzung der Ergebnisse. Diese Abfrage entspricht den LISTID-Spaltenwerten in der SALES-Tabelle und der LISTING-Tabelle für LISTIDs 1, 2, 3, 4 und 5 in beiden Tabellen. Die Ergebnisse zeigen, dass 20 Zeilen den Kriterien entsprechen. ``` select sales.listid as sales_listid, listing.listid as listing_listid from sales cross join listing where sales.listid between 1 and 5 and listing.listid between 1 and 5 order by 1,2; sales_listid | listing_listid -------------+--------------- 1 | 1 1 | 2 1 | 3 1 | 4 1 | 5 4 | 1 4 | 2 4 | 3 4 | 4 4 | 5 5 | 1 5 | 1 5 | 2 5 | 2 5 | 3 5 | 3 5 | 4 5 | 4 5 | 5 5 | 5 ``` ## ANTI-JOIN Gibt die Werte aus der linken Tabellenreferenz zurück, die nicht mit der rechten Tabellenreferenz übereinstimmen. Es wird auch als *Left Anti Join* bezeichnet. Der ANTI JOIN ist eine nützliche Operation, wenn Sie die Zeilen in einer Tabelle suchen möchten, für die es in einer anderen Tabelle keine Übereinstimmung gibt. **Syntax:** ``` SELECT column1, column2, ..., columnn FROM table1 LEFT ANTI JOIN table2 ON table1.column = table2.column; ``` Die folgende Abfrage gibt alle Kunden zurück, die keine Bestellungen aufgegeben haben. ``` SELECT customers.customer_id, customers.name FROM customers LEFT ANTI JOIN orders ON customers.customer_id = orders.customer_id WHERE orders.order_id IS NULL; ``` ## NATURAL Gibt an, dass die Zeilen aus den beiden Beziehungen implizit auf Gleichheit für alle Spalten mit übereinstimmenden Namen abgeglichen werden. Es ordnet automatisch Spalten mit demselben Namen und Datentyp zwischen den beiden Tabellen zu. Sie müssen die Join-Bedingung nicht explizit in der ON-Klausel angeben. Sie kombiniert alle übereinstimmenden Spalten zwischen den beiden Tabellen in der Ergebnismenge. NATURAL JOIN ist eine praktische Abkürzung, wenn die Tabellen, die Sie verknüpfen, Spalten mit denselben Namen und Datentypen haben. Es wird jedoch generell empfohlen, das explizitere INNER JOIN... zu verwenden ON-Syntax, um die Join-Bedingungen expliziter und verständlicher zu machen. **Syntax:** ``` SELECT column1, column2, ..., columnn FROM table1 NATURAL JOIN table2; ``` Das folgende Beispiel ist eine natürliche Verknüpfung zwischen zwei Tabellen mit den folgenden Spalten: `employees` `departments` + `employees`Tabelle: `employee_id``first_name`,`last_name`, `department_id ` + `departments`tabelle:`department_id`, `department_name ` Die folgende Abfrage gibt eine Ergebnismenge zurück, die den Vornamen, den Nachnamen und den Abteilungsnamen für alle übereinstimmenden Zeilen zwischen den beiden Tabellen enthält, basierend auf der `department_id` Spalte. ``` SELECT e.first_name, e.last_name, d.department_name FROM employees e NATURAL JOIN departments d; ``` Das folgende Beispiel ist ein NATURAL-Join zwischen zwei Tabellen. In diesem Fall haben die Spalten listid, sellerid, eventid und dateid identische Namen und Datentypen in beiden Tabellen und werden daher als Join-Spalten verwendet. Die Ergebnisse sind auf 5 Zeilen begrenzt. ``` select listid, sellerid, eventid, dateid, numtickets from listing natural join sales order by 1 limit 5; listid | sellerid | eventid | dateid | numtickets -------+-----------+---------+--------+----------- 113 | 29704 | 4699 | 2075 | 22 115 | 39115 | 3513 | 2062 | 14 116 | 43314 | 8675 | 1910 | 28 118 | 6079 | 1611 | 1862 | 9 163 | 24880 | 8253 | 1888 | 14 ```