Oracle Database
कार्यभार संभाला
खोज…
क्रोस जॉइन
एक CROSS JOIN दो तालिकाओं के बीच एक CROSS JOIN करता है जो दो तालिकाओं के कार्टेशियन उत्पाद में एक स्पष्ट सम्मिलित खंड और परिणाम का उपयोग नहीं करता है। एक कार्टेशियन उत्पाद का अर्थ है कि एक तालिका की प्रत्येक पंक्ति दूसरी तालिका की प्रत्येक पंक्ति के साथ जुड़ती है। उदाहरण के लिए, यदि TABLEA में 20 पंक्तियाँ हैं और TABLEB में 20 पंक्तियाँ हैं, तो परिणाम 20*20 = 400 आउटपुट पंक्तियाँ होंगी।
उदाहरण:
SELECT *
FROM TABLEA CROSS JOIN TABLEB;
यह भी लिखा जा सकता है:
SELECT *
FROM TABLEA, TABLEB;
यहाँ दो तालिकाओं के बीच SQL में क्रॉस जॉइन का उदाहरण दिया गया है:
नमूना तालिका: TABLEA
+-------+---------+
| VALUE | NAME |
+-------+---------+
| 1 | ONE |
| 2 | TWO |
+-------+---------+
नमूना तालिका: TABLEB
+-------+--------+
| VALUE | NAME |
+-------+--------+
| 3 | THREE |
| 4 | FOUR |
+-------+--------+
अब, यदि आप क्वेरी निष्पादित करते हैं:
SELECT *
FROM TABLEA CROSS JOIN TABLEB;
आउटपुट:
+-------+--------+-------+--------+
| VALUE | NAME | VALUE | NAME |
+-------+--------+-------+--------+
| 1 | ONE | 3 | THREE |
| 1 | ONE | 4 | FOUR |
| 2 | TWO | 3 | THREE |
| 2 | TWO | 4 | FOUR |
+-------+--------+-------+--------+
इस तरह से दो मेजों के बीच क्रॉस जॉइनिंग होती है: 
क्रॉस जॉइन के बारे में अधिक जानकारी: ओरेकल प्रलेखन
आंतरिक रूप से जुड़ा
INNER JOIN एक JOIN ऑपरेशन है जो आपको एक स्पष्ट जॉइन क्लॉज निर्दिष्ट करने की अनुमति देता है।
वाक्य - विन्यास
TableExpression [INNER] JOIN TableExpression {ON booleanExpression | क्लाज का उपयोग करना}
आप बूलियन एक्सप्रेशन के साथ ON को निर्दिष्ट करके जॉइन क्लॉज को निर्दिष्ट कर सकते हैं।
ON क्लॉज में एक्सप्रेशन के दायरे में करंट टेबल और बाहरी क्वेरी के किसी भी टेबल्स से करंट सिलेक्ट शामिल है। निम्नलिखित उदाहरण में, ON क्लॉज वर्तमान तालिकाओं को संदर्भित करता है:
-- 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
बाईं ओर का बाहरी जोड़
एक LEFT OUTER JOIN दो तालिकाओं के बीच एक LEFT OUTER JOIN करता है, जिसमें एक स्पष्ट जुड़ने वाले खंड की आवश्यकता होती है, लेकिन पहली तालिका से बेजोड़ पंक्तियों को बाहर नहीं करता है।
उदाहरण:
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP LEFT OUTER JOIN SCOTT.DEPT
ON EMP.DEPTNO = DEPT.DEPTNO;
हालांकि एएनएसआई सिंटैक्स अनुशंसित तरीका है, यह अक्सर विरासत सिंटैक्स का सामना करने की संभावना है। किसी स्थिति के भीतर (+) का उपयोग यह निर्धारित करता है कि समीकरण के किस पक्ष को बाहरी माना जाए।
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP,
SCOTT.DEPT
WHERE
EMP.DEPTNO = DEPT.DEPTNO(+);
यहाँ लेफ्ट आउटर का एक उदाहरण दो तालिकाओं के बीच में मिलाएँ:
नमूना तालिका: EMPLOYEE
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
नमूना तालिका: DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
अब, यदि आप क्वेरी निष्पादित करते हैं:
SELECT
*
FROM
EMPLOYEE LEFT OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
आउटपुट:
+-----------+---------+---------+--------------+
| 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 करता है जिसके लिए एक स्पष्ट जुड़ाव खंड की आवश्यकता होती है लेकिन दूसरी तालिका से बेजोड़ पंक्तियों को बाहर नहीं करता है।
उदाहरण:
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.EMP RIGHT OUTER JOIN SCOTT.DEPT
ON EMP.DEPTNO = DEPT.DEPTNO;
चूंकि SCOTT.DEPT की बेजोड़ पंक्तियाँ शामिल हैं, लेकिन SCOTT.EMP की बेजोड़ पंक्तियाँ नहीं हैं, ऊपर दिए गए LEFT OUTER JOIN का उपयोग करके निम्नलिखित कथन के बराबर है।
SELECT
ENAME,
DNAME,
EMP.DEPTNO,
DEPT.DEPTNO
FROM
SCOTT.DEPT RIGHT OUTER JOIN SCOTT.EMP
ON DEPT.DEPTNO = EMP.DEPTNO;
यहां राइट आउटर का उदाहरण दो तालिकाओं के बीच में मिलाया गया है:
नमूना तालिका: EMPLOYEE
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
नमूना तालिका: DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
अब, यदि आप क्वेरी निष्पादित करते हैं:
SELECT
*
FROM
EMPLOYEE RIGHT OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
आउटपुट:
+-----------+---------+---------+--------------+
| 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 (+) सिंटेक्स समतुल्य है:
SELECT *
FROM EMPLOYEE, DEPT
WHERE EMPLOYEE.DEPTNO(+) = DEPT.DEPTNO;
पूरा कंप्यूटर शामिल है
एक FULL OUTER JOIN दो तालिकाओं के बीच एक FULL OUTER JOIN करता है, जिसमें एक स्पष्ट सम्मिलित खंड की आवश्यकता होती है, लेकिन दोनों तालिका में बेजोड़ पंक्तियों को शामिल नहीं करता है। दूसरे शब्दों में, यह प्रत्येक तालिका में सभी पंक्तियों को लौटाता है।
उदाहरण:
SELECT
*
FROM
EMPLOYEE FULL OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
यहाँ दो तालिकाओं के बीच पूर्ण बाहरी जुड़ने का एक उदाहरण दिया गया है:
नमूना तालिका: EMPLOYEE
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
नमूना तालिका: DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
अब, यदि आप क्वेरी निष्पादित करते हैं:
SELECT
*
FROM
EMPLOYEE FULL OUTER JOIN DEPT
ON EMPLOYEE.DEPTNO = DEPT.DEPTNO;
उत्पादन
+-----------+---------+---------+--------------+
| 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 |
+-----------+---------+---------+--------------+
यहां जो कॉलम मेल नहीं खाते हैं उन्हें NULL रखा गया है।
ANTIJOIN
एक एंटीजेन विधेय के बाईं ओर से पंक्तियों को लौटाता है जिसके लिए विधेय के दाईं ओर एक समान पंक्तियाँ नहीं होती हैं। यह उन पंक्तियों को लौटाता है जो दाईं ओर स्थित सब-वेरी से मेल नहीं खातीं।
SELECT * FROM employees
WHERE department_id NOT IN
(SELECT department_id FROM departments
WHERE location_id = 1700)
ORDER BY last_name;
यहाँ दो तालिकाओं के बीच एंटी जुड़ने का एक उदाहरण दिया गया है:
नमूना तालिका: EMPLOYEE
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| A | 2 |
| B | 1 |
| C | 3 |
| D | 2 |
| E | 1 |
| F | 1 |
| G | 4 |
| H | 4 |
+-----------+---------+
नमूना तालिका: DEPT
+---------+--------------+
| DEPTNO | DEPTNAME |
+---------+--------------+
| 1 | ACCOUNTING |
| 2 | FINANCE |
| 5 | MARKETING |
| 6 | HR |
+---------+--------------+
अब, यदि आप क्वेरी निष्पादित करते हैं:
SELECT
*
FROM
EMPLOYEE WHERE DEPTNO NOT IN
(SELECT DEPTNO FROM DEPT);
आउटपुट:
+-----------+---------+
| NAME | DEPTNO |
+-----------+---------+
| C | 3 |
| H | 4 |
| G | 4 |
+-----------+---------+
आउटपुट से पता चलता है कि केवल EMPLOYEE तालिका की पंक्तियाँ, जिनमें से DEPTNO DEPT तालिका में मौजूद नहीं थीं।
SEMIJOIN
एक अर्धविराम क्वेरी का उपयोग किया जा सकता है, उदाहरण के लिए, कम से कम एक कर्मचारी जिसका वेतन 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;
यह पूर्ण सम्मिलित विकल्पों की तुलना में अधिक कुशल है, क्योंकि कर्मचारियों पर आंतरिक जुड़ाव तब एक विस्तृत खंड देता है जिसमें वेतन 2500 से अधिक होना चाहिए जो एक ही विभाग को कई बार वापस कर सकता है। कहते हैं अगर आग विभाग है n सभी वेतन 3000 के साथ कर्मचारियों, select * from departments, employees आवश्यक साथ आईडी पर शामिल होने और हमारी जहां खंड आग विभाग वापसी होगी n बार।
शामिल हों
JOIN ऑपरेशन पहली तालिका से किसी भी बेजोड़ पंक्तियों को छोड़कर, दो तालिकाओं के बीच एक JOIN करता है। Oracle 9i आगे से, JOIN INNER JOIN फंक्शन के बराबर है। CROSS JOIN और NATURAL JOIN ऑपरेटरों के विपरीत, इस ऑपरेशन के लिए एक स्पष्ट ज्वाइन क्लॉज की आवश्यकता होती है।
उदाहरण:
select t1.*,
t2.DeptId
from table_1 t1
join table_2 t2 on t2.DeptNo = t1.DeptNo
ओरेकल दस्तावेज:
प्राकृतिक जोइन
प्राकृतिक जॉइन के लिए किसी अन्वेषणात्मक स्थिति की आवश्यकता नहीं है; यह शामिल तालिकाओं में एक ही नाम के साथ सभी क्षेत्रों के आधार पर एक बनाता है।
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');
यह कार्यक्षेत्र ID और DESCR, दोनों तालिकाओं के लिए सामान्य पर किया जाएगा:
SQL> select *
2 from tab1
3 natural join
4 tab2;
ID DESCR
---------- ----------
3 three
विभिन्न नामों वाले स्तंभों का उपयोग JOIN स्थिति में नहीं किया जाएगा:
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
यदि शामिल तालिकाओं में कोई सामान्य कॉलम नहीं है, तो एक JOIN जिसमें कोई भी शर्त नहीं होगी:
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
