Oracle Database
VERBINDUNGEN
Suche…
CROSS JOIN
Ein CROSS JOIN führt einen Join zwischen zwei Tabellen aus, der keine explizite Join-Klausel verwendet, und führt zum kartesischen Produkt von zwei Tabellen. Ein kartesisches Produkt bedeutet, dass jede Zeile einer Tabelle mit jeder Zeile der zweiten Tabelle im Join kombiniert wird. Wenn TABLEA beispielsweise 20 Zeilen und TABLEB 20 Zeilen hat, wäre das Ergebnis 20*20 = 400 Ausgabezeilen.
Beispiel:
SELECT *
FROM TABLEA CROSS JOIN TABLEB;
Dies kann auch geschrieben werden als:
SELECT *
FROM TABLEA, TABLEB;
Hier ist ein Beispiel für Cross Join in SQL zwischen zwei Tabellen:
Probentabelle : TABLEA
+-------+---------+
| VALUE | NAME |
+-------+---------+
| 1 | ONE |
| 2 | TWO |
+-------+---------+
Beispieltabelle: TABLEB
+-------+--------+
| VALUE | NAME |
+-------+--------+
| 3 | THREE |
| 4 | FOUR |
+-------+--------+
Wenn Sie nun die Abfrage ausführen:
SELECT *
FROM TABLEA CROSS JOIN TABLEB;
Ausgabe:
+-------+--------+-------+--------+
| VALUE | NAME | VALUE | NAME |
+-------+--------+-------+--------+
| 1 | ONE | 3 | THREE |
| 1 | ONE | 4 | FOUR |
| 2 | TWO | 3 | THREE |
| 2 | TWO | 4 | FOUR |
+-------+--------+-------+--------+
So erfolgt das Cross-Joining zwischen zwei Tabellen: 
Weitere Informationen zu Cross Join: Oracle-Dokumentation
INNER JOIN
Ein INNER JOIN ist eine JOIN-Operation, mit der Sie eine explizite Join-Klausel angeben können.
Syntax
TableExpression [INNER] JOIN TableExpression {ON booleanExpression | USING-Klausel}
Sie können die Join-Klausel angeben, indem Sie ON mit einem booleschen Ausdruck angeben.
Der Geltungsbereich von Ausdrücken in der ON-Klausel umfasst die aktuellen Tabellen und alle Tabellen in äußeren Abfrageblöcken für das aktuelle SELECT. Im folgenden Beispiel verweist die ON-Klausel auf die aktuellen Tabellen:
-- Join the EMP_ACT and EMPLOYEE tables
-- select all the columns from the EMP_ACT table and
-- add the employee's surname (LASTNAME) from the EMPLOYEE table
-- to each row of the result
SELECT SAMP.EMP_ACT.*, LASTNAME
FROM SAMP.EMP_ACT JOIN SAMP.EMPLOYEE
ON EMP_ACT.EMPNO = EMPLOYEE.EMPNO
-- Join the EMPLOYEE and DEPARTMENT tables,
-- select the employee number (EMPNO),
-- employee surname (LASTNAME),
-- department number (WORKDEPT in the EMPLOYEE table and DEPTNO in the
-- DEPARTMENT table)
-- and department name (DEPTNAME)
-- of all employees who were born (BIRTHDATE) earlier than 1930.
SELECT EMPNO, LASTNAME, WORKDEPT, DEPTNAME
FROM SAMP.EMPLOYEE JOIN SAMP.DEPARTMENT
ON WORKDEPT = DEPTNO
AND YEAR(BIRTHDATE) < 1930
-- Another example of "generating" new data values,
-- using a query which selects from a VALUES clause (which is an
-- alternate form of a fullselect).
-- This query shows how a table can be derived called "X"
-- having 2 columns "R1" and "R2" and 1 row of data
SELECT *
FROM (VALUES (3, 4), (1, 5), (2, 6))
AS VALUESTABLE1(C1, C2)
JOIN (VALUES (3, 2), (1, 2),
(0, 3)) AS VALUESTABLE2(c1, c2)
ON VALUESTABLE1.c1 = VALUESTABLE2.c1
-- This results in:
-- C1 |C2 |C1 |2
-- -----------------------------------------------
-- 3 |4 |3 |2
-- 1 |5 |1 |2
-- List every department with the employee number and
-- last name of the manager
SELECT DEPTNO, DEPTNAME, EMPNO, LASTNAME
FROM DEPARTMENT INNER JOIN EMPLOYEE
ON MGRNO = EMPNO
-- List every employee number and last name
-- with the employee number and last name of their manager
SELECT E.EMPNO, E.LASTNAME, M.EMPNO, M.LASTNAME
FROM EMPLOYEE E INNER JOIN
DEPARTMENT INNER JOIN EMPLOYEE M
ON MGRNO = M.EMPNO
ON E.WORKDEPT = DEPTNO
LINKE ÄUSSERE VERBINDUNG
Ein LEFT OUTER JOIN führt eine Verknüpfung zwischen zwei Tabellen aus, die eine explizite Verknüpfungsklausel erfordert, aber nicht übereinstimmende Zeilen nicht aus der ersten Tabelle ausschließt.
Beispiel:
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP LEFT OUTER JOIN SCOTT.DEPT
ON EMP.DEPTNO = DEPT.DEPTNO;
Obwohl die empfohlene Methode die ANSI-Syntax ist, ist es wahrscheinlich, dass sie häufig auf eine ältere Syntax stößt. Die Verwendung von (+) innerhalb einer Bedingung bestimmt, welche Seite der Gleichung als äußere betrachtet wird .
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP,
SCOTT.DEPT
WHERE
EMP.DEPTNO = DEPT.DEPTNO(+);
Hier ist ein Beispiel für Left Outer Join zwischen zwei Tabellen:
Beispieltabelle: MITARBEITER
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Beispieltabelle: DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Wenn Sie nun die Abfrage ausführen:
SELECT
*
FROM
EMPLOYEE LEFT OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Ausgabe:
+-----------+---------+---------+--------------+
| NAME | DEPTNO | DEPTNO | DEPTNAME |
+-----------+---------+---------+--------------+
| F | 1 | 1 | ACCOUNTING |
| E | 1 | 1 | ACCOUNTING |
| B | 1 | 1 | ACCOUNTING |
| D | 2 | 2 | FINANCE |
| A | 2 | 2 | FINANCE |
| C | 3 | | |
| H | 4 | | |
| G | 4 | | |
+-----------+---------+---------+--------------+
RECHTE AUSSEN VERBINDEN
Ein RIGHT OUTER JOIN führt eine Verknüpfung zwischen zwei Tabellen aus, für die eine explizite Verknüpfungsklausel erforderlich ist, jedoch nicht übereinstimmende Zeilen nicht aus der zweiten Tabelle ausgeschlossen werden.
Beispiel:
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP RIGHT OUTER JOIN SCOTT.DEPT
ON EMP.DEPTNO = DEPT.DEPTNO;
Da die nicht SCOTT.DEPT Zeilen von SCOTT.DEPT enthalten sind, aber nicht SCOTT.EMP Zeilen von SCOTT.EMP nicht, entspricht das obige der folgenden Anweisung, die LEFT OUTER JOIN .
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.DEPT RIGHT OUTER JOIN SCOTT.EMP
ON DEPT.DEPTNO = EMP.DEPTNO;
Hier ist ein Beispiel für den Right Outer Join zwischen zwei Tabellen:
Beispieltabelle: MITARBEITER
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Beispieltabelle: DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Wenn Sie nun die Abfrage ausführen:
SELECT
*
FROM
EMPLOYEE RIGHT OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Ausgabe:
+-----------+---------+---------+--------------+
| NAME | DEPTNO | DEPTNO | DEPTNAME |
+-----------+---------+---------+--------------+
| A | 2 | 2 | FINANCE |
| B | 1 | 1 | ACCOUNTING |
| D | 2 | 2 | FINANCE |
| E | 1 | 1 | ACCOUNTING |
| F | 1 | 1 | ACCOUNTING |
| | | 5 | MARKETING |
| | | 6 | HR |
+-----------+---------+---------+--------------+
Die Oracle-Syntax (+) entspricht der Abfrage:
SELECT *
FROM EMPLOYEE, DEPT
WHERE EMPLOYEE.DEPTNO(+) = DEPT.DEPTNO;
VOLL AUSSEN MITGLIED
Ein FULL OUTER JOIN führt eine Verknüpfung zwischen zwei Tabellen aus, die eine explizite Verknüpfungsklausel erfordert, aber nicht übereinstimmende Zeilen in beiden Tabellen nicht ausschließt. Mit anderen Worten, es werden alle Zeilen in jeder Tabelle zurückgegeben.
Beispiel:
SELECT
*
FROM
EMPLOYEE FULL OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Hier ist ein Beispiel für einen vollständigen äußeren Join zwischen zwei Tabellen:
Beispieltabelle: MITARBEITER
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Beispieltabelle: DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Wenn Sie nun die Abfrage ausführen:
SELECT
*
FROM
EMPLOYEE FULL OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Ausgabe
+-----------+---------+---------+--------------+
| NAME | DEPTNO | DEPTNO | DEPTNAME |
+-----------+---------+---------+--------------+
| A | 2 | 2 | FINANCE |
| B | 1 | 1 | ACCOUNTING |
| C | 3 | | |
| D | 2 | 2 | FINANCE |
| E | 1 | 1 | ACCOUNTING |
| F | 1 | 1 | ACCOUNTING |
| G | 4 | | |
| H | 4 | | |
| | | 6 | HR |
| | | 5 | MARKETING |
+-----------+---------+---------+--------------+
Hier wurden die Spalten, die nicht übereinstimmen, auf NULL gehalten.
ANTIJOIN
Ein Antijoin gibt Zeilen von der linken Seite des Prädikats zurück, für die es keine entsprechenden Zeilen auf der rechten Seite des Prädikats gibt. Es gibt Zeilen zurück, die nicht mit der Unterabfrage auf der rechten Seite übereinstimmen (NOT IN).
SELECT * FROM employees
WHERE department_id NOT IN
(SELECT department_id FROM departments
WHERE location_id = 1700)
ORDER BY last_name;
Hier ist ein Beispiel für Anti-Join zwischen zwei Tabellen:
Beispieltabelle: MITARBEITER
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Beispieltabelle: DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Wenn Sie nun die Abfrage ausführen:
SELECT
*
FROM
EMPLOYEE WHERE DEPTNO NOT IN
(SELECT DEPTNO FROM DEPT);
Ausgabe:
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| C | 3 |
| H | 4 |
| G | 4 |
+-----------+---------+
Die Ausgabe zeigt, dass nur die Zeilen der EMPLOYEE-Tabelle, deren DEPTNO nicht in der DEPT-Tabelle vorhanden war.
SEMIJOIN
Eine Semijoin-Abfrage kann beispielsweise dazu verwendet werden, alle Abteilungen mit mindestens einem Mitarbeiter zu finden, dessen Gehalt 2500 übersteigt.
SELECT * FROM departments
WHERE EXISTS
(SELECT 1 FROM employees
WHERE departments.department_id = employees.department_id
AND employees.salary > 2500)
ORDER BY department_name;
Dies ist effizienter als die vollständige Join-Alternative, da inneres Beitreten von Mitarbeitern dann eine Klausel enthält, in der angegeben wird, dass das Gehalt mehr als 2500 betragen muss und dieselbe Abteilung mehrmals wiederkommen könnte. Wenn die Feuerwehr über n Mitarbeiter verfügt, die alle das Gehalt 3000 haben, select * from departments, employees mit den erforderlichen IDs aus und unsere where-Klausel würde die Feuerwehr n mal zurückgeben.
BEITRETEN
Die JOIN Operation führt eine Verknüpfung zwischen zwei Tabellen aus, wobei alle nicht übereinstimmenden Zeilen aus der ersten Tabelle ausgeschlossen werden. Ab Oracle 9i entspricht der JOIN in seiner Funktion dem INNER JOIN . Dieser Vorgang erfordert eine explizite Join-Klausel, im Gegensatz zu den Operatoren CROSS JOIN und NATURAL JOIN .
Beispiel:
select t1.*,
t2.DeptId
from table_1 t1
join table_2 t2 on t2.DeptNo = t1.DeptNo
Oracle-Dokumentation:
NATÜRLICHER JOIN
NATURAL JOIN erfordert keine explizite Join-Bedingung. Es wird ein Feld erstellt, das auf allen Feldern mit demselben Namen in den verbundenen Tabellen basiert.
create table tab1(id number, descr varchar2(100));
create table tab2(id number, descr varchar2(100));
insert into tab1 values(1, 'one');
insert into tab1 values(2, 'two');
insert into tab1 values(3, 'three');
insert into tab2 values(1, 'ONE');
insert into tab2 values(3, 'three');
Der Join wird für die Felder ID und DESCR durchgeführt, die für beide Tabellen gelten:
SQL> select *
2 from tab1
3 natural join
4 tab2;
ID DESCR
---------- ----------
3 three
Spalten mit unterschiedlichen Namen werden in der JOIN-Bedingung nicht verwendet:
SQL> select *
2 from (select id as id, descr as descr1 from tab1)
3 natural join
4 (select id as id, descr as descr2 from tab2);
ID DESCR1 DESCR2
---------- ---------- ----------
1 one ONE
3 three three
Wenn die verknüpften Tabellen keine gemeinsamen Spalten haben, wird ein JOIN ohne Bedingungen ausgeführt:
SQL> select *
2 from (select id as id1, descr as descr1 from tab1)
3 natural join
4 (select id as id2, descr as descr2 from tab2);
ID1 DESCR1 ID2 DESCR2
---------- ---------- ---------- ----------
1 one 1 ONE
2 two 1 ONE
3 three 1 ONE
1 one 3 three
2 two 3 three
3 three 3 three
