हम खुद को Oracle प्रवास श्रृंखला के तीसरे लेख में पाते हैं। इस बार, हम उन अजीब ऑपरेटरों को देखते हैं जो Oracle (+) में WHERE क्लॉज मानदंड को संशोधित करते हैं। अन्य सभी चीज़ों की तरह, PostgreSQL के पास भी इसका समाधान है।
राइट जॉइन करें
Oracle का समर्थन करता है, और कई डेवलपर्स योग्यता खंड के लिए ऑपरेटरों का उपयोग करके ANSI बाहरी JOIN सिंटैक्स का उपयोग करते हैं।
आमतौर पर, यह कुछ इस तरह दिखता है:
SELECT *
FROM person, places
WHERE person.id = places.person_id(+)इस सिंटैक्स का उद्देश्य एक सही बाहरी जुड़ाव है। सेट थ्योरी शब्दों में, यह व्यक्ति की परवाह किए बिना सभी स्थानों सहित सबसेट है।
एक छोटे से नमूने का परिणाम इस तरह दिखेगा:
| id | last_name | first_name | id | स्थान | person_id |
|---|---|---|---|---|---|
| 1 | (NULL) | (NULL) | 1 | डलास | (NULL) |
| 2 | रॉयल | किर्क | 2 | लंदन | 2 |
| 3 | Riggs | साइमन | 3 | पेरिस | 3 |
यह सिंटैक्स PostgreSQL में समर्थित नहीं है।
समान परिणाम प्राप्त करने के लिए, आप बाहरी जुड़ने के लिए मानक SQL सिंटैक्स का उपयोग करेंगे।
SELECT *
FROM persons
RIGHT JOIN places
ON persons.id = places.person_id;
SQL एक स्पष्ट क्रियाविशेषण भी प्रदान करता है OUTER . यह स्पष्टीकरण पूरी तरह से वैकल्पिक है, जैसा कि कोई भी RIGHT JOIN परिभाषा के अनुसार OUTER है शामिल हों।
पूर्ण जॉइन
इसी तरह, पूर्ण जुड़ाव के लिए Oracle सिंटैक्स का उपयोग करना PostgreSQL में काम नहीं करता है।
SELECT *
FROM persons, places
WHERE persons.id(+) = places(+);इस वाक्य रचना का उद्देश्य व्यक्तियों और स्थानों की पूरी सूची है चाहे कोई व्यक्ति किसी स्थान से जुड़ा हो या नहीं।
परिणाम यह चाहेंगे:
| id | last_name | <वें स्टाइल ="टेक्स्ट-एलाइन:लेफ्ट;">फर्स्ट_नाम**id | स्थान | person_id | |
|---|---|---|---|---|---|
| 1 | (NULL) | (NULL) | 1 | डलास | (NULL) |
| 2 | रॉयल | किर्क | 2 | लंदन | 2 |
| 3 | Riggs | साइमन | 3 | पेरिस | 3 |
| 4 | एंड्रयू | Dunstan | (NULL) | (NULL) | (NULL) |
PostgreSQL सिंटैक्स का उपयोग करके, क्वेरी इस प्रकार लिखी जाएगी:
SELECT *
FROM persons
FULL JOIN places
ON persons.id = places.person_id;
फिर से, OUTER कीवर्ड पूरी तरह से वैकल्पिक है।
क्रॉस जॉइन
निहित संबंधों के बजाय कीवर्ड का उपयोग करने के दृष्टिकोण का एक विशिष्ट लाभ यह है कि आप गलती से एक क्रॉस उत्पाद बनाने में सक्षम नहीं हैं।
वाक्य रचना:
SELECT *
FROM persons
LEFT JOIN places;इसके परिणामस्वरूप त्रुटि होगी:
ERROR: syntax error at or near ";"यह दर्शाता है कि लाइन एंडिंग मार्कर ";" पर स्टेटमेंट पूरा नहीं है।
PostgreSQL ANSI सिंटैक्स का उपयोग करके क्रॉस जॉइन उत्पाद बनाएगा।
SELECT *
FROM persons, places;| id | last_name | प्रथम_नाम | आईडी | स्थान | person_id |
|---|---|---|---|---|---|
| 1 | डंस्टन | एंड्रयू | 1 | डलास | (शून्य) |
| 1 | डंस्टन | एंड्रयू | 2 | लंदन | 2 |
| 1 | डंस्टन | एंड्रयू | 3 | पेरिस | 3 |
| 1 | डंस्टन | एंड्रयू | 4 | मैड्रिड | (शून्य) |
| 2 | रॉयल | किर्क | 1 | डलास | (शून्य) |
| 2 | रॉयल | किर्क | 2 | लंदन | 2 |
| 2 | रॉयल | किर्क | 3 | पेरिस | 3 |
| 2 | रॉयल | किर्क | 4 | मैड्रिड | (शून्य) |
| 3 | रिग्स | साइमन | 1 | डलास | (शून्य) |
| 3 | रिग्स | साइमन | 2 | लंदन | 2 |
| 3 | रिग्स | साइमन | 3 | पेरिस | 3 |
| 3 | रिग्स | साइमन | 4 | मैड्रिड | (शून्य) |
| 6 | वोंग | चिह्नित करें | 1 | डलास | (शून्य) |
| 6 | वोंग | चिह्नित करें | 2 | लंदन | 2 |
| 6 | वोंग | चिह्नित करें | 3 | पेरिस | 3 |
| 6 | वोंग | चिह्नित करें | 4 | मैड्रिड | (शून्य) |
जो जानबूझकर परिणाम की तुलना में कोडिंग त्रुटि की अधिक संभावना है।
इस कार्यक्षमता को जानबूझकर प्राप्त करने के लिए, CROSS JOIN . का उपयोग करने की अनुशंसा की जाती है बयान।
SELECT *
FROM persons
CROSS JOIN places;इस प्रकार यह स्पष्ट हो जाता है कि कथन में क्या था।
प्राकृतिक जुड़ाव
PostgreSQL NATURAL JOIN का समर्थन करता है वाक्य रचना, लेकिन थोड़ा विरोध में।
SELECT *
FROM persons
NATURAL JOIN places;यह निम्नलिखित परिणाम उत्पन्न करता है।
| id | last_name | प्रथम_नाम | parent_id | स्थान | person_id |
|---|---|---|---|---|---|
| 1 | डंस्टन | एंड्रयू | (शून्य) | डलास | (शून्य) |
| 2 | रॉयल | किर्क | 1 | लंदन | 2 |
| 3 | रिग्स | साइमन | 1 | पेरिस | 3 |
हालाँकि, यह वाक्यविन्यास एक समस्या है। हमारे उदाहरण के लिए, दोनों तालिकाओं में "आईडी" कॉलम का एक दूसरे से कोई लेना-देना नहीं है . इस जुड़ाव ने एक परिणाम दिया है, लेकिन एक पूरी तरह अप्रासंगिक सामग्री के साथ।
इसके अतिरिक्त, आपके पास एक प्रश्न हो सकता है जो शुरू में सही परिणाम प्रस्तुत करता है, लेकिन बाद के डीडीएल स्टेटमेंट चुपचाप प्रभावित करते हैं।
विचार करें:
ALTER TABLE person ADD COLUMN places_id bigint;
ALTER TABLE places ADD COLUMN places_id bigint;
ALTER TABLE person ADD COLUMN person_id bigint;
अब NATURAL JOIN कौन सा कॉलम है? उपयोग कर रहे हैं? विकल्प हैं id, place_id, person_id, और उपरोक्त सभी। मैं उत्तर को एक अभ्यास के रूप में पाठक पर छोड़ता हूँ।
यह सिंटैक्स आपके कोड के लिए एक टाइम बम है। बस इसका इस्तेमाल न करें।
ठीक है, तो आप आश्वस्त नहीं हैं। ठीक है, तो कम से कम कुछ समझदार कोडिंग सम्मेलन हैं। पैरेंट टेबल के लिए, पहचान कॉलम को "myparenttable_id" नाम दें। इसे बाल संबंधों से संदर्भित करते समय, उसी नाम का प्रयोग करें, "myparenttable_id"। कभी भी किसी भी चीज़ को "आईडी" नाम न दें, और कभी भी किसी भिन्न नाम वाले कॉलम का संदर्भ न दें। आह, भूल जाओ। बस ऐसा मत करो।
USING . का उपयोग करके आप पिछली पहेली को स्पष्ट करने के लिए ललचा सकते हैं खोजशब्द। यह इस तरह दिखेगा:
SELECT *
FROM persons
JOIN places
USING (id);
लेकिन USING कीवर्ड केवल सभी तालिकाओं में सटीक नाम मिलान का लाभ उठा सकता है। जो फिर से, हमारे उदाहरण में गलत है।
PostgreSQL के लिए सबसे अच्छा अभ्यास विकल्प केवल कन्वेंशन मानकों को कोड करके टेबल डिजाइन करने से बचना है।
सारांश
ये कीवर्ड तकनीक (बनाम ऑपरेटर) Oracle पर भी उपलब्ध हैं। वे अधिक क्रॉस-प्लेटफ़ॉर्म हैं, और कम अस्पष्ट हैं। यही उन्हें सर्वोत्तम अभ्यास बना देगा।
इसके अलावा, अनुचित तरीके से उपयोग किए जाने पर वे तार्किक त्रुटियों को उजागर करते हैं। PostgreSQL में किसी भी विकास के लिए, हम एकतरफा स्पष्ट कीवर्ड का उपयोग करने की सलाह देते हैं।
