sql हिंदी - एसक्यूएल जॉइन और जॉइन के विभिन्न प्रकार




मैनेजमेंट डीबीएमएस (7)

एसक्यूएल JOIN क्या है और विभिन्न प्रकार क्या हैं?


Answers

W3schools से एक उदाहरण:


मैं अपने पालतू शिखर को धक्का देने जा रहा हूं: उपयोग करने वाला कीवर्ड।

यदि जॉइन के दोनों किनारों पर दोनों टेबलों की अपनी विदेशी कुंजी ठीक से नामित होती है (यानी, वही नाम, न केवल "आईडी) तो इसका उपयोग किया जा सकता है:

SELECT ...
FROM customers JOIN orders USING (customer_id)

मुझे यह बहुत व्यावहारिक, पठनीय लगता है, और अक्सर पर्याप्त नहीं होता है।


मैंने एक उदाहरण बनाया है जो शब्दों की तुलना में बेहतर बताता है, मेरी राय में:


SQL JOIN क्या है?

SQL JOIN दो या दो से अधिक डेटाबेस टेबल से डेटा पुनर्प्राप्त करने का एक तरीका है।

विभिन्न SQL JOIN एस क्या हैं?

कुल पांच JOIN । वो हैं :

  1. JOIN or INNER JOIN
  2. OUTER JOIN

     2.1 LEFT OUTER JOIN or LEFT JOIN
     2.2 RIGHT OUTER JOIN or RIGHT JOIN
     2.3 FULL OUTER JOIN or FULL JOIN

  3. NATURAL JOIN
  4. CROSS JOIN
  5. SELF JOIN

1. जॉइन या इनर जॉइन:

इस तरह की JOIN , हमें सभी रिकॉर्ड मिलते हैं जो दोनों टेबलों में स्थिति से मेल खाते हैं, और दोनों टेबलों में रिकॉर्ड जो मेल नहीं खाते हैं, की रिपोर्ट नहीं की जाती है।

दूसरे शब्दों में, INNER JOIN एक तथ्य पर आधारित है कि: केवल दोनों तालिकाओं में मिलान प्रविष्टियां सूचीबद्ध की जानी चाहिए।

ध्यान दें कि किसी अन्य JOIN कीवर्ड के बिना JOIN (जैसे INNER , OUTER , LEFT , आदि) एक INNER JOIN । दूसरे शब्दों में, JOIN INNER JOIN लिए एक सिंटेक्टिक चीनी है (देखें: जॉइन और इनर जॉइन के बीच अंतर )।

2. बाहरी जॉइन:

OUTER JOIN पुनर्प्राप्त करता है

या तो, एक टेबल से मेल की गई पंक्तियां और दूसरी पंक्ति में सभी पंक्तियां या, सभी तालिकाओं में सभी पंक्तियां (इससे कोई फ़र्क नहीं पड़ता कि कोई मिलान है या नहीं)।

तीन प्रकार के बाहरी शामिल हों:

2.1 बाएं बाहरी जॉइन या बाएं जॉइन

यह दाएं तालिका से मिलान पंक्तियों के संयोजन के साथ बाएं तालिका से सभी पंक्तियों को लौटता है। यदि दाएं तालिका में कोई कॉलम मेल नहीं खाता है, तो यह कुल मान देता NULL

2.2 अधिकार आउट जॉइन या दाएं जॉइन

यह JOIN बाएं टेबल से मेल खाने वाली पंक्तियों के संयोजन के साथ दाएं टेबल से सभी पंक्तियां लौटाती है। यदि बाएं टेबल में कोई कॉलम मेल नहीं खाता है, तो यह कुल मान देता NULL

2.3 पूर्ण बाहरी जॉइन या पूर्ण जॉइन

यह JOIN LEFT OUTER JOIN और RIGHT OUTER JOIN को जोड़ती है। जब शर्तों को पूरा किया जाता है तो यह किसी भी तालिका से पंक्ति लौटाता है और कोई मिलान नहीं होने पर कुल मूल्य देता NULL

दूसरे शब्दों में, OUTER JOIN इस तथ्य पर आधारित है कि: केवल तालिकाओं में से एक (दाएं या बाएं) या तालिकाओं के दोनों (मिलान) में मिलान प्रविष्टियां सूचीबद्ध की जानी चाहिए।

Note that `OUTER JOIN` is a loosened form of `INNER JOIN`.

3. प्राकृतिक जॉइन:

यह दो स्थितियों पर आधारित है:

  1. समानता के लिए समान नाम वाले सभी कॉलम पर JOIN बनाया जाता है।
  2. परिणाम से डुप्लिकेट कॉलम हटा देता है।

यह प्रकृति में सैद्धांतिक प्रतीत होता है और नतीजतन (संभवतः) अधिकांश डीबीएमएस इस समर्थन को भी परेशान नहीं करते हैं।

4. क्रॉस जॉइन:

यह शामिल दो तालिकाओं का कार्टेशियन उत्पाद है। CROSS JOIN का नतीजा ज्यादातर स्थितियों में समझ में नहीं आता है। इसके अलावा, हमें इसकी बिल्कुल आवश्यकता नहीं है (या कम से कम, सटीक होने की आवश्यकता है)।

5. स्वयं शामिल:

यह JOIN का एक अलग रूप नहीं है, बल्कि यह एक टेबल के लिए एक JOIN ( INNER , OUTER , आदि) है।

ऑपरेटर के आधार पर जॉइन

JOIN क्लॉज के लिए प्रयुक्त ऑपरेटर के आधार पर, दो प्रकार के JOIN एस हो सकते हैं। वो हैं

  1. इक्की जॉइन
  2. थेटा जॉइन

1. इक्की जॉइन:

जो भी प्रकार के प्रकार ( INNER , OUTER , आदि) के लिए, अगर हम केवल समानता ऑपरेटर (=) का उपयोग करते हैं, तो हम कहते हैं कि JOIN एक EQUI JOIN

2. थेटा जॉइन:

यह EQUI JOIN समान है लेकिन यह अन्य सभी ऑपरेटरों जैसे>, <,> = आदि की अनुमति देता है।

कई लोग EQUI JOIN और थेटा दोनों में INNER , INNER , EQUI JOIN । लेकिन मुझे दृढ़ विश्वास है कि यह एक गलती है और विचारों को अस्पष्ट बनाता है। क्योंकि INNER JOIN , OUTER JOIN इत्यादि सभी टेबल और उनके डेटा से जुड़े हुए हैं, जहां EQUI JOIN और EQUI JOIN केवल ऑपरेटर से जुड़े होते हैं जिन्हें हम पूर्व में उपयोग करते हैं।

फिर, ऐसे कई लोग हैं जो NATURAL JOIN को "अनोखा" EQUI JOIN । असल में, यह सच है, क्योंकि मैंने पहली बार NATURAL JOIN लिए उल्लेख किया था। हालांकि, हमें केवल उसमें केवल NATURAL JOIN को ही सीमित नहीं करना है। INNER JOIN एस, OUTER JOIN एस भी एक EQUI JOIN हो सकता है।


परिभाषा:

जॉइन एक साथ डेटा को क्वेरी करने का तरीका है जो एक साथ कई तालिकाओं से मिलकर बनता है।

जॉइन के प्रकार:

आरडीबीएमएस के बारे में चिंता 5 प्रकार के शामिल हैं:

  • इक्वि-जॉइन: समानता स्थिति के आधार पर दो तालिकाओं से सामान्य रिकॉर्ड जोड़ती है। तकनीकी रूप से, समानता-ऑपरेटर (=) का उपयोग करके एक तालिका के प्राथमिककी के मूल्यों की तुलना करने के लिए और एन्थर तालिका के फोरीग्न कुंजी मानों का उपयोग करके शामिल हों, इसलिए परिणाम सेट में दोनों तालिकाओं से सामान्य (मिलान) रिकॉर्ड शामिल हैं। कार्यान्वयन के लिए INNER-JOIN देखें।

  • प्राकृतिक-जुड़ें: यह इक्वि-जॉइन का वर्धित संस्करण है, जिसमें SELECT ऑपरेशन डुप्लिकेट कॉलम को छोड़ देता है। कार्यान्वयन के लिए INNER-JOIN देखें

  • गैर-इक्वि-जॉइन: यह इक्वि-जॉइन के विपरीत है जहां जॉइनिंग स्थिति बराबर ऑपरेटर (=) जैसे,! =, <=,> =,>, <या BETWEEN आदि के अलावा उपयोग की जाती है। कार्यान्वयन के लिए INNER-JOIN देखें।

  • स्व-जुड़ें:: शामिल होने का एक अनुकूलित व्यवहार जहां एक टेबल स्वयं के साथ संयुक्त हो; यह आमतौर पर स्वयं-संदर्भ तालिका (या यूनरी रिलेशनशिप इकाई) से पूछताछ के लिए आवश्यक है। कार्यान्वयन के लिए INNER-JOINs देखें।

  • कार्टेशियन उत्पाद: यह क्रॉस किसी भी शर्त के बिना दोनों तालिकाओं के सभी रिकॉर्ड को जोड़ता है। तकनीकी रूप से, यह WHERE-Clause के बिना एक क्वेरी का परिणाम सेट देता है।

एसक्यूएल चिंता और प्रगति के अनुसार, 3 प्रकार के जॉइन हैं और इन प्रकार के जॉइन का उपयोग करके सभी आरडीबीएमएस में शामिल हो सकते हैं।

  1. इनर-जॉइन: यह दो तालिकाओं से मेल खाने वाली पंक्तियों (या संयोजन) विलय करता है। मिलान टेबल के सामान्य कॉलम और उनके तुलनात्मक संचालन के आधार पर किया जाता है। यदि समानता आधारित स्थिति तब होती है: इक्वि-जॉइन प्रदर्शन किया जाता है, अन्यथा गैर-इक्वि-जॉइन।

  2. ** बाहरी-जॉइन: ** यह दो तालिकाओं से मेल खाने वाली पंक्तियों और नल मूल्यों के साथ बेजोड़ पंक्तियों को मिलाता है (या जोड़ता है)। हालांकि, अन-मिलान वाली पंक्तियों के चयन को अनुकूलित कर सकते हैं उदाहरण के लिए, उप तालिका के द्वारा पहली तालिका या दूसरी तालिका से बेजोड़ पंक्ति का चयन करना: बाएं बाहरी जॉइन और दाएं बाहरी जॉइन।

    2.1। बाएं बाहरी जॉइन (उर्फ, बाएं-जॉइन): मिलान की गई पंक्तियां दो टेबल बनाती हैं और केवल बाएं तालिका (यानी, पहली तालिका) से अनमैच होती हैं।

    2.2। दाएं बाहरी जॉइन (उर्फ, दाएं-जॉइन): दो तालिकाओं से मिलान की गई पंक्तियां लौटाती है और केवल दाएं तालिका से बेजोड़ होती है।

    2.3। पूर्ण बाहरी जॉइन (उर्फ आउटर जॉइन): दोनों टेबलों से मिलान और बेजोड़ लौटाता है।

  3. क्रॉस-जॉइन: यह शामिल नहीं होता है इसके बजाय यह विलय / संयोजन नहीं करता है बल्कि यह कार्टशियन उत्पाद करता है।

नोट: आवश्यकता के आधार पर स्वयं-जॉइन इनर-जॉइन, आउट-जॉइन और क्रॉस-जॉइन द्वारा प्राप्त किया जा सकता है लेकिन तालिका को अपने साथ शामिल होना चाहिए।

अधिक जानकारी के लिए:

उदाहरण:

1.1: इनर-जॉइन: इक्विटी-अपूर्णता शामिल हों

SELECT  *
FROM Table1 A 
 INNER JOIN Table2 B ON A.<PrimaryKey> =B.<ForeignKey>;

1.2: इनर-जॉइन: प्राकृतिक-जॉइन कार्यान्वयन

Select A.*, B.Col1, B.Col2          --But no B.ForiengKyeColumn in Select
 FROM Table1 A
 INNER JOIN Table2 B On A.Pk = B.Fk;

1.3: गैर-एकिजॉइन कार्यान्वयन के साथ INNER- जुड़ें

Select *
 FROM Table1 A INNER JOIN Table2 B On A.Pk <= B.Fk;

1.4: स्वयं-जॉइन के साथ प्रवेश करें

Select *
 FROM Table1 A1 INNER JOIN Table1 A2 On A1.Pk = A2.Fk;

2.1: बाहरी जॉइन (पूर्ण बाहरी शामिल)

Select *
 FROM Table1 A FULL OUTER JOIN Table2 B On A.Pk = B.Fk;

2.2: बाएं जॉइन

Select *
 FROM Table1 A LEFT OUTER JOIN Table2 B On A.Pk = B.Fk;

2.3: सही जॉइन

Select *
 FROM Table1 A RIGHT OUTER JOIN Table2 B On A.Pk = B.Fk;

3.1: क्रॉस जॉइन

Select *
 FROM TableA CROSS JOIN TableB;

3.2: क्रॉस जॉइन-सेल्फ जॉइन

Select *
 FROM Table1 A1 CROSS JOIN Table1 A2;

// या //

Select *
 FROM Table1 A1,Table1 A2;

दिलचस्प बात यह है कि ज्यादातर अन्य उत्तर इन दो समस्याओं से ग्रस्त हैं:

मैंने हाल ही में विषय पर एक लेख लिखा है: एसक्यूएल में टेबल्स में शामिल होने के कई अलग-अलग तरीकों के लिए एक संभावित अपूर्ण, व्यापक मार्गदर्शिका , जिसे मैं यहां सारांशित करूंगा।

सबसे पहले और सबसे प्रमुख: जॉइन कार्टेशियन उत्पाद हैं

यही कारण है कि वेन आरेख उन्हें गलत तरीके से समझाते हैं, क्योंकि एक जॉइन दो जुड़ने वाली टेबलों के बीच एक कार्टेशियन उत्पाद बनाता है। विकिपीडिया इसे अच्छी तरह से दिखाता है:

कार्टेशियन उत्पादों के लिए एसक्यूएल वाक्यविन्यास CROSS JOIN । उदाहरण के लिए:

SELECT *

-- This just generates all the days in January 2017
FROM generate_series(
  '2017-01-01'::TIMESTAMP,
  '2017-01-01'::TIMESTAMP + INTERVAL '1 month -1 day',
  INTERVAL '1 day'
) AS days(day)

-- Here, we're combining all days with all departments
CROSS JOIN departments

जो अन्य तालिका से सभी पंक्तियों के साथ एक तालिका से सभी पंक्तियों को जोड़ती है:

स्रोत:

+--------+   +------------+
| day    |   | department |
+--------+   +------------+
| Jan 01 |   | Dept 1     |
| Jan 02 |   | Dept 2     |
| ...    |   | Dept 3     |
| Jan 30 |   +------------+
| Jan 31 |
+--------+

परिणाम:

+--------+------------+
| day    | department |
+--------+------------+
| Jan 01 | Dept 1     |
| Jan 01 | Dept 2     |
| Jan 01 | Dept 3     |
| Jan 02 | Dept 1     |
| Jan 02 | Dept 2     |
| Jan 02 | Dept 3     |
| ...    | ...        |
| Jan 31 | Dept 1     |
| Jan 31 | Dept 2     |
| Jan 31 | Dept 3     |
+--------+------------+

अगर हम सिर्फ टेबल की अल्पविराम से अलग सूची लिखते हैं, तो हम वही प्राप्त करेंगे:

-- CROSS JOINing two tables:
SELECT * FROM table1, table2

इनर जॉइन (थेटा-जॉइन)

एक INNER JOIN सिर्फ एक फ़िल्टर CROSS JOIN जहां फ़िल्टर की भविष्यवाणी को बीजगणित संबंध में Theta कहा जाता है।

उदाहरण के लिए:

SELECT *

-- Same as before
FROM generate_series(
  '2017-01-01'::TIMESTAMP,
  '2017-01-01'::TIMESTAMP + INTERVAL '1 month -1 day',
  INTERVAL '1 day'
) AS days(day)

-- Now, exclude all days/departments combinations for
-- days before the department was created
JOIN departments AS d ON day >= d.created_at

ध्यान दें कि कीवर्ड INNER वैकल्पिक है (एमएस एक्सेस को छोड़कर)।

( परिणाम उदाहरणों के लिए आलेख देखें )

इक्की जॉइन

एक विशेष प्रकार की थीटा-जॉइन इक्की जॉइन है, जिसे हम सबसे अधिक उपयोग करते हैं। भविष्यवाणी एक तालिका की प्राथमिक कुंजी को दूसरी तालिका की विदेशी कुंजी के साथ जोड़ती है। यदि हम चित्रण के लिए साकिला डेटाबेस का उपयोग करते हैं, तो हम लिख सकते हैं:

SELECT *
FROM actor AS a
JOIN film_actor AS fa ON a.actor_id = fa.actor_id
JOIN film AS f ON f.film_id = fa.film_id

यह सभी अभिनेताओं को उनकी फिल्मों के साथ जोड़ती है।

या कुछ डेटाबेस पर भी:

SELECT *
FROM actor
JOIN film_actor USING (actor_id)
JOIN film USING (film_id)

USING() वाक्यविन्यास एक कॉलम निर्दिष्ट करने की अनुमति देता है जो जॉइन ऑपरेशन की तालिका के दोनों तरफ मौजूद होना चाहिए और उन दो कॉलमों पर एक समानता भविष्यवाणी करता है।

प्राकृतिक जॉइन

अन्य उत्तरों ने इस "जॉइन टाइप" को अलग से सूचीबद्ध किया है, लेकिन यह समझ में नहीं आता है। यह इक्की जॉइन के लिए सिर्फ एक वाक्यविन्यास चीनी रूप है, जो थेटा-जॉइन या इनर जॉइन का एक विशेष मामला है। प्राकृतिक जॉइन बस उन सभी कॉलम एकत्र करता है जो दोनों तालिकाओं में शामिल होने के लिए आम हैं और उन स्तंभों का USING() शामिल होते हैं। आकस्मिक मैचों की वजह से शायद ही कभी उपयोगी होता है (जैसे LAST_UPDATE डेटाबेस में LAST_UPDATE कॉलम)।

वाक्यविन्यास यहां दिया गया है:

SELECT *
FROM actor
NATURAL JOIN film_actor
NATURAL JOIN film

बाहरी जॉइन

अब, OUTER JOIN INNER JOIN से थोड़ा अलग है क्योंकि यह कई कार्टेशियन उत्पादों का UNION बनाता है। हम लिख सकते है:

-- Convenient syntax:
SELECT *
FROM a LEFT JOIN b ON <predicate>

-- Cumbersome, equivalent syntax:
SELECT a.*, b.*
FROM a JOIN b ON <predicate>
UNION ALL
SELECT a.*, NULL, NULL, ..., NULL
FROM a
WHERE NOT EXISTS (
  SELECT * FROM b WHERE <predicate>
)

कोई भी उत्तरार्द्ध लिखना नहीं चाहता, इसलिए हम OUTER JOIN लिखते हैं (जिसे आमतौर पर डेटाबेस द्वारा बेहतर अनुकूलित किया जाता है)।

INNER तरह, कीवर्ड OUTER वैकल्पिक है, यहां।

OUTER JOIN तीन स्वादों में आता है:

  • LEFT [ OUTER ] JOIN : JOIN अभिव्यक्ति की बाईं तालिका को ऊपर दिखाए गए अनुसार यूनियन में जोड़ा गया है।
  • RIGHT [ OUTER ] JOIN : JOIN अभिव्यक्ति की सही तालिका ऊपर दिखाए गए अनुसार संघ में जोड़ दी गई है।
  • FULL [ OUTER ] JOIN : JOIN अभिव्यक्ति की दोनों FULL [ OUTER ] JOIN ऊपर दिखाए गए अनुसार यूनियन में जोड़ दी गई हैं।

इन सभी को कीवर्ड USING() या NATURAL के साथ जोड़ा जा सकता है ( मैंने हाल ही में एक NATURAL FULL JOIN उपयोग के लिए वास्तविक दुनिया का उपयोग किया है )

वैकल्पिक वाक्यविन्यास

ओरेकल और एसक्यूएल सर्वर में कुछ ऐतिहासिक, बहिष्कृत वाक्यविन्यास हैं, जो एसक्यूएल मानक के पहले से ही सिंटैक्स के पहले OUTER JOIN समर्थन करते थे:

-- Oracle
SELECT *
FROM actor a, film_actor fa, film f
WHERE a.actor_id = fa.actor_id(+)
AND fa.film_id = f.film_id(+)

-- SQL Server
SELECT *
FROM actor a, film_actor fa, film f
WHERE a.actor_id *= fa.actor_id
AND fa.film_id *= f.film_id

ऐसा करने के बाद, इस वाक्यविन्यास का प्रयोग न करें। मैं बस इसे यहां सूचीबद्ध करता हूं ताकि आप इसे पुराने ब्लॉग पोस्ट / विरासत कोड से पहचान सकें।

विभाजित OUTER JOIN

कुछ लोगों को यह पता है, लेकिन एसक्यूएल मानक विभाजित OUTER JOIN निर्दिष्ट करता है (और ओरेकल इसे लागू करता है)। आप इस तरह की चीजें लिख सकते हैं:

WITH

  -- Using CONNECT BY to generate all dates in January
  days(day) AS (
    SELECT DATE '2017-01-01' + LEVEL - 1
    FROM dual
    CONNECT BY LEVEL <= 31
  ),

  -- Our departments
  departments(department, created_at) AS (
    SELECT 'Dept 1', DATE '2017-01-10' FROM dual UNION ALL
    SELECT 'Dept 2', DATE '2017-01-11' FROM dual UNION ALL
    SELECT 'Dept 3', DATE '2017-01-12' FROM dual UNION ALL
    SELECT 'Dept 4', DATE '2017-04-01' FROM dual UNION ALL
    SELECT 'Dept 5', DATE '2017-04-02' FROM dual
  )
SELECT *
FROM days 
LEFT JOIN departments 
  PARTITION BY (department) -- This is where the magic happens
  ON day >= created_at

परिणाम के भाग:

+--------+------------+------------+
| day    | department | created_at |
+--------+------------+------------+
| Jan 01 | Dept 1     |            | -- Didn't match, but still get row
| Jan 02 | Dept 1     |            | -- Didn't match, but still get row
| ...    | Dept 1     |            | -- Didn't match, but still get row
| Jan 09 | Dept 1     |            | -- Didn't match, but still get row
| Jan 10 | Dept 1     | Jan 10     | -- Matches, so get join result
| Jan 11 | Dept 1     | Jan 10     | -- Matches, so get join result
| Jan 12 | Dept 1     | Jan 10     | -- Matches, so get join result
| ...    | Dept 1     | Jan 10     | -- Matches, so get join result
| Jan 31 | Dept 1     | Jan 10     | -- Matches, so get join result

यहां बिंदु यह है कि जॉइन के विभाजन के पक्ष से सभी पंक्तियां परिणाम में उछल जाएंगी, भले ही JOIN ने "जॉइन के दूसरी तरफ" से कुछ भी मिलान किया हो। लंबी कहानी छोटी: यह रिपोर्ट में स्पैस डेटा भरना है। बहुत उपयोगी!

सेमी जॉइन

गंभीरता से? कोई अन्य जवाब यह नहीं मिला? बेशक नहीं, क्योंकि एसक्यूएल में इसका मूल वाक्यविन्यास नहीं है, दुर्भाग्यवश (जैसे नीचे एंटी जॉइन की तरह)। लेकिन हम IN() और EXISTS() उपयोग कर सकते हैं, उदाहरण के लिए फिल्मों में खेले गए सभी कलाकारों को ढूंढने के लिए:

SELECT *
FROM actor a
WHERE EXISTS (
  SELECT * FROM film_actor fa
  WHERE a.actor_id = fa.actor_id
)

WHERE a.actor_id = fa.actor_id भविष्यवाणी अर्द्ध शामिल होने के रूप में कार्य करता है। यदि आप इस पर विश्वास नहीं करते हैं, तो निष्पादन योजनाएं देखें, उदाहरण के लिए ओरेकल में। आप देखेंगे कि डेटाबेस एक सेमी जॉइन ऑपरेशन निष्पादित करता है, न कि EXISTS() predicate।

एंटी जॉइन

यह केवल सेमी जॉइन के विपरीत है ( सावधान रहें , हालांकि इसका उपयोग NOT IN करें , क्योंकि इसमें एक महत्वपूर्ण चेतावनी है)

फिल्मों के बिना सभी अभिनेता यहां दिए गए हैं:

SELECT *
FROM actor a
WHERE NOT EXISTS (
  SELECT * FROM film_actor fa
  WHERE a.actor_id = fa.actor_id
)

कुछ लोग (विशेष रूप से MySQL लोग) इस तरह एंटी जॉइन भी लिखते हैं:

SELECT *
FROM actor a
LEFT JOIN film_actor fa
USING (actor_id)
WHERE film_id IS NULL

मुझे लगता है कि ऐतिहासिक कारण प्रदर्शन है।

लैटिन जॉइन

ओएमजी, यह बहुत अच्छा है। मैं इसका उल्लेख करने वाला अकेला हूं? यहां एक अच्छी क्वेरी है:

SELECT a.first_name, a.last_name, f.*
FROM actor AS a
LEFT OUTER JOIN LATERAL (
  SELECT f.title, SUM(amount) AS revenue
  FROM film AS f
  JOIN film_actor AS fa USING (film_id)
  JOIN inventory AS i USING (film_id)
  JOIN rental AS r USING (inventory_id)
  JOIN payment AS p USING (rental_id)
  WHERE fa.actor_id = a.actor_id -- JOIN predicate with the outer query!
  GROUP BY f.film_id
  ORDER BY revenue DESC
  LIMIT 5
) AS f
ON true

यह प्रति अभिनेता शीर्ष 5 राजस्व उत्पादन फिल्मों को मिलेगा। हर बार जब आपको टॉप-एन-प्रति-कुछ पूछताछ की आवश्यकता होती है, तो LATERAL JOIN आपका मित्र होगा। यदि आप एक SQL सर्वर व्यक्ति हैं, तो आप इस JOIN प्रकार को नाम के तहत जानते हैं

SELECT a.first_name, a.last_name, f.*
FROM actor AS a
OUTER APPLY (
  SELECT f.title, SUM(amount) AS revenue
  FROM film AS f
  JOIN film_actor AS fa ON f.film_id = fa.film_id
  JOIN inventory AS i ON f.film_id = i.film_id
  JOIN rental AS r ON i.inventory_id = r.inventory_id
  JOIN payment AS p ON r.rental_id = p.rental_id
  WHERE fa.actor_id = a.actor_id -- JOIN predicate with the outer query!
  GROUP BY f.film_id
  ORDER BY revenue DESC
  LIMIT 5
) AS f

ठीक है, शायद यह धोखाधड़ी है, क्योंकि एक LATERAL JOIN या APPLY अभिव्यक्ति वास्तव में एक "सहसंबंधित सबक्वायरी" है जो कई पंक्तियां उत्पन्न करती है। लेकिन अगर हम "सहसंबंधित सबक्वायरीज़" की अनुमति देते हैं, तो हम इसके बारे में भी बात कर सकते हैं ...

मल्टीसेट

यह केवल ओरेकल और इनफॉर्मिक्स (मेरे ज्ञान के लिए) द्वारा वास्तव में कार्यान्वित किया जाता है, लेकिन इसे एआरएस और / या एक्सएमएल और एक्सएमएल का उपयोग कर एसक्यूएल सर्वर में पोस्टग्रेएसक्यूएल में नकल किया जा सकता है।

MULTISET बाहरी क्वेरी में पंक्तियों के परिणामी सेट के साथ एक सहसंबंधित सबक्वायरी और घोंसले का उत्पादन करता है। नीचे दी गई क्वेरी सभी कलाकारों का चयन करती है और प्रत्येक अभिनेता के लिए अपनी फिल्मों को नेस्टेड संग्रह में एकत्रित करता है:

SELECT a.*, MULTISET (
  SELECT f.*
  FROM film AS f
  JOIN film_actor AS fa USING (film_id)
  WHERE a.actor_id = fa.actor_id
) AS films
FROM actor

जैसा कि आपने देखा है, केवल "उबाऊ" INNER , OUTER और CROSS JOIN तुलना में अधिक प्रकार के जॉइन हैं जिनका आमतौर पर उल्लेख किया जाता है। मेरे लेख में अधिक जानकारी । और कृपया, उन्हें चित्रित करने के लिए वेन आरेखों का उपयोग करना बंद करें।


मुझे लगता है कि अगर कोई PHP और MySQL या कुछ अन्य डेटा का उपयोग करना चाहता हैबेस सर्वर:

  1. PDO (PHP डेटा ऑब्जेक्ट्स) सीखने के बारे में सोचें - यह एक डाटाबेस एक्सेस लेयर है जो एकाधिक डेटाबेस तक पहुंच की एक समान विधि प्रदान करता है।
  2. MySQLi सीखने के बारे में सोचोMySQLi
  3. मूल PHP फ़ंक्शंस का उपयोग करें जैसे: strip_tags , mysql_real_escape_string() या यदि वेरिएबल न्यूमेरिक, बस (int)$foohere PHP में चर के प्रकार के बारे में और पढ़ें । यदि आप पीडीओ या MySQLi जैसे पुस्तकालयों का उपयोग कर रहे हैं, तो हमेशा PDO::quote() और mysqli_real_escape_string()

पुस्तकालय उदाहरण:

---- पीडीओ

----- कोई प्लेसहोल्डर नहीं - एसक्यूएल इंजेक्शन के लिए परिपक्व! यह बुरा है

$request = $pdoConnection->("INSERT INTO parents (name, addr, city) values ($name, $addr, $city)");

----- अनाम प्लेसहोल्डर्स

$request = $pdoConnection->("INSERT INTO parents (name, addr, city) values (?, ?, ?);

----- नामित प्लेसहोल्डर्स

$request = $pdoConnection->("INSERT INTO parents (name, addr, city) value (:name, :addr, :city)");

--- MySQLi

$request = $mysqliConnection->prepare('
       SELECT * FROM trainers
       WHERE name = ?
       AND email = ?
       AND last_login > ?');

    $query->bind_param('first_param', 'second_param', $mail, time() - 3600);
    $query->execute();

पीएस :

पीडीओ आसानी से इस लड़ाई जीतता है। बारह अलग डेटाबेस ड्राइवरों और नामित पैरामीटर के समर्थन के साथ, हम छोटे प्रदर्शन हानि को अनदेखा कर सकते हैं, और इसके एपीआई में उपयोग कर सकते हैं। एक सुरक्षा दृष्टिकोण से, दोनों तब तक सुरक्षित हैं जब तक डेवलपर उन्हें उपयोग करने के तरीके का उपयोग करता है

लेकिन पीडीओ और माईस्क्लुली दोनों तेजी से हैं, जबकि MySQLi मानक में तेजी से तेज़ी से प्रदर्शन करता है - गैर-तैयार बयानों के लिए ~ 2.5%, और तैयार लोगों के लिए ~ 6.5%।

और कृपया अपने डेटाबेस में प्रत्येक क्वेरी का परीक्षण करें - इंजेक्शन को रोकने के लिए यह एक बेहतर तरीका है।





sql database oracle postgresql rdbms