Oracle Database
ANSLUTER SIG
Sök…
KRÄSS GÅ MED
A CROSS JOIN utför en CROSS JOIN mellan två tabeller som inte använder en uttrycklig sammankopplingsklausul och resulterar i den kartesiska produkten av två tabeller. En kartesisk produkt betyder att varje rad i ett bord kombineras med varje rad i det andra bordet i skarven. Till exempel, om TABLEA har 20 rader och TABLEB har 20 rader, skulle resultatet vara 20*20 = 400 utgångsrader.
Exempel:
SELECT *
FROM TABLEA CROSS JOIN TABLEB;
Detta kan också skrivas som:
SELECT *
FROM TABLEA, TABLEB;
Här är ett exempel på tvärbindning i SQL mellan två tabeller:
Provtabell : TABELL
+-------+---------+
| VALUE | NAME |
+-------+---------+
| 1 | ONE |
| 2 | TWO |
+-------+---------+
Exempel på tabell: TABELL
+-------+--------+
| VALUE | NAME |
+-------+--------+
| 3 | THREE |
| 4 | FOUR |
+-------+--------+
Nu, om du kör frågan:
SELECT *
FROM TABLEA CROSS JOIN TABLEB;
Produktion:
+-------+--------+-------+--------+
| VALUE | NAME | VALUE | NAME |
+-------+--------+-------+--------+
| 1 | ONE | 3 | THREE |
| 1 | ONE | 4 | FOUR |
| 2 | TWO | 3 | THREE |
| 2 | TWO | 4 | FOUR |
+-------+--------+-------+--------+
Så här sker korsfogning mellan två tabeller: 
Mer om Cross Join: Oracle-dokumentation
INRE KOPPLING
En INNER JOIN är en JOIN-operation som låter dig ange en uttrycklig sammankopplingsklausul.
Syntax
TableExpression [INNER] JOIN TableExpression {ON booleanExpression | ANVÄNDER klausul}
Du kan ange kopplingsklausulen genom att ange PÅ med ett booleskt uttryck.
Räckvidden för uttryck i ON-klausulen inkluderar de aktuella tabellerna och alla tabeller i yttre frågeformer till det aktuella VÄLJ. I följande exempel hänvisar ON-klausulen till de aktuella tabellerna:
-- 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
Vänster yttre medlem
En LEFT OUTER JOIN utför en sammanfogning mellan två tabeller som kräver en uttrycklig sammankopplingsklausul men inte utesluter oöverträffade rader från det första bordet.
Exempel:
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP LEFT OUTER JOIN SCOTT.DEPT
ON EMP.DEPTNO = DEPT.DEPTNO;
Även om ANSI-syntax är det rekommenderade sättet kommer det troligtvis att möta äldre syntax mycket ofta. Att använda (+) inom ett villkor bestämmer vilken sida av ekvationen som ska betraktas som yttre .
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP,
SCOTT.DEPT
WHERE
EMP.DEPTNO = DEPT.DEPTNO(+);
Här är ett exempel på vänster yttre koppling mellan två tabeller:
Exempel på tabell: MEDARBETARE
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Provtabell : DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Nu, om du kör frågan:
SELECT
*
FROM
EMPLOYEE LEFT OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Produktion:
+-----------+---------+---------+--------------+
| 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 | | |
+-----------+---------+---------+--------------+
RIGHT OUTER JOIN
RIGHT OUTER JOIN utför en sammanfogning mellan två tabeller som kräver en uttrycklig sammankopplingsklausul men inte utesluter oöverträffade rader från det andra bordet.
Exempel:
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP RIGHT OUTER JOIN SCOTT.DEPT
ON EMP.DEPTNO = DEPT.DEPTNO;
Eftersom de oöverträffade raderna av SCOTT.DEPT ingår, men oöverträffade rader med SCOTT.EMP inte är, motsvarar ovanstående följande uttalande med LEFT OUTER JOIN .
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.DEPT RIGHT OUTER JOIN SCOTT.EMP
ON DEPT.DEPTNO = EMP.DEPTNO;
Här är ett exempel på Right Outer Join mellan två tabeller:
Exempel på tabell: MEDARBETARE
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Provtabell : DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Nu, om du kör frågan:
SELECT
*
FROM
EMPLOYEE RIGHT OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Produktion:
+-----------+---------+---------+--------------+
| 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 |
+-----------+---------+---------+--------------+
Oracle (+) syntaxekvivalent för frågan är:
SELECT *
FROM EMPLOYEE, DEPT
WHERE EMPLOYEE.DEPTNO(+) = DEPT.DEPTNO;
FULL YTTERLEDNING
FULL OUTER JOIN utför en sammanfogning mellan två tabeller som kräver en uttrycklig sammankopplingsklausul men utesluter inte oöverträffade rader i någon av tabellerna. Med andra ord returnerar det alla raderna i varje tabell.
Exempel:
SELECT
*
FROM
EMPLOYEE FULL OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Här är ett exempel på Full Outer Join mellan två tabeller:
Exempel på tabell: MEDARBETARE
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Provtabell : DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Nu, om du kör frågan:
SELECT
*
FROM
EMPLOYEE FULL OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
Produktion
+-----------+---------+---------+--------------+
| 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 |
+-----------+---------+---------+--------------+
Här har kolumnerna som inte matchar hållits NULL.
ANTIJOIN
En antijoin returnerar rader från predikatets vänstra sida för vilka det inte finns motsvarande rader på predikatets högra sida. Det returnerar rader som inte matchar (INTE IN) underfrågan på höger sida.
SELECT * FROM employees
WHERE department_id NOT IN
(SELECT department_id FROM departments
WHERE location_id = 1700)
ORDER BY last_name;
Här är ett exempel på Anti Join mellan två tabeller:
Exempel på tabell: MEDARBETARE
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
Provtabell : DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
Nu, om du kör frågan:
SELECT
*
FROM
EMPLOYEE WHERE DEPTNO NOT IN
(SELECT DEPTNO FROM DEPT);
Produktion:
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| C | 3 |
| H | 4 |
| G | 4 |
+-----------+---------+
Utgången visar att endast raderna på ANställda-tabellen, varav DEPTNO inte fanns i DEPT-tabellen.
SEMIJOIN
En semijoinfråga kan till exempel användas för att hitta alla avdelningar med minst en anställd vars lön överstiger 2500.
SELECT * FROM departments
WHERE EXISTS
(SELECT 1 FROM employees
WHERE departments.department_id = employees.department_id
AND employees.salary > 2500)
ORDER BY department_name;
Detta är mer effektivt än de fullständiga anslutningsalternativen, eftersom inre sammankoppling av anställda sedan ger en där klausul om att lönen måste vara större än 2500 skulle kunna returnera samma avdelning flera gånger. Säg om brandavdelningen har n anställda alla med lön 3000, select * from departments, employees med nödvändiga gå med på id och vår där klausul skulle returnera brandkåren n gånger.
ANSLUTA SIG
JOIN operationen utför en sammanfogning mellan två tabeller, exklusive alla oöverträffade rader från det första bordet. Från Oracle 9i framåt är JOIN ekvivalent i funktion till INNER JOIN . Denna operation kräver en uttrycklig sammankopplingsklausul, i motsats till CROSS JOIN och NATURAL JOIN .
Exempel:
select t1.*,
t2.DeptId
from table_1 t1
join table_2 t2 on t2.DeptNo = t1.DeptNo
Oracle-dokumentation:
NATURLIGT GÅ MED
NATURLIGT GÅRD kräver inget explitiskt sammanfogningsvillkor; det bygger ett baserat på alla fält med samma namn i de sammanfogade tabellerna.
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');
Samlingen kommer att göras på fälten ID och DESCR, gemensamma för båda tabellerna:
SQL> select *
2 from tab1
3 natural join
4 tab2;
ID DESCR
---------- ----------
3 three
Kolumner med olika namn kommer inte att användas i JOIN-tillståndet:
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
Om de sammanfogade tabellerna inte har några gemensamma kolumner görs en JOIN utan villkor:
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
