MySQL JOIN-Verwendung

In den vorherigen Kapiteln haben wir gelernt, wie man Daten aus einer einzelnen Tabelle liest, was relativ einfach ist, aber in realen Anwendungen müssen wir oft Daten aus mehreren Datentabellen lesen.

In diesem Kapitel führen wir ein, wie man MySQLs JOIN verwendet, um Daten in zwei oder mehr Tabellen abzufragen.

Sie können MySQLs JOIN in SELECT-, UPDATE- und DELETE-Anweisungen verwenden, um Abfragen über mehrere Tabellen durchzuführen.

JOIN lässt sich nach Funktionalität grob in die folgenden drei Kategorien einteilen:

  • INNER JOIN (innerer Join oder Äquijoin):Ruft Datensätze mit übereinstimmenden Feldbeziehungen in den beiden Tabellen ab.
  • LEFT JOIN (linker Join):Ruft alle Datensätze aus der linken Tabelle ab, auch wenn die rechte Tabelle keine entsprechenden übereinstimmenden Datensätze hat.
  • RIGHT JOIN (rechter Join):Das Gegenteil von LEFT JOIN; wird verwendet, um alle Datensätze aus der rechten Tabelle abzurufen, auch wenn die linke Tabelle keine entsprechenden übereinstimmenden Datensätze hat.

In diesem Kapitel verwendete Datenbankstruktur und Daten zum Herunterladen:example-mysql-join-test.sql。

INNER JOIN

INNER JOIN gibt übereinstimmende Zeilen zurück, die die Join-Bedingung in beiden Tabellen erfüllen. Das Folgende ist die grundlegende Syntax der INNER JOIN-Anweisung:

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

Parameter description:

  • column1, column2, ... sind die Namen der Spalten, die Sie auswählen möchten. Wenn Sie*bedeutet die Auswahl aller Spalten.
  • table1, table2sind die Namen der beiden Tabellen, die verbunden werden sollen.
  • table1.column_name = table2.column_nameist die JOIN-Bedingung, die die Spalten angibt, die für den Abgleich in den beiden Tabellen verwendet werden.

Einfacher INNER JOIN:

SELECT orders.order_id, customers.customer_name
FROM orders
INNER JOIN customers ON orders.customer_id = customers.customer_id;

Die obige SQL-Anweisung wählt die Bestell-ID und den Kundennamen aus der Tabelle orders und der Tabelle customers aus, die die JOIN-Bedingung erfüllen.

2. Tabellen-Aliase verwenden:

SELECT o.order_id, c.customer_name
FROM orders AS o
INNER JOIN customers AS c ON o.customer_id = c.customer_id;

Die obige SQL-Anweisung verwendet die Tabellen-Aliase o und c als Aliase für die Tabellen orders und customers.

3. INNER JOIN mit mehreren Tabellen:

SELECT orders.order_id, customers.customer_name, products.product_name
FROM orders
INNER JOIN customers ON orders.customer_id = customers.customer_id
INNER JOIN order_items ON orders.order_id = order_items.order_id
INNER JOIN products ON order_items.product_id = products.product_id;

Die obige SQL-Anweisung umfasst die Verknüpfung von vier Tabellen: orders, customers, order_items und products. Sie wählt die Bestell-ID, den Kundennamen und den Produktnamen aus und verknüpft die zugehörigen Spalten dieser Tabellen.

4. Filtern mit der WHERE-Klausel:

SELECT orders.order_id, customers.customer_name
FROM orders
INNER JOIN customers ON orders.customer_id = customers.customer_id
WHERE orders.order_date >= '2023-01-01';

Die obige SQL-Anweisung verwendet die WHERE-Klausel nach dem INNER JOIN, um Bestellungen mit einem Bestelldatum am oder nach dem '2023-01-01' zu filtern.

LEFT JOIN

LEFT JOIN gibt alle Zeilen aus der linken Tabelle zurück und enthält übereinstimmende Zeilen aus der rechten Tabelle. Wenn es keine übereinstimmende Zeile in der rechten Tabelle gibt, werden NULL-Werte zurückgegeben. Das Folgende ist die grundlegende Syntax der LEFT JOIN-Anweisung:

SELECT column1, column2, ...
FROM table1
LEFT JOIN table2 ON table1.column_name = table2.column_name;

1. Einfacher LEFT JOIN:

SELECT customers.customer_id, customers.customer_name, orders.order_id
FROM customers
LEFT JOIN orders ON customers.customer_id = orders.customer_id;

Die obige SQL-Anweisung wählt die Kunden-ID und den Kundennamen aus der Tabelle customers aus und enthält alle Zeilen aus der linken Tabelle customers sowie die passende Bestell-ID (falls vorhanden).

2. Tabellen-Aliase verwenden:

SELECT c.customer_id, c.customer_name, o.order_id
FROM customers AS c
LEFT JOIN orders AS o ON c.customer_id = o.customer_id;

Die obige SQL-Anweisung verwendet die Tabellenaliase c und o, um die Namen der Tabellen customers bzw. orders zu ersetzen.

3. LEFT JOIN über mehrere Tabellen:

SELECT customers.customer_id, customers.customer_name, orders.order_id, products.product_name
FROM customers
LEFT JOIN orders ON customers.customer_id = orders.customer_id
LEFT JOIN order_items ON orders.order_id = order_items.order_id
LEFT JOIN products ON order_items.product_id = products.product_id;

Die obige SQL-Anweisung verknüpft vier Tabellen: customers, orders, order_items und products, und wählt Kunden-ID, Kundenname, Bestell-ID und Produktname aus. Der LEFT JOIN stellt sicher, dass selbst wenn es keine passenden Zeilen in order_items oder products gibt, Kunden- und Bestellinformationen trotzdem zurückgegeben werden.

4. Filtern mit der WHERE-Klausel:

SELECT customers.customer_id, customers.customer_name, orders.order_id
FROM customers
LEFT JOIN orders ON customers.customer_id = orders.customer_id
WHERE orders.order_date >= '2023-01-01' OR orders.order_id IS NULL;

Die obige SQL-Anweisung verwendet die WHERE-Klausel nach dem LEFT JOIN, um Bestellungen mit Bestelldaten am oder nach dem '2023-01-01' zu filtern, sowie Kunden ohne passende Bestellungen.

LEFT JOIN ist ein häufig verwendeter Join-Typ, insbesondere wenn Sie alle Zeilen aus der linken Tabelle zurückgeben müssen. Wenn es keine passende Zeile in der rechten Tabelle gibt, werden die zugehörigen Spalten als NULL angezeigt. Wenn Sie LEFT JOIN verwenden, stellen Sie sicher, dass Sie die Join-Bedingung verstehen, und filtern Sie Ergebnisse nach Bedarf.

RIGHT JOIN

RIGHT JOIN gibt alle Zeilen aus der rechten Tabelle zurück und schließt passende Zeilen aus der linken Tabelle ein. Wenn es keine passende Zeile in der linken Tabelle gibt, werden NULL-Werte zurückgegeben. Das Folgende ist die grundlegende Syntax der RIGHT JOIN-Anweisung:

SELECT column1, column2, ...
FROM table1
RIGHT JOIN table2 ON table1.column_name = table2.column_name;

Das Folgende ist ein einfaches RIGHT JOIN-Beispiel:

SELECT customers.customer_id, orders.order_id
FROM customers
RIGHT JOIN orders ON customers.customer_id = orders.customer_id;

Die obige SQL-Anweisung wählt alle Bestell-IDs aus der rechten Tabelle orders aus und enthält passende Kunden-IDs aus der linken Tabelle customers. Wenn es keine passende Kunden-ID in der Tabelle customers gibt, werden die zugehörigen Spalten als NULL angezeigt.

Während der Entwicklung wird RIGHT JOIN nicht häufig verwendet, da es denselben Effekt erzielen kann, indem man LEFT JOIN verwendet und die Reihenfolge der Tabellen vertauscht. Beispielsweise kann die obige Abfrage mit LEFT JOIN umgeschrieben werden als:

SELECT customers.customer_id, orders.order_id
FROM orders
LEFT JOIN customers ON orders.customer_id = customers.customer_id;

Die obige SQL-Anweisung liefert dasselbe Ergebnis, weil LEFT JOIN und RIGHT JOIN symmetrisch sind. In der Praxis können Sie je nach persönlicher Vorliebe oder organisatorischen Standards wählen, welche Form Sie verwenden.


Verwendung von INNER JOIN in der Eingabeaufforderung

INNER JOIN kann mehrere Tabellen anhand der angegebenen Join-Bedingung miteinander verknüpfen, sodass Sie zugehörige Daten in einer Abfrage abrufen können.

Wenn Sie INNER JOIN verwenden, stellen Sie sicher, dass die Join-Bedingung korrekt ist, und verstehen Sie die Beziehungen zwischen den verknüpften Tabellen.

Beispiel

Wir haben zwei Tabellen, tcount_tbl und example_tbl, in der Datenbank EXAMPLE.

Probieren Sie das folgende Beispiel aus:

Testdaten für das Beispiel

mysql> use EXAMPLE; Datenbank geändert mysql> SELECT * FROM tcount_tbl; +---------------+--------------+ | example_author | example_count| +---------------+--------------+ | Beispiel-Tutorial |10 | | EXAMPLE.COM | 20 | | Google | 22 | +---------------+--------------+ 3 Zeilen im Satz (0.01 Sek.) mysql> SELECT * from example_tbl; +-----------+---------------+---------------+-----------------+ | example_id | example_title | example_author | submission_date | +-----------+---------------+---------------+-----------------+ | 1| LernenPHP| Beispiel-Tutorial |2017-04-12 | | 2| LernenMySQL| Beispiel-Tutorial |2017-04-12 | | 3| LernenJava | EXAMPLE.COM | 2015-05-01 | | 4| LernenPython | EXAMPLE.COM | 2016-03-06 | | 5| LernenC | FK | 2017-04-05 | +-----------+---------------+---------------+-----------------+ 5 Zeilen in Satz (0.01 sec)

Als Nächstes verwenden wir MySQLsINNER JOIN (Sie können INNER auch weglassen und JOIN verwenden, mit demselben Effekt), um die beiden obigen Tabellen zu verknüpfen und die Werte des Feldes example_count in der Tabelle tcount_tbl zu lesen, die allen example_author-Feldern in der Tabelle example_tbl entsprechen:

INNER JOIN

mysql> SELECT a.example_id, a.example_author, b.example_count FROM example_tbl a INNER JOIN tcount_tbl b ON a.example_author = b.example_author; +-------------+-----------------+----------------+ | a.example_id | a.example_author | b.example_count | +-------------+-----------------+----------------+ | 1| Beispiel-Tutorial |10 | | 2| Beispiel-Tutorial |10 | | 3 | EXAMPLE.COM | 20 | | 4 | EXAMPLE.COM | 20 | +-------------+-----------------+----------------+ 4 Zeilen in Satz (0.00 sec)

Die obige SQL-Anweisung ist äquivalent zu:

WHERE-Klausel

mysql> SELECT a.example_id, a.example_author, b.example_count FROM example_tbl a, tcount_tbl b WHERE a.example_author = b.example_author; +-------------+-----------------+----------------+ | a.example_id | a.example_author | b.example_count | +-------------+-----------------+----------------+ | 1| Beispiel-Tutorial |10 | | 2| Beispiel-Tutorial |10 | | 3 | EXAMPLE.COM | 20 | | 4 | EXAMPLE.COM | 20 | +-------------+-----------------+----------------+ 4 Zeilen in Satz (0.01 sec)


MySQL LEFT JOIN

LEFT JOIN ist ein häufig verwendeter Join-Typ, insbesondere wenn Sie alle Zeilen aus der linken Tabelle zurückgeben müssen.

Wenn es in der rechten Tabelle keine übereinstimmende Zeile gibt, werden die zugehörigen Spalten als NULL angezeigt.

Wenn Sie LEFT JOIN verwenden, stellen Sie sicher, dass Sie die Join-Bedingung verstehen und die Ergebnisse nach Bedarf filtern.

MySQL LEFT JOIN unterscheidet sich von JOIN; LEFT JOIN liest alle Daten aus der linken Datentabelle, selbst wenn die rechte Tabelle keine entsprechenden Daten hat.

Beispiel

Versuchen Sie das folgende Beispiel, wobeiexample_tblals linke Tabelle,tcount_tblals rechte Tabelle verwendet werden, um die Anwendung von MySQL LEFT JOIN zu verstehen:

LEFT JOIN

mysql> SELECT a.example_id, a.example_author, b.example_count FROM example_tbl a LEFT JOIN tcount_tbl b ON a.example_author = b.example_author; +-------------+-----------------+----------------+ | a.example_id | a.example_author | b.example_count | +-------------+-----------------+----------------+ | 1| Beispiel-Tutorial |10 | | 2| Beispiel-Tutorial |10 | | 3 | EXAMPLE.COM | 20 | | 4 | EXAMPLE.COM | 20 | | 5 | FK | NULL | +-------------+-----------------+----------------+ 5 Zeilen in Satz (0.01 sec)

Das obige Beispiel verwendet LEFT JOIN, wodurch alle ausgewählten Felddaten aus der linken Datentabelle example_tbl gelesen werden, selbst wenn es in der rechten Tabelle tcount_tbl keinen entsprechenden example_author-Feldwert gibt.


MySQL RIGHT JOIN

MySQL RIGHT JOIN liest alle Daten aus der rechten Datentabelle, selbst wenn die linke Tabelle keine entsprechenden Daten hat.

In der tatsächlichen Entwicklung wird RIGHT JOIN nicht häufig verwendet, da sich derselbe Effekt durch die Verwendung von LEFT JOIN und das Vertauschen der Reihenfolge der Tabellen erzielen lässt.

Beispiel

Versuchen Sie das folgende Beispiel, wobeiexample_tblals linke Tabelle,tcount_tblals rechte Tabelle verwendet werden, um die Anwendung von MySQL RIGHT JOIN zu verstehen:

RIGHT JOIN

mysql> SELECT a.example_id, a.example_author, b.example_count FROM example_tbl a RIGHT JOIN tcount_tbl b ON a.example_author = b.example_author; +-------------+-----------------+----------------+ | a.example_id | a.example_author | b.example_count | +-------------+-----------------+----------------+ | 1| Beispiel-Tutorial |10 | | 2| Beispiel-Tutorial |10 | | 3 | EXAMPLE.COM | 20 | | 4 | EXAMPLE.COM | 20 | | NULL | NULL | 22 | +-------------+-----------------+----------------+ 5 Zeilen in Satz (0.01 sec)

Das obige Beispiel verwendet RIGHT JOIN, das alle ausgewählten Felddaten aus der rechten Datentabelle tcount_tbl liest, selbst wenn es keinen entsprechenden example_author-Feldwert in der linken Tabelle example_tbl gibt.


Verwendung von JOIN in PHP-Skripten

In PHP verwenden Sie die Funktion mysqli_query(), um SQL-Anweisungen auszuführen. Sie können dieselben SQL-Anweisungen wie oben als Parameter der Funktion mysqli_query() verwenden.

Probieren Sie das folgende Beispiel aus:

MySQL ORDER BY Test:

<?php $dbhost = 'localhost'; //Hostadresse des MySQL-Servers $dbuser = 'root'; //MySQL-Benutzername $dbpass = '123456'; //Passwort für den MySQL-Benutzernamen $conn = mysqli_connect($dbhost, $dbuser, $dbpass); if(! $conn ) { die('Verbindung fehlgeschlagen:' . mysqli_error($conn)); } //Kodierung festlegen, um verstümmelte chinesische Zeichen zu vermeiden mysqli_query($conn , "set names utf8"); $sql = 'SELECT a.example_id, a.example_author, b.example_count FROM example_tbl a INNER JOIN tcount_tbl b ON a.example_author = b.example_author'; mysqli_select_db( $conn, 'EXAMPLE' ); $retval = mysqli_query( $conn, $sql ); if(! $retval ) { die('Daten können nicht gelesen werden:' . mysqli_error($conn)); } echo '<h2>Beispiel-Tutorial MySQL JOIN Test<h2>'; echo '<table border="1"><tr><td>Tutorial-ID</td><td>Autor</td><td>Login-Anzahl</td></tr>'; while($row = mysqli_fetch_array($retval, MYSQLI_ASSOC)) { echo "<tr><td> {$row['example_id']}</td> ". "<td>{$row['example_author']} </td> ". "<td>{$row['example_count']} </td> ". "</tr>"; } echo '</table>'; mysqli_close($conn); ?>

Das Ausgabeergebnis ist in der folgenden Abbildung dargestellt:

Weitere Erweiterungen