Viele Datenbankdesigns trennen Informationen in verschiedene Tabellen, basierend auf den Beziehungen zwischen bestimmten Datenpunkten. Selbst in solchen F\u00e4llen kommt es h\u00e4ufig vor, dass man Informationen aus mehreren Tabellen gleichzeitig abrufen m\u00f6chte.<\/p>\n
Eine g\u00e4ngige Methode, um in einer SQL-Operation (Structured Query Language) auf Daten aus mehreren Tabellen zuzugreifen, ist die Verkn\u00fcpfung von Tabellen mit einer JOIN-Klausel. Angelehnt an die Join-Operation in der relationalen Algebra kombiniert eine JOIN-Klausel separate Tabellen, indem sie die Zeilen in jeder Tabelle vergleicht, die miteinander in Beziehung stehen. Typischerweise basiert diese Beziehung auf einem Spaltenpaar \u2013 je eine Spalte aus jeder Tabelle \u2013, das gemeinsame Werte aufweist, beispielsweise den Fremdschl\u00fcssel einer Tabelle und den Prim\u00e4rschl\u00fcssel einer anderen Tabelle, auf den der Fremdschl\u00fcssel verweist.<\/p>\n
Dieser Leitfaden erkl\u00e4rt, wie man verschiedene SQL-Abfragen mit einer JOIN-Klausel erstellt. Er zeigt au\u00dferdem die verschiedenen Arten von JOIN-Klauseln, wie man Daten aus mehreren Tabellen kombiniert und wie man Spalten mit Aliasen versieht, um das Schreiben von JOIN-Operationen zu vereinfachen.<\/p>\n
Um dieser Anleitung zu folgen, ben\u00f6tigen Sie einen Computer mit einem relationalen Datenbankmanagementsystem (RDBMS), das SQL verwendet. Die Anweisungen und Beispiele in dieser Anleitung wurden in der folgenden Umgebung getestet:<\/p>\n
Wenn Ihr SQL-Datenbanksystem auf einem Remote-Server l\u00e4uft, stellen Sie eine SSH-Verbindung von Ihrem lokalen Rechner zu Ihrem Server her:<\/p>\n
ssh sammy@your_server_ip\r\n<\/code><\/pre>\n<\/div>\n\u00d6ffnen Sie anschlie\u00dfend die MySQL-Server-Eingabeaufforderung und ersetzen Sie \u201eSami\u201c durch Ihren MySQL-Benutzernamen:<\/p>\n
\nmysql -u sammy -p\r\n<\/code><\/pre>\n<\/div>\nErstelle eine Datenbank namens joinsDB:<\/p>\n
\nCREATE DATABASE joinsDB;\r\n<\/code><\/pre>\n<\/div>\nWenn die Datenbank erfolgreich erstellt wurde, erhalten Sie folgende Ausgabe:<\/p>\n
\nOutput\r\nQuery OK, 1 row affected (0.01 sec)<\/code><\/pre>\n<\/div>\nUm die joinsDB-Datenbank auszuw\u00e4hlen, f\u00fchren Sie die folgende USE-Anweisung aus:<\/p>\n
\nUSE joinsDB;<\/code><\/pre>\n<\/div>\n\nOutput\r\nDatabase changed<\/code><\/pre>\n<\/div>\nNachdem Sie joinsDB ausgew\u00e4hlt haben, erstellen Sie darin einige Tabellen. Stellen Sie sich f\u00fcr die Beispiele in diesem Leitfaden vor, Sie betreiben eine Fabrik und m\u00f6chten Informationen \u00fcber Ihre Produktionslinie, Ihre Vertriebsmitarbeiter und den Umsatz Ihres Unternehmens in einer SQL-Datenbank erfassen. Sie beginnen mit drei Tabellen, wobei die erste Informationen \u00fcber Ihre Produkte speichert. Sie legen fest, dass diese erste Tabelle drei Spalten ben\u00f6tigt:<\/p>\n
\n- Produkt-ID: Die Identifikationsnummer jedes Produkts, dargestellt als Integer-Wert. Diese Spalte dient als Prim\u00e4rschl\u00fcssel der Tabelle, d. h. jeder Wert identifiziert die entsprechende Zeile eindeutig. Da jeder Wert eines Prim\u00e4rschl\u00fcssels eindeutig sein muss, ist diese Spalte mit der UNIQUE-Einschr\u00e4nkung versehen.<\/li>\n
- productName: Der Name jedes Produkts wird mit Hilfe des Datentyps varchar und maximal 20 Zeichen angegeben.<\/li>\n
- Preis: Der Preis jedes Produkts, angegeben als Dezimalzahl. Dies bedeutet, dass jeder Wert in dieser Spalte maximal vier Stellen haben darf, wobei zwei dieser Stellen rechts vom Dezimaltrennzeichen stehen. Der zul\u00e4ssige Wertebereich in dieser Spalte liegt daher zwischen -99,99 und 99,99.<\/li>\n<\/ul>\n
Erstellen Sie eine Tabelle namens \u201eProdukte\u201c, die diese drei Spalten enth\u00e4lt:<\/p>\n
\nCREATE TABLE products (\r\nproductID int UNIQUE,\r\nproductName varchar(20),\r\nprice decimal (4,2),\r\nPRIMARY KEY (productID)\r\n);<\/code><\/pre>\n<\/div>\nDie zweite Tabelle speichert Informationen \u00fcber die Mitarbeiter Ihres Vertriebsteams. Sie entscheiden, dass auch diese Tabelle drei Spalten ben\u00f6tigt:<\/p>\n
\n- empID: \u00c4hnlich der Spalte productID enth\u00e4lt diese Spalte eine eindeutige Identifikationsnummer f\u00fcr jeden Mitarbeiter im Vertriebsteam, dargestellt als Integer-Datentyp. Daher verf\u00fcgt diese Spalte \u00fcber eine UNIQUE-Einschr\u00e4nkung und dient als Prim\u00e4rschl\u00fcssel f\u00fcr die Teamtabelle.<\/li>\n
- empName: Der Name jedes Verk\u00e4ufers, angegeben als varchar-Datentyp mit maximal 20 Zeichen.<\/li>\n
- Produktspezialisierung: Jedem Mitglied Ihres Vertriebsteams ist ein Produkt als Spezialgebiet zugeordnet. Sie k\u00f6nnen zwar alle Produkte Ihres Unternehmens verkaufen, ihr Schwerpunkt liegt jedoch auf dem jeweiligen Spezialgebiet. Um dies in der Tabelle darzustellen, erstellen Sie diese Spalte, die die Produkt-ID (productID) jedes Produkts enth\u00e4lt, auf das sich der jeweilige Mitarbeiter spezialisiert hat.<\/li>\n<\/ul>\n
Um sicherzustellen, dass die Spalte \u201eproductSpecialty\u201c nur g\u00fcltige Produkt-IDs enth\u00e4lt, wird eine Fremdschl\u00fcsselbedingung auf die Spalte angewendet, die auf die Spalte \u201eproductID\u201c der Tabelle \u201eProducts\u201c verweist. Eine Fremdschl\u00fcsselbedingung beschreibt die Beziehung zwischen zwei Tabellen, indem sie vorschreibt, dass Werte in der Spalte, auf die sie angewendet wird, auch in der referenzierten Spalte vorhanden sein m\u00fcssen. In der folgenden CREATE TABLE-Anweisung legt die FOREIGN KEY-Bedingung fest, dass jeder Wert, der der Spalte \u201eproductSpecialty\u201c in der Tabelle \u201eteam\u201c hinzugef\u00fcgt wird, auch in der Spalte \u201eproductID\u201c der Tabelle \u201eProducts\u201c vorhanden sein muss.<\/p>\n
Erstellen Sie eine Tabelle namens Team mit diesen drei Spalten:<\/p>\n
\nCREATE TABLE team (\r\nempID int UNIQUE,\r\nempName varchar(20),\r\nproductSpecialty int,\r\nPRIMARY KEY (empID),\r\nFOREIGN KEY (productSpecialty) REFERENCES products (productID)\r\n);\r\n<\/code><\/pre>\n<\/div>\nDie letzte Tabelle, die Sie erstellen, enth\u00e4lt die Verkaufsdaten des Unternehmens. Diese Tabelle hat vier Spalten:<\/p>\n
\n- saleID: \u00c4hnlich wie die Spalten productID und empID enth\u00e4lt diese Spalte eine eindeutige Identifikationsnummer f\u00fcr jeden Verkauf, dargestellt als Integer-Datentyp. Diese Spalte verf\u00fcgt au\u00dferdem \u00fcber eine UNIQUE-Einschr\u00e4nkung, sodass sie als Prim\u00e4rschl\u00fcssel der Verkaufstabelle fungieren kann.<\/li>\n
- Menge: Die Anzahl der verkauften Einheiten jedes Produkts wird mit dem Datentyp int ausgedr\u00fcckt.<\/li>\n
- Produkt-ID: Die Identifikationsnummer des verkauften Produkts, ausgedr\u00fcckt als int.<\/li>\n
- Verk\u00e4ufer: Identifikationsnummer des Mitarbeiters, der den Verkauf get\u00e4tigt hat.<\/li>\n<\/ul>\n
Wie bei der Spalte \u201eproductSpecialty\u201c aus der Tabelle \u201eteam\u201c entscheiden Sie sich, FOREIGN KEY-Constraints sowohl auf die Spalte \u201eproductID\u201c als auch auf die Spalte \u201esalesperson\u201c anzuwenden. Dadurch wird sichergestellt, dass diese Spalten nur Werte enthalten, die in der Spalte \u201eproductID\u201c der Tabelle \u201eproducts\u201c bzw. in der Spalte \u201eempID\u201c der Tabelle \u201eteam\u201c vorhanden sind.<\/p>\n
Erstellen Sie eine Tabelle namens \u201eUmsatz\u201c mit diesen vier Spalten:<\/p>\n
\nCREATE TABLE sales (\r\nsaleID int UNIQUE,\r\nquantity int,\r\nproductID int,\r\nsalesperson int,\r\nPRIMARY KEY (saleID),\r\nFOREIGN KEY (productID) REFERENCES products (productID),\r\nFOREIGN KEY (salesperson) REFERENCES team (empID)\r\n);<\/code><\/pre>\n<\/div>\nLaden Sie anschlie\u00dfend die Tabelle \u201eProducts\u201c mit Beispieldaten, indem Sie die folgende INSERT INTO-Operation ausf\u00fchren:<\/p>\n
\nINSERT INTO products\r\nVALUES\r\n(1, 'widget', 18.99),\r\n(2, 'gizmo', 14.49),\r\n(3, 'thingamajig', 39.99),\r\n(4, 'doodad', 11.50),\r\n(5, 'whatzit', 29.99);<\/code><\/pre>\n<\/div>\nLaden Sie anschlie\u00dfend die Teamtabelle mit Beispieldaten:<\/p>\n
\nINSERT INTO team\r\nVALUES\r\n(1, 'Florence', 1),\r\n(2, 'Mary', 4),\r\n(3, 'Diana', 3),\r\n(4, 'Betty', 2);<\/code><\/pre>\n<\/div>\nLaden Sie die Verkaufstabelle ebenfalls mit Beispieldaten:<\/p>\n
\nINSERT INTO sales\r\nVALUES\r\n(1, 7, 1, 1),\r\n(2, 10, 5, 4),\r\n(3, 8, 2, 4),\r\n(4, 1, 3, 3),\r\n(5, 5, 1, 3);<\/code><\/pre>\n<\/div>\nStellen Sie sich abschlie\u00dfend vor, Ihr Unternehmen t\u00e4tigt einige Verk\u00e4ufe, ohne dass jemand aus Ihrem Vertriebsteam daran beteiligt ist. Um diese Verk\u00e4ufe zu erfassen, f\u00fchren Sie die folgende Operation aus, um der Tabelle \u201eVerk\u00e4ufe\u201c drei Zeilen hinzuzuf\u00fcgen, die keinen Wert in der Spalte \u201eVerk\u00e4ufer\u201c enthalten:<\/p>\n
\nINSERT INTO sales (saleID, quantity, productID)\r\nVALUES\r\n(6, 1, 5),\r\n(7, 3, 1),\r\n(8, 4, 5);<\/code><\/pre>\n<\/div>\nDamit sind Sie bereit, dem Rest der Anleitung zu folgen und zu lernen, wie man Tabellen in SQL miteinander verkn\u00fcpft.<\/p>\n
Die Syntax der JOIN-Operation verstehen<\/h5>\n
JOIN-Klauseln k\u00f6nnen in verschiedenen SQL-Anweisungen verwendet werden, darunter UPDATE- und DELETE-Operationen. Zur Veranschaulichung verwenden die Beispiele in diesem Leitfaden jedoch SELECT-Abfragen, um die Funktionsweise von JOIN-Klauseln zu demonstrieren.<\/p>\n
Das folgende Beispiel zeigt die allgemeine Syntax einer SELECT-Anweisung, die eine JOIN-Klausel enth\u00e4lt:<\/p>\n
\nSELECT table1.column1, table2.column2\r\nFROM table1 JOIN table2\r\nON search_condition;<\/code><\/pre>\n<\/div>\nDiese Syntax beginnt mit einer SELECT-Anweisung, die zwei Spalten aus zwei separaten Tabellen zur\u00fcckgibt. Da JOIN-Klauseln die Inhalte mehrerer Tabellen vergleichen, gibt diese Beispielsyntax an, aus welcher Tabelle jede Spalte ausgew\u00e4hlt werden soll. Dazu wird dem Spaltennamen der Tabellenname und ein Punkt vorangestellt. Dies wird als vollqualifizierter Spaltenverweis bezeichnet.<\/p>\n
Sie k\u00f6nnen vollqualifizierte Spaltenreferenzen wie diese in jeder Operation verwenden. Technisch gesehen ist dies jedoch nur dann notwendig, wenn zwei Spalten aus verschiedenen Tabellen denselben Namen haben. Es empfiehlt sich jedoch, sie bei der Arbeit mit mehreren Tabellen zu verwenden, da sie die Lesbarkeit und das Verst\u00e4ndnis von JOIN-Operationen verbessern.<\/p>\n
Nach SELECT folgt die FROM-Klausel. In jeder Abfrage definiert die FROM-Klausel den Datensatz, der durchsucht werden soll, um die gew\u00fcnschten Daten zu erhalten. Der einzige Unterschied besteht darin, dass die FROM-Klausel aus zwei Tabellen besteht, die durch das Schl\u00fcsselwort JOIN getrennt sind. Eine hilfreiche Methode zum Schreiben von Abfragen ist, sich zu merken, welche Spalten aus welcher Tabelle zur\u00fcckgegeben werden sollen.<\/p>\n
Anschlie\u00dfend folgt die ON-Klausel, die anhand einer Suchbedingung festlegt, wie die Abfrage die beiden Tabellen verkn\u00fcpfen soll. Eine Suchbedingung besteht aus einer oder mehreren Anweisungen oder Ausdr\u00fccken, die f\u00fcr eine bestimmte Bedingung den Wert \u00abwahr\u00bb, \u00abfalsch\u00bb oder \u00abunbekannt\u00bb ergeben k\u00f6nnen. Man kann sich die JOIN-Operation so vorstellen, dass sie alle Zeilen beider Tabellen kombiniert und anschlie\u00dfend alle Zeilen zur\u00fcckgibt, f\u00fcr die die Suchbedingung in der ON-Klausel den Wert \u201cwahr\u201d ergibt.<\/p>\n
In einer ON-Klausel ist es \u00fcblicherweise sinnvoll, eine Suchbedingung einzuf\u00fcgen, die pr\u00fcft, ob zwei zusammengeh\u00f6rige Spalten \u2013 beispielsweise der Fremdschl\u00fcssel einer Tabelle und der Prim\u00e4rschl\u00fcssel einer anderen Tabelle, auf die der Fremdschl\u00fcssel verweist \u2013 gleiche Werte aufweisen. Dies wird auch als Equi-Join bezeichnet.<\/p>\n
Um zu veranschaulichen, wie equi \u00fcbereinstimmende Daten aus mehreren Tabellen verkn\u00fcpfen kann, f\u00fchren Sie die folgende Abfrage mit den zuvor hinzugef\u00fcgten Beispieldaten aus. Diese verkn\u00fcpft die Tabellen \u201eProducts\u201c und \u201eTeam\u201c mithilfe einer Suchbedingung, die auf \u00fcbereinstimmende Werte in den jeweiligen Spalten \u201eproductID\u201c und \u201eproductSpecialty\u201c pr\u00fcft. Anschlie\u00dfend werden der Name jedes Vertriebsteammitglieds, der Name jedes Produkts, auf das es spezialisiert ist, und der Preis dieser Produkte zur\u00fcckgegeben.<\/p>\n
\n\nSELECT team.empName, products.productName, products.price\r\nFROM products JOIN team\r\nON products.productID = team.productSpecialty<\/code><\/pre>\n<\/div>\n\u062f\u0631 \u0627\u06cc\u0646\u062c\u0627 \u0645\u062c\u0645\u0648\u0639\u0647 \u0646\u062a\u0627\u06cc\u062c \u0627\u06cc\u0646 \u067e\u0631\u0633 \u0648 \u062c\u0648 \u0627\u0633\u062a:<\/p>\n<\/div>\n
\n\nOutput\r\n+----------+-------------+-------+\r\n| empName | productName | price |\r\n+----------+-------------+-------+\r\n| Florence | widget | 18.99 |\r\n| Mary | doodad | 11.50 |\r\n| Diana | thingamajig | 39.99 |\r\n| Betty | gizmo | 14.49 |\r\n+----------+-------------+-------+\r\n4 rows in set (0.00 sec)<\/code><\/pre>\n<\/div>\n<\/div>\n\nUm zu veranschaulichen, wie SQL diese Tabellen kombiniert, um dieses Ergebnis-Set zu erzeugen, sehen wir uns den Prozess genauer an. Zur Klarstellung: Das Folgende entspricht nicht exakt der Vorgehensweise eines Datenbankmanagementsystems beim Verkn\u00fcpfen zweier Tabellen, aber es kann hilfreich sein, die JOIN-Operation als Prozedur zu betrachten.<\/p>\n
Zuerst gibt die Abfrage die Produkte f\u00fcr jede Zeile und Spalte der ersten Tabelle in der FROM-Klausel aus:<\/p>\n
\nJOIN Process Example\r\n+-----------+-------------+-------+\r\n| productID | productName | price |\r\n+-----------+-------------+-------+\r\n| 1 | widget | 18.99 |\r\n| 2 | gizmo | 14.49 |\r\n| 3 | thingamajig | 39.99 |\r\n| 4 | doodad | 11.50 |\r\n| 5 | whatzit | 29.99 |\r\n+-----------+-------------+-------+<\/code><\/pre>\n\u0633\u067e\u0633\u060c \u0628\u0647 \u0647\u0631 \u06cc\u06a9 \u0627\u0632 \u0627\u06cc\u0646 \u0631\u062f\u06cc\u0641\u200c\u0647\u0627 \u0646\u06af\u0627\u0647 \u0645\u06cc\u200c\u06a9\u0646\u062f \u0648 \u0628\u0627 \u0647\u0631 \u0631\u062f\u06cc\u0641\u06cc \u0627\u0632 \u062c\u062f\u0648\u0644 \u062a\u06cc\u0645 \u06a9\u0647 productSpecialty \u0622\u0646 \u0628\u0631\u0627\u0628\u0631 \u0628\u0627 \u0645\u0642\u062f\u0627\u0631 productID \u062f\u0631 \u0622\u0646 \u0633\u0637\u0631 \u0627\u0633\u062a\u060c \u0645\u0637\u0627\u0628\u0642\u062a \u0645\u06cc\u200c\u062f\u0647\u062f:<\/div>\n\n\nJOIN Process Example\r\n+-----------+-------------+-------+-------+----------+------------------+\r\n| productID | productName | price | empID | empName | productSpecialty |\r\n+-----------+-------------+-------+-------+----------+------------------+\r\n| 1 | widget | 18.99 | 1 | Florence | 1 |\r\n| 2 | gizmo | 14.49 | 4 | Betty | 2 |\r\n| 3 | thingamajig | 39.99 | 3 | Diana | 3 |\r\n| 4 | doodad | 11.50 | 2 | Mary | 4 |\r\n| 5 | whatzit | 29.99 | | | |\r\n+-----------+-------------+-------+-------+----------+------------------+<\/code><\/pre>\n\u0633\u067e\u0633\u060c \u0633\u0637\u0631\u0647\u0627\u06cc\u06cc \u0631\u0627 \u06a9\u0647 \u0645\u0637\u0627\u0628\u0642\u062a \u0646\u062f\u0627\u0631\u0646\u062f \u0631\u0627 \u0628\u0631\u0634 \u0645\u06cc\u200c\u062f\u0647\u062f \u0648 \u0633\u062a\u0648\u0646\u200c\u0647\u0627 \u0631\u0627 \u0628\u0631 \u0627\u0633\u0627\u0633 \u062a\u0631\u062a\u06cc\u0628 \u0622\u0646\u0647\u0627 \u062f\u0631 \u0639\u0628\u0627\u0631\u062a SELECT \u0645\u0631\u062a\u0628 \u0645\u06cc\u200c\u06a9\u0646\u062f\u060c \u0633\u062a\u0648\u0646\u200c\u0647\u0627\u06cc\u06cc \u0631\u0627 \u06a9\u0647 \u0645\u0634\u062e\u0635 \u0646\u0634\u062f\u0647 \u0628\u0648\u062f\u0646\u062f \u062d\u0630\u0641 \u0645\u06cc\u200c\u06a9\u0646\u062f\u060c \u0631\u062f\u06cc\u0641\u200c\u0647\u0627 \u0631\u0627 \u0645\u062a\u0648\u0633\u0644 \u0645\u06cc\u200c\u06a9\u0646\u062f \u0648 \u0645\u062c\u0645\u0648\u0639\u0647 \u0646\u062a\u0627\u06cc\u062c \u0646\u0647\u0627\u06cc\u06cc \u0631\u0627 \u0628\u0631\u0645\u06cc\u200c\u06af\u0631\u062f\u0627\u0646\u062f:<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n\n\nJOIN Process Example\r\n+----------+-------------+-------+\r\n| empName | productName | price |\r\n+----------+-------------+-------+\r\n| Florence | widget | 18.99 |\r\n| Mary | doodad | 11.50 |\r\n| Diana | thingamajig | 39.99 |\r\n| Betty | gizmo | 14.49 |\r\n+----------+-------------+-------+\r\n4 rows in set (0.00 sec)<\/code><\/pre>\n<\/div>\n<\/div>\n\nDie Verwendung von Equi-Joins ist die gebr\u00e4uchlichste Methode, um Tabellen zu verkn\u00fcpfen. Alternativ k\u00f6nnen in der ON-Klausel auch andere SQL-Operatoren wie <, >, LIKE, NOT LIKE oder sogar BETWEEN verwendet werden. Beachten Sie jedoch, dass komplexere Suchbedingungen die Vorhersage der Ergebnisse erschweren k\u00f6nnen.<\/p>\n
In den meisten Implementierungen lassen sich Tabellen \u00fcber beliebige Spalten verkn\u00fcpfen, deren Datentyp gem\u00e4\u00df SQL-Standard \u00abqualifizierter JOIN\u00bb lautet. Das bedeutet, dass Sie im Allgemeinen eine Spalte mit numerischen Daten mit jeder anderen Spalte mit numerischen Daten verkn\u00fcpfen k\u00f6nnen, unabh\u00e4ngig von den jeweiligen Datentypen. Ebenso k\u00f6nnen Sie in der Regel jede Spalte mit Zeichenwerten mit jeder anderen Spalte mit Zeichendaten verkn\u00fcpfen. Wie bereits erw\u00e4hnt, handelt es sich bei den Spalten, die Sie zum Verkn\u00fcpfen zweier Tabellen verwenden, \u00fcblicherweise um Spalten, die eine Beziehung zwischen den Tabellen darstellen, beispielsweise einen Fremdschl\u00fcssel und den Prim\u00e4rschl\u00fcssel der referenzierten Tabelle.<\/p>\n
Viele SQL-Implementierungen erm\u00f6glichen es, Spalten mit gleichem Namen mit dem Schl\u00fcsselwort USING anstelle von ON zu verkn\u00fcpfen. Die Syntax f\u00fcr eine solche Operation k\u00f6nnte wie folgt lauten:<\/p>\n
\nSELECT table1.column1, table2.column2\r\nFROM table1 JOIN table2\r\nUSING (related_column);<\/code><\/pre>\n<\/div>\n<\/div>\n\nIn dieser Beispielsyntax entspricht die USING-Anweisung der Anweisung ON table1.related_column = table2.related_column;.<\/p>\n
Da sowohl Verk\u00e4ufe als auch Produkte eine Spalte namens ProduktID besitzen, k\u00f6nnen Sie diese Spalten mithilfe des Schl\u00fcsselworts USING verkn\u00fcpfen. Die folgende Anweisung f\u00fchrt dies aus und gibt die Verkaufs-ID jedes Verkaufs, die Anzahl der verkauften Einheiten, den Namen jedes verkauften Produkts und dessen Preis zur\u00fcck. Au\u00dferdem wird das Ergebnis nach dem Wert der Verkaufs-ID in aufsteigender Reihenfolge sortiert:<\/p>\n
\nSELECT sales.saleID, sales.quantity, products.productName, products.price\r\nFROM sales JOIN products\r\nUSING (productID)\r\nORDER BY saleID;<\/code><\/pre>\n<\/div>\n<\/div>\n\n\nOutput\r\n+--------+----------+-------------+-------+\r\n| saleID | quantity | productName | price |\r\n+--------+----------+-------------+-------+\r\n| 1 | 7 | widget | 18.99 |\r\n| 2 | 10 | whatzit | 29.99 |\r\n| 3 | 8 | gizmo | 14.49 |\r\n| 4 | 1 | thingamajig | 39.99 |\r\n| 5 | 5 | widget | 18.99 |\r\n| 6 | 1 | whatzit | 29.99 |\r\n| 7 | 3 | widget | 18.99 |\r\n| 8 | 4 | whatzit | 29.99 |\r\n+--------+----------+-------------+-------+\r\n8 rows in set (0.00 sec)<\/code><\/pre>\n<\/div>\n<\/div>\n\nBeim Verkn\u00fcpfen von Tabellen ordnet das Datenbanksystem die Zeilen manchmal auf schwer vorhersehbare Weise an. Die Verwendung einer ORDER BY-Klausel wie dieser kann dazu beitragen, die Ergebnismengen \u00fcbersichtlicher und lesbarer zu gestalten.<\/p>\n
Verkn\u00fcpfung von mehr als zwei Tabellen<\/h5>\n
Es kann vorkommen, dass Sie Daten aus mehr als zwei Tabellen kombinieren m\u00fcssen. Sie k\u00f6nnen beliebig viele Tabellen verkn\u00fcpfen, indem Sie JOIN-Klauseln ineinander verschachteln. Die folgende Syntax zeigt beispielhaft, wie die Verkn\u00fcpfung von drei Tabellen aussieht:<\/p>\n
\nSELECT table1.column1, table2.column2, table3.column3\r\nFROM table1 JOIN table2\r\nON table1.related_column = table2.related_column\r\nJOIN table3\r\nON table3.related_column = table1_or_2.related_column;<\/code><\/pre>\n<\/div>\n<\/div>\n\nDie FROM-Klausel in dieser Beispielanweisung beginnt mit dem Verkn\u00fcpfen von Tabelle 1 mit Tabelle 2. Nach dieser ON-Klausel folgt ein zweiter JOIN, der die ersten verkn\u00fcpften Tabellen mit Tabelle 3 kombiniert. Beachten Sie, dass die dritte Tabelle mit einer Spalte entweder der ersten oder der zweiten Tabelle verkn\u00fcpft werden kann.<\/p>\n
Stellen Sie sich beispielsweise vor, Sie m\u00f6chten wissen, wie viel Umsatz Ihr Mitarbeiter generiert hat, interessieren sich aber nur f\u00fcr Verkaufsdaten, die Verk\u00e4ufe eines Produkts beinhalten, auf das sich der Mitarbeiter spezialisiert hat.<\/p>\n
Um diese Informationen zu erhalten, k\u00f6nnen Sie die folgende Abfrage ausf\u00fchren. Diese Abfrage verkn\u00fcpft zun\u00e4chst die Tabellen \u201eProdukte\u201c und \u201eVerk\u00e4ufe\u201c anhand ihrer jeweiligen Spalten \u201eproductID\u201c. Anschlie\u00dfend wird die Tabelle \u201eTeam\u201c mit den ersten beiden Tabellen verkn\u00fcpft, indem jede Zeile im ersten JOIN mit ihrer Spalte \u201eproductSpecialty\u201c abgeglichen wird. Die Abfrage filtert die Ergebnisse dann mithilfe einer WHERE-Klausel, um nur Zeilen zur\u00fcckzugeben, in denen der zugeordnete Mitarbeiter auch die Person ist, die den Verkauf get\u00e4tigt hat. Die Abfrage enth\u00e4lt au\u00dferdem eine ORDER BY-Klausel, die die endg\u00fcltigen Ergebnisse aufsteigend nach dem Wert in der Spalte \u201esaleID\u201c sortiert.<\/p>\n
\nSELECT sales.saleID,\r\nteam.empName,\r\nproducts.productName,\r\n(sales.quantity * products.price)\r\nFROM products JOIN sales\r\nUSING (productID)\r\nJOIN team\r\nON team.productSpecialty = sales.productID\r\nWHERE team.empID = sales.salesperson\r\nORDER BY sales.saleID;\r\n<\/code><\/pre>\n<\/div>\n<\/div>\nBeachten Sie, dass sich unter den in der SELECT-Anweisung aufgef\u00fchrten Spalten eine Anweisung befindet, die die Werte in der Spalte \u201eValue\u201c der Tabelle \u201eSales\u201c mit den Preiswerten in der Tabelle \u201eProducts\u201c multipliziert. \u201eProducts\u201c gibt diese Werte in den entsprechenden Zeilen zur\u00fcck:<\/div>\n\n\nOutput\r\n+--------+----------+-------------+-----------------------------------+\r\n| saleID | empName | productName | (sales.quantity * products.price) |\r\n+--------+----------+-------------+-----------------------------------+\r\n| 1 | Florence | widget | 132.93 |\r\n| 3 | Betty | gizmo | 115.92 |\r\n| 4 | Diana | thingamajig | 39.99 |\r\n+--------+----------+-------------+-----------------------------------+\r\n3 rows in set (0.00 sec)<\/code><\/pre>\n<\/div>\n<\/div>\n\nAlle bisherigen Beispiele verwendeten nur einen JOIN-Ausdruck: einen INNER JOIN. Im n\u00e4chsten Abschnitt erhalten Sie einen \u00dcberblick \u00fcber INNER JOINs, OUTER JOINs und deren Unterschiede.<\/p>\n
Inner vs. outer JOIN-Operationen<\/h2>\n
Es gibt zwei Haupttypen von JOIN-Anweisungen: INNER Joins und OUTER Joins. Der Unterschied zwischen diesen beiden Arten von Joins liegt in den zur\u00fcckgegebenen Daten. INNER Joins geben nur \u00fcbereinstimmende Zeilen aus jeder verkn\u00fcpften Tabelle zur\u00fcck, w\u00e4hrend OUTER Joins sowohl \u00fcbereinstimmende als auch nicht \u00fcbereinstimmende Zeilen zur\u00fcckgeben.<\/p>\n
Die Syntax und die Beispielabfragen aus den vorherigen Abschnitten verwenden alle INNER JOIN-Anweisungen, obwohl keine von ihnen das Schl\u00fcsselwort INNER enth\u00e4lt. Die meisten SQL-Implementierungen behandeln jede JOIN-Anweisung als INNER JOIN, sofern nicht explizit anders angegeben.<\/p>\n
Abfragen mit einem \u00e4u\u00dferen JOIN kombinieren mehrere Tabellen und geben sowohl \u00fcbereinstimmende als auch nicht \u00fcbereinstimmende Zeilen zur\u00fcck. Dies ist hilfreich, um Zeilen mit fehlenden Werten zu finden oder wenn eine Teil\u00fcbereinstimmung akzeptabel ist.<\/p>\n
Outer Joins lassen sich in drei Typen unterteilen: LEFT OUTER Joins, RIGHT OUTER Joins und FULL OUTER Joins. LEFT OUTER Joins, kurz LEFT Joins, geben alle \u00fcbereinstimmenden Zeilen der beiden verkn\u00fcpften Tabellen sowie alle nicht \u00fcbereinstimmenden Zeilen der \u201clinken\u201d Tabelle zur\u00fcck. Im Kontext einer JOIN-Operation ist die \u201clinke\u201d Tabelle immer die erste Tabelle, die direkt nach dem Schl\u00fcsselwort FROM und links vom Schl\u00fcsselwort JOIN angegeben wird. Analog dazu ist die \u00abrechte\u00bb Tabelle die zweite Tabelle, also die Tabelle, die direkt nach JOIN folgt. Ein RIGHT OUTER Join gibt alle \u00fcbereinstimmenden Zeilen der verkn\u00fcpften Tabellen sowie alle nicht \u00fcbereinstimmenden Zeilen der \u00abrechten\u00bb Tabelle zur\u00fcck. Ein FULL OUTER JOIN gibt alle Zeilen beider Tabellen zur\u00fcck, einschlie\u00dflich der Zeilen, die in keiner der beiden Tabellen \u00fcbereinstimmen.<\/p>\n
Um zu veranschaulichen, wie die verschiedenen Arten von JOIN-Klauseln Daten zur\u00fcckgeben, f\u00fchren Sie die folgenden Beispielabfragen auf den Tabellen aus, die im vorherigen Abschnitt \u201eVerbindung zu und Einrichtung einer Beispieldatenbank\u201c erstellt wurden. Diese Abfragen sind bis auf die Angabe einer anderen Art von JOIN-Klausel identisch.<\/p>\n
Dieses erste Beispiel verwendet einen INNER JOIN, um die Tabellen \u201eVertrieb\u201c und \u201eTeam\u201c anhand der entsprechenden Spalten \u201eVerk\u00e4ufer\u201c und \u201eMitarbeiter-ID\u201c zu verkn\u00fcpfen. Auch hier ist das Schl\u00fcsselwort INNER implizit enthalten, obwohl es nicht explizit angegeben ist:<\/p>\n
\nSELECT sales.saleID, sales.quantity, sales.salesperson, team.empName \r\nFROM sales JOIN team\r\nON sales.salesperson = team.empID;<\/code><\/pre>\n<\/div>\n<\/div>\nDa diese Abfrage eine innere JOIN-Klausel verwendet, werden nur \u00fcbereinstimmende Zeilen aus beiden Tabellen zur\u00fcckgegeben:<\/div>\n\n\nOutput\r\n+--------+----------+-------------+----------+\r\n| saleID | quantity | salesperson | empName |\r\n+--------+----------+-------------+----------+\r\n| 1 | 7 | 1 | Florence |\r\n| 4 | 1 | 3 | Diana |\r\n| 5 | 5 | 3 | Diana |\r\n| 2 | 10 | 4 | Betty |\r\n| 3 | 8 | 4 | Betty |\r\n+--------+----------+-------------+----------+\r\n5 rows in set (0.00 sec)<\/pre>\n<\/div>\n<\/div>\nDiese Version der Abfrage verwendet stattdessen eine LEFT OUTER JOIN-Klausel:<\/div>\n\n\nSELECT sales.saleID, sales.quantity, sales.salesperson, team.empName\r\nFROM sales LEFT OUTER JOIN team\r\nON sales.salesperson = team.empID;<\/code><\/pre>\n<\/div>\n<\/div>\nWie die vorherige Abfrage gibt auch diese alle \u00fcbereinstimmenden Werte aus beiden Tabellen zur\u00fcck. Sie gibt jedoch alle Werte aus der \u00ablinken\u00bb Tabelle (in diesem Fall Sales) zur\u00fcck, die keine Entsprechung in der \u00abrechten\u00bb Tabelle (Team) haben. Da diese Zeilen in der linken Tabelle keine Entsprechung in der rechten Tabelle haben, werden die nicht \u00fcbereinstimmenden Werte als NULL zur\u00fcckgegeben.<\/div>\n\n\nOutput\r\n+--------+----------+-------------+----------+\r\n| saleID | quantity | salesperson | empName |\r\n+--------+----------+-------------+----------+\r\n| 1 | 7 | 1 | Florence |\r\n| 2 | 10 | 4 | Betty |\r\n| 3 | 8 | 4 | Betty |\r\n| 4 | 1 | 3 | Diana |\r\n| 5 | 5 | 3 | Diana |\r\n| 6 | 1 | NULL | NULL |\r\n| 7 | 3 | NULL | NULL |\r\n| 8 | 4 | NULL | NULL |\r\n+--------+----------+-------------+----------+\r\n8 rows in set (0.00 sec)<\/code><\/pre>\n<\/div>\n<\/div>\nDie n\u00e4chste Version der Abfrage verwendet stattdessen eine RIGHT JOIN-Klausel:<\/div>\n\n\nSELECT sales.saleID, sales.quantity, sales.salesperson, team.empName\r\nFROM sales RIGHT JOIN team\r\nON sales.salesperson = team.empID;<\/code><\/pre>\n<\/div>\n<\/div>\n\nBeachten Sie, dass die JOIN-Klausel dieser Abfrage RIGHT JOIN und nicht RIGHT OUTER JOIN lautet. Genau wie das Schl\u00fcsselwort INNER f\u00fcr eine INNER JOIN-Klausel nicht erforderlich ist, ist OUTER implizit enthalten, wenn Sie LEFT JOIN oder RIGHT JOIN schreiben.<\/p>\n
Das Ergebnis dieser Abfrage ist das Gegenteil der vorherigen, da sie jede Zeile aus beiden Tabellen zur\u00fcckgibt, aber nur eindeutige Zeilen aus der \u201crechten\u201d Tabelle:<\/p>\n
\nOutput\r\n+--------+----------+-------------+----------+\r\n| saleID | quantity | salesperson | empName |\r\n+--------+----------+-------------+----------+\r\n| 1 | 7 | 1 | Florence |\r\n| NULL | NULL | NULL | Mary |\r\n| 4 | 1 | 3 | Diana |\r\n| 5 | 5 | 3 | Diana |\r\n| 2 | 10 | 4 | Betty |\r\n| 3 | 8 | 4 | Betty |\r\n+--------+----------+-------------+----------+\r\n6 rows in set (0.00 sec)<\/code><\/pre>\n<\/div>\n<\/div>\n\nTabellen- und Spaltenaliase in JOIN-Klauseln<\/p>\n
Beim Verkn\u00fcpfen von Tabellen mit langen oder sehr beschreibenden Namen kann das Schreiben mehrerer vollst\u00e4ndig qualifizierter Spaltenreferenzen m\u00fchsam sein. Um dies zu vermeiden, verwenden Benutzer manchmal einen k\u00fcrzeren Tabellen- oder Spaltennamenalias.<\/p>\n
In SQL k\u00f6nnen Sie dies erreichen, indem Sie jeder Tabellendefinition in der FROM-Klausel das Schl\u00fcsselwort AS und anschlie\u00dfend den Alias Ihrer Wahl hinzuf\u00fcgen:<\/p>\n
\nSELECT t1.column1, t2.column2\r\nFROM table1 AS t1 JOIN table2 AS t2\r\nON t1.related_column = t2.related_column;<\/code><\/pre>\n<\/div>\n<\/div>\n\nDiese Beispielsyntax verwendet Aliase in der SELECT-Klausel, obwohl diese nicht vor der FROM-Klausel definiert sind. Dies ist m\u00f6glich, da die Ausf\u00fchrung von SQL-Abfragen mit der FROM-Klausel beginnt. Das kann verwirrend sein, aber es ist hilfreich, sich dies zu merken und \u00fcber Aliase nachzudenken, bevor man mit dem Schreiben der Abfrage beginnt.<\/p>\n
F\u00fchren Sie beispielsweise die folgende Abfrage aus, die die Tabellen Sales und Products verkn\u00fcpft und ihnen die Aliase S bzw. P zuweist:<\/p>\n
\nSELECT S.saleID, S.quantity,\r\nP.productName,\r\n(P.price * S.quantity) AS revenue \r\nFROM sales AS S JOIN products AS P\r\nUSING (productID);<\/code><\/pre>\n<\/div>\n<\/div>\nBeachten Sie, dass dieses Beispiel einen dritten Alias, \u201eUmsatz\u201c, f\u00fcr das Produkt der Werte in der Spalte \u201eBetrag\u201c der Tabelle \u201eVerkauf\u201c und der entsprechenden Werte aus der Spalte \u201ePreis\u201c der Tabelle \u201eProdukte\u201c erstellt. Dies ist nur im Spaltennamen des Ergebnissatzes ersichtlich, aber die Bereitstellung eines solchen Alias kann hilfreich sein, um die Bedeutung oder Absicht hinter den Abfrageergebnissen zu verdeutlichen:<\/div>\n\n\nOutput\r\n+--------+----------+-------------+---------+\r\n| saleID | quantity | productName | revenue |\r\n+--------+----------+-------------+---------+\r\n| 1 | 7 | widget | 132.93 |\r\n| 2 | 10 | whatzit | 299.90 |\r\n| 3 | 8 | gizmo | 115.92 |\r\n| 4 | 1 | thingamajig | 39.99 |\r\n| 5 | 5 | widget | 94.95 |\r\n| 6 | 1 | whatzit | 29.99 |\r\n| 7 | 3 | widget | 56.97 |\r\n| 8 | 4 | whatzit | 119.96 |\r\n+--------+----------+-------------+---------+\r\n8 rows in set (0.00 sec)<\/code><\/pre>\n<\/div>\n<\/div>\nBeachten Sie, dass das Schl\u00fcsselwort AS bei der Definition eines Alias technisch optional ist. Das vorherige Beispiel k\u00f6nnte auch wie folgt geschrieben werden:<\/div>\n\n\nSELECT S.saleID, S.quantity, P.productName, (P.price * S.quantity) revenue \r\nFROM sales S JOIN products P\r\nUSING (productID);<\/code><\/pre>\n<\/div>\n<\/div>\n\nObwohl das Schl\u00fcsselwort AS f\u00fcr die Definition eines Alias nicht zwingend erforderlich ist, gilt es als bew\u00e4hrte Praxis, es zu verwenden. Dadurch wird die Absicht der Abfrage klarer und ihre Lesbarkeit verbessert.<\/p>\n
Ergebnis<\/h2>\n
In dieser Anleitung haben Sie gelernt, wie Sie mit der JOIN-Operation separate Tabellen zu einem einzigen Abfrageergebnis kombinieren. Die hier gezeigten Befehle sollten zwar in den meisten relationalen Datenbanken funktionieren, jedoch verwendet jede SQL-Datenbank ihre eigene Implementierung der Sprache. Eine ausf\u00fchrlichere Erkl\u00e4rung der einzelnen Befehle und ihrer Optionen finden Sie in der Dokumentation Ihres Datenbankmanagementsystems (DBMS).<\/p>\n<\/div>","protected":false},"excerpt":{"rendered":"Einleitung Viele Datenbankdesigns organisieren Informationen in Tabellen basierend auf Beziehungen zwischen spezifischen Datenpunkten.","protected":false},"author":1,"featured_media":16027,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_yoast_wpseo_focuskw":"\u0646\u062d\u0648\u0647 \u0627\u0633\u062a\u0641\u0627\u062f\u0647 \u0627\u0632 Joins \u062f\u0631 SQL","_yoast_wpseo_title":"","_yoast_wpseo_metadesc":"","_yoast_wpseo_canonical":"","_yoast_wpseo_opengraph-description":"","_yoast_wpseo_opengraph-image":"","_yoast_wpseo_twitter-description":"","_yoast_wpseo_twitter-image":"","_yoast_wpseo_focuskeywords":"","_yoast_wpseo_primary_category":"193","footnotes":""},"categories":[193,349],"tags":[403,391],"class_list":{"0":"post-15949","1":"post","2":"type-post","3":"status-publish","4":"format-standard","5":"has-post-thumbnail","7":"category-tutorials","8":"category-database","9":"tag-data-base","10":"tag-mysql"},"yoast_head":"\n
\u0646\u062d\u0648\u0647 \u0627\u0633\u062a\u0641\u0627\u062f\u0647 \u0627\u0632 Joins \u062f\u0631 SQL - \u0628\u0644\u0627\u06af ITPiran<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.itpiran.net\/blog\/de\/tutorials\/how-to-use-joins-in-sql\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"\u0646\u062d\u0648\u0647 \u0627\u0633\u062a\u0641\u0627\u062f\u0647 \u0627\u0632 Joins \u062f\u0631 SQL - \u0628\u0644\u0627\u06af ITPiran\" \/>\n<meta property=\"og:description\" content=\"\u0645\u0642\u062f\u0645\u0647 \u0628\u0633\u06cc\u0627\u0631\u06cc \u0627\u0632 \u0637\u0631\u0627\u062d\u06cc \u0647\u0627\u06cc \u067e\u0627\u06cc\u06af\u0627\u0647 \u062f\u0627\u062f\u0647 \u0628\u0631 \u0627\u0633\u0627\u0633 \u0631\u0648\u0627\u0628\u0637 \u0628\u06cc\u0646 \u0646\u0642\u0627\u0637 \u062f\u0627\u062f\u0647 \u062e\u0627\u0635\u060c \u0627\u0637\u0644\u0627\u0639\u0627\u062a \u0631\u0627 \u0628\u0647 \u062c\u062f\u0627\u0648\u0644…\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.itpiran.net\/blog\/de\/tutorials\/how-to-use-joins-in-sql\/\" \/>\n<meta property=\"og:site_name\" content=\"\u0628\u0644\u0627\u06af ITPiran\" \/>\n<meta property=\"article:published_time\" content=\"2024-07-22T17:56:37+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-08-14T17:02:31+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/cdn.itpiran.net\/2024\/07\/14203156\/joins-sql.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1793\" \/>\n\t<meta property=\"og:image:height\" content=\"1110\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"admin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"admin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"4\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/\"},\"author\":{\"name\":\"admin\",\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/#\\\/schema\\\/person\\\/04ed27b919baca468a2273f8e4318f81\"},\"headline\":\"\u0646\u062d\u0648\u0647 \u0627\u0633\u062a\u0641\u0627\u062f\u0647 \u0627\u0632 Joins \u062f\u0631 SQL\",\"datePublished\":\"2024-07-22T17:56:37+00:00\",\"dateModified\":\"2024-08-14T17:02:31+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/\"},\"wordCount\":213,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/cdn.itpiran.net\\\/2024\\\/07\\\/14203156\\\/joins-sql.jpg\",\"keywords\":[\"data base\",\"MySQL\"],\"articleSection\":[\"\u0622\u0645\u0648\u0632\u0634\u06cc\",\"\u067e\u0627\u06cc\u06af\u0627\u0647 \u062f\u0627\u062f\u0647\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/\",\"url\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/\",\"name\":\"\u0646\u062d\u0648\u0647 \u0627\u0633\u062a\u0641\u0627\u062f\u0647 \u0627\u0632 Joins \u062f\u0631 SQL - \u0628\u0644\u0627\u06af ITPiran\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/cdn.itpiran.net\\\/2024\\\/07\\\/14203156\\\/joins-sql.jpg\",\"datePublished\":\"2024-07-22T17:56:37+00:00\",\"dateModified\":\"2024-08-14T17:02:31+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/#primaryimage\",\"url\":\"https:\\\/\\\/cdn.itpiran.net\\\/2024\\\/07\\\/14203156\\\/joins-sql.jpg\",\"contentUrl\":\"https:\\\/\\\/cdn.itpiran.net\\\/2024\\\/07\\\/14203156\\\/joins-sql.jpg\",\"width\":1793,\"height\":1110},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/tutorials\\\/how-to-use-joins-in-sql\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"\u0622\u0645\u0648\u0632\u0634\u06cc\",\"item\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/category\\\/tutorials\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"\u0646\u062d\u0648\u0647 \u0627\u0633\u062a\u0641\u0627\u062f\u0647 \u0627\u0632 Joins \u062f\u0631 SQL\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/\",\"name\":\"\u0628\u0644\u0627\u06af ITPiran\",\"description\":\"\u0627\u062e\u0628\u0627\u0631 \u0648 \u0645\u0642\u0627\u0644\u0627\u062a \u062a\u062c\u0627\u0631\u062a \u067e\u0627\u06cc\u062f\u0627\u0631 \u0627\u06cc\u0631\u0627\u0646\u06cc\u0627\u0646\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/#organization\",\"name\":\"\u0628\u0644\u0627\u06af \u062a\u062c\u0627\u0631\u062a \u067e\u0627\u06cc\u062f\u0627\u0631 \u0627\u06cc\u0631\u0627\u0646\u06cc\u0627\u0646\",\"alternateName\":\"ITPIran Blog\",\"url\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/cdn.itpiran.net\\\/2023\\\/12\\\/27150508\\\/cropped-ITPIRAN-BLOG-LOGO-2.png\",\"contentUrl\":\"https:\\\/\\\/cdn.itpiran.net\\\/2023\\\/12\\\/27150508\\\/cropped-ITPIRAN-BLOG-LOGO-2.png\",\"width\":512,\"height\":512,\"caption\":\"\u0628\u0644\u0627\u06af \u062a\u062c\u0627\u0631\u062a \u067e\u0627\u06cc\u062f\u0627\u0631 \u0627\u06cc\u0631\u0627\u0646\u06cc\u0627\u0646\"},\"image\":{\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/#\\\/schema\\\/person\\\/04ed27b919baca468a2273f8e4318f81\",\"name\":\"admin\",\"url\":\"https:\\\/\\\/www.itpiran.net\\\/blog\\\/de\\\/author\\\/admin\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Wie man Joins in SQL verwendet \u2013 ITPiran-Blog","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.itpiran.net\/blog\/de\/tutorials\/how-to-use-joins-in-sql\/","og_locale":"de_DE","og_type":"article","og_title":"\u0646\u062d\u0648\u0647 \u0627\u0633\u062a\u0641\u0627\u062f\u0647 \u0627\u0632 Joins \u062f\u0631 SQL - \u0628\u0644\u0627\u06af ITPiran","og_description":"\u0645\u0642\u062f\u0645\u0647 \u0628\u0633\u06cc\u0627\u0631\u06cc \u0627\u0632 \u0637\u0631\u0627\u062d\u06cc \u0647\u0627\u06cc \u067e\u0627\u06cc\u06af\u0627\u0647 \u062f\u0627\u062f\u0647 \u0628\u0631 \u0627\u0633\u0627\u0633 \u0631\u0648\u0627\u0628\u0637 \u0628\u06cc\u0646 \u0646\u0642\u0627\u0637 \u062f\u0627\u062f\u0647 \u062e\u0627\u0635\u060c \u0627\u0637\u0644\u0627\u0639\u0627\u062a \u0631\u0627 \u0628\u0647 \u062c\u062f\u0627\u0648\u0644…","og_url":"https:\/\/www.itpiran.net\/blog\/de\/tutorials\/how-to-use-joins-in-sql\/","og_site_name":"\u0628\u0644\u0627\u06af ITPiran","article_published_time":"2024-07-22T17:56:37+00:00","article_modified_time":"2024-08-14T17:02:31+00:00","og_image":[{"width":1793,"height":1110,"url":"https:\/\/cdn.itpiran.net\/2024\/07\/14203156\/joins-sql.jpg","type":"image\/jpeg"}],"author":"admin","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"admin","Gesch\u00e4tzte Lesezeit":"4\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/#article","isPartOf":{"@id":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/"},"author":{"name":"admin","@id":"https:\/\/www.itpiran.net\/blog\/#\/schema\/person\/04ed27b919baca468a2273f8e4318f81"},"headline":"\u0646\u062d\u0648\u0647 \u0627\u0633\u062a\u0641\u0627\u062f\u0647 \u0627\u0632 Joins \u062f\u0631 SQL","datePublished":"2024-07-22T17:56:37+00:00","dateModified":"2024-08-14T17:02:31+00:00","mainEntityOfPage":{"@id":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/"},"wordCount":213,"commentCount":0,"publisher":{"@id":"https:\/\/www.itpiran.net\/blog\/#organization"},"image":{"@id":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/#primaryimage"},"thumbnailUrl":"https:\/\/cdn.itpiran.net\/2024\/07\/14203156\/joins-sql.jpg","keywords":["data base","MySQL"],"articleSection":["\u0622\u0645\u0648\u0632\u0634\u06cc","\u067e\u0627\u06cc\u06af\u0627\u0647 \u062f\u0627\u062f\u0647"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/","url":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/","name":"Wie man Joins in SQL verwendet \u2013 ITPiran-Blog","isPartOf":{"@id":"https:\/\/www.itpiran.net\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/#primaryimage"},"image":{"@id":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/#primaryimage"},"thumbnailUrl":"https:\/\/cdn.itpiran.net\/2024\/07\/14203156\/joins-sql.jpg","datePublished":"2024-07-22T17:56:37+00:00","dateModified":"2024-08-14T17:02:31+00:00","breadcrumb":{"@id":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/#primaryimage","url":"https:\/\/cdn.itpiran.net\/2024\/07\/14203156\/joins-sql.jpg","contentUrl":"https:\/\/cdn.itpiran.net\/2024\/07\/14203156\/joins-sql.jpg","width":1793,"height":1110},{"@type":"BreadcrumbList","@id":"https:\/\/www.itpiran.net\/blog\/tutorials\/how-to-use-joins-in-sql\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.itpiran.net\/blog\/"},{"@type":"ListItem","position":2,"name":"\u0622\u0645\u0648\u0632\u0634\u06cc","item":"https:\/\/www.itpiran.net\/blog\/category\/tutorials\/"},{"@type":"ListItem","position":3,"name":"\u0646\u062d\u0648\u0647 \u0627\u0633\u062a\u0641\u0627\u062f\u0647 \u0627\u0632 Joins \u062f\u0631 SQL"}]},{"@type":"WebSite","@id":"https:\/\/www.itpiran.net\/blog\/#website","url":"https:\/\/www.itpiran.net\/blog\/","name":"ITPiran Blog","description":"Iranische Nachrichten und Artikel zum Thema nachhaltiger Handel","publisher":{"@id":"https:\/\/www.itpiran.net\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.itpiran.net\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/www.itpiran.net\/blog\/#organization","name":"Nachhaltiger iranischer Unternehmensblog","alternateName":"ITPIran Blog","url":"https:\/\/www.itpiran.net\/blog\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/www.itpiran.net\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/cdn.itpiran.net\/2023\/12\/27150508\/cropped-ITPIRAN-BLOG-LOGO-2.png","contentUrl":"https:\/\/cdn.itpiran.net\/2023\/12\/27150508\/cropped-ITPIRAN-BLOG-LOGO-2.png","width":512,"height":512,"caption":"\u0628\u0644\u0627\u06af \u062a\u062c\u0627\u0631\u062a \u067e\u0627\u06cc\u062f\u0627\u0631 \u0627\u06cc\u0631\u0627\u0646\u06cc\u0627\u0646"},"image":{"@id":"https:\/\/www.itpiran.net\/blog\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/www.itpiran.net\/blog\/#\/schema\/person\/04ed27b919baca468a2273f8e4318f81","name":"Administrator","url":"https:\/\/www.itpiran.net\/blog\/de\/author\/admin\/"}]}},"_links":{"self":[{"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/posts\/15949","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/comments?post=15949"}],"version-history":[{"count":4,"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/posts\/15949\/revisions"}],"predecessor-version":[{"id":16028,"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/posts\/15949\/revisions\/16028"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/media\/16027"}],"wp:attachment":[{"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/media?parent=15949"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/categories?post=15949"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.itpiran.net\/blog\/de\/wp-json\/wp\/v2\/tags?post=15949"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}