{
  "assessmentTests": {
    "sql_test": {
      "name": "SQL टेस्ट",
      "desc": "फ़िल्टरिंग, जॉइन्स, एग्रीगेशन, सबक्वेरीज़ और विंडो फंक्शन्स पर 30 परिदृश्य-आधारित प्रश्न — पता लगाएँ कि क्या आपकी SQL वह है जो नौकरी की पोस्टिंग SQL प्रवीणता से माने।",
      "recommendation": "आपकी SQL कौशल प्रोफ़ाइल",
      "results": {
        "beginner": {
          "name": "नौसिखिया",
          "desc": "आप एक सरल SELECT कथन लिख सकते हैं और कुछ शर्तों पर फ़िल्टर कर सकते हैं, लेकिन जो प्रश्न आप गलत करते हैं वे NULL हैंडलिंग और जॉइन मैकेनिक्स के चारों ओर जमा होते हैं, न कि सिंटेक्स के — एक कॉलम को NULL से तुलना करना `=` के साथ, वह जो LEFT JOIN वास्तव में संरक्षित करता है, BETWEEN की सटीक सीमाएँ कैसे काम करती हैं। यह SQL में बुरे होने के बारे में नहीं है; ये वो खास नियम हैं जो लोगों को परेशान करते हैं जिन्होंने SQL को परीक्षण और त्रुटि से सीखा है, न कि मानक से। ये काम पर महत्वपूर्ण हैं क्योंकि हर एक वह जगह है जहाँ एक क्वेरी प्रशंसनीय दिखने वाली लेकिन गलत पंक्ति संख्या रिटर्न करती है।",
          "recommendation": "इन तीन चीज़ों से शुरुआत करें, इसी क्रम में: क्यों `WHERE col = NULL` कभी कुछ नहीं मिलाता (`IS NULL` की जरूरत होती है), INNER JOIN बनाम LEFT JOIN क्या अलग करता है, और BETWEEN की सटीक सीमाएँ क्या हैं। Mode Analytics की SQL ट्यूटोरियल और PostgreSQL डॉक्यूमेंटेशन दोनों ही चलाने योग्य उदाहरणों के साथ तीनों को कवर करते हैं।"
        },
        "intermediate": {
          "name": "मध्यवर्ती",
          "desc": "आप रोज़मर्रा की रिपोर्टिंग क्वेरीज़ में सहज हैं — जॉइन्स, GROUP BY, सीधे-सादे फ़िल्टरिंग — और दिनचर्या डेशबोर्ड या तदर्थ विश्लेषण काम से धीमे नहीं होंगे। यहाँ और उन्नत के बीच का अंतर ज़्यादातर इस बात में है कि जब क्लॉज़ एक-दूसरे के साथ इंटरैक्ट करते हैं: जॉइन की गई तालिका पर WHERE क्लॉज़ शांति से LEFT JOIN को एक INNER JOIN में बदल देता है, एक जॉइन जो एकत्रीकरण से पहले पंक्ति गणना फैला देता है, एक NOT IN जो शांति से सब कुछ वापस करता है क्योंकि सबक्वेरी में एक NULL फिसल गया। ये वह तरह की बग हैं जो एक तेज़ नज़र की जांच से गुज़र जाती हैं और केवल तब दिखाई देती हैं जब कोई किसी अलग रिपोर्ट के मुक़ाबले कुल की तुलना करता है।",
          "recommendation": "क्लॉज़ों के अलग-अलग काम करने के बजाय कैसे एक-दूसरे के साथ इंटरैक्ट करते हैं पर ध्यान दें: LEFT JOIN के दाहिने-हाथ के कॉलम पर WHERE फ़िल्टरिंग, एकत्रीकरण से पहले एक-से-कई जॉइन्स से पंक्ति गुणन, और क्यों NOT IN NULLs की मौजूदगी में टूट जाता है (EXISTS आमतौर पर नहीं करता)। फिर HAVING बनाम WHERE, क्योंकि उस विभाजन से लोग गलत हो जाते हैं जो दोनों क्लॉज़ को अलग से जानते हैं।"
        },
        "advanced": {
          "name": "उन्नत",
          "desc": "यह वह स्तर है जो अधिकांश नौकरी पोस्टिंग \"मजबूत SQL\" से माने। आप एक बहु-जॉइन क्वेरी को पढ़ते हैं और इसकी पंक्ति संख्या चलाने से पहले भविष्यवाणी कर सकते हैं, आप जानते हैं कि एक परिणाम सेट क्यों बदला, न केवल यह कि वह बदला, और आप एक CTE या विंडो फंक्शन तक पहुँचते हैं बजाय एक नेस्टेड सबक्वेरी के जब यह स्पष्ट उपकरण हो। जो यह बैंड को शीर्ष से अलग करता है वह काम का रक्षात्मक पक्ष है: जानना कि किस रैंकिंग फंक्शन का उपयोग करना है जब टाई महत्वपूर्ण हो, एक लेन-देन एक समवर्ती सत्र से क्या अलग करता है, और एक लापता ON DELETE नियम डेटाबेस स्तर पर वास्तव में क्या करता है।",
          "recommendation": "उन हिस्सों में धकेलें जो डेटा की रक्षा करते हैं जो दूसरे लोग भी छूते हैं: RANK, DENSE_RANK और ROW_NUMBER के बीच का अंतर जब टाई मायने रखते हैं, COMMIT वास्तव में क्या दृश्यमान बनाता है और किसको, और DELETE पर विदेशी कुंजी व्यवहार। The Index न्यूज़लेटर या SQL for Devs के विंडो फंक्शन्स और लेन-देन अलगाववाद पर गहन विश्लेषण अगला अच्छा पड़ाव दोनों के लिए है।"
        },
        "expert": {
          "name": "विशेषज्ञ",
          "desc": "आपने हर खंड में शीर्ष पर स्कोर किया — फ़िल्टरिंग और NULL शब्दार्थ, जॉइन्स और सेट ऑपरेशन्स, एकत्रीकरण और सबक्वेरीज़, और विंडो फंक्शन्स, CTEs और बाधाएँ। व्यावहारिक रूप से, इसका मतलब है आप एक अजनबी की बहु-जॉइन रिपोर्ट क्वेरी ले सकते हैं और समझा सकते हैं कि क्यों वह पंक्ति गणना वापस करती है, न केवल यह कि सिंटेक्स क्या कहता है, जो कठिन और अधिक मूल्यवान कौशल है। इस स्तर पर क्वेरी भाषा शायद ही कभी सीमित करने वाला कारक होता है; सीमा आमतौर पर स्कीमा डिज़ाइन या इसके अंदर डेटा का आकार होती है।",
          "recommendation": "अब निष्पादन योजनाओं और डिज़ाइन में वापसी होती है: EXPLAIN आउटपुट पढ़ना यह मानने से पहले कि एक क्वेरी धीमी है, अनुक्रमण रणनीति एक मुक्त जीत के बजाय लिखने की लागत के विरुद्ध व्यापार के रूप में, और सामान्यीकरण निर्णय जो एक स्कीमा बढ़ने के साथ पकड़ में आते हैं। यदि आप एक भूमिका के लिए स्क्रीन किए जा रहे हैं, तो एक क्वेरी बग का वर्णन करें जैसे जॉइन फैन-आउट या NOT IN/NULL जाल जो आपने उत्पादन में पाया था, न कि SQL सुविधाओं के नाम — यह तर्क प्रदर्शित करता है, केवल शब्दावली नहीं।"
        }
      },
      "questions": [
        {
          "question": "एक टेबल में एक nullable कॉलम age है। आप `SELECT * FROM users WHERE age = NULL` चलाते हैं। यह कितनी पंक्तियाँ रिटर्न करता है, भले ही कई पंक्तियों में age NULL सेट हो?",
          "options": [
            {
              "icon": "",
              "label": "हर पंक्ति जहाँ age NULL है, क्योंकि = NULL को किसी भी अन्य मान की तरह मिलाता है"
            },
            {
              "icon": "",
              "label": "शून्य — कुछ भी NULL से = से तुलना करना कभी TRUE नहीं देता, केवल UNKNOWN; IS NULL की जरूरत होती है"
            },
            {
              "icon": "",
              "label": "एक सिंटेक्स त्रुटि — NULL = के दाहिने पक्ष पर दिखाई नहीं दे सकता"
            },
            {
              "icon": "",
              "label": "टेबल की हर पंक्ति, क्योंकि NULL तुलना डिफ़ॉल्ट रूप से TRUE हो जाती है"
            }
          ]
        },
        {
          "question": "आप `SELECT DISTINCT department, role FROM employees` चलाते हैं। DISTINCT डुप्लिकेट किसके को हटाता है?",
          "options": [
            {
              "icon": "",
              "label": "विभाग और भूमिका का संयोजन एक साथ — एक पंक्ति केवल तभी हटाई जाती है यदि दोनों कॉलम एक और पंक्ति से बिल्कुल मेल खाएँ"
            },
            {
              "icon": "",
              "label": "केवल डुप्लिकेट विभाग मान, हर भूमिका को रखते हुए"
            },
            {
              "icon": "",
              "label": "केवल डुप्लिकेट भूमिका मान, हर विभाग को रखते हुए"
            },
            {
              "icon": "",
              "label": "कुछ नहीं — DISTINCT केवल एक कॉलम के साथ काम करता है"
            }
          ]
        },
        {
          "question": "एक कॉलम नाम को फ़िल्टर किया जाता है `WHERE name LIKE 'A_'` के साथ। इनमें से कौन से मान मिलते हैं: 'A', 'Al', 'Ana', 'Ally'?",
          "options": [
            {
              "icon": "",
              "label": "'A' — अंडरस्कोर वैकल्पिक है और शून्य या अधिक वर्णों से मिलता है"
            },
            {
              "icon": "",
              "label": "'Al' — अंडरस्कोर बिल्कुल एक वर्ण मिलाता है, इसलिए LIKE 'A_' A से शुरू होने वाली कोई भी दो-वर्ण स्ट्रिंग मिलाता है"
            },
            {
              "icon": "",
              "label": "'Ana' और 'Ally' — अंडरस्कोर किसी भी संख्या में अनुगामी वर्णों से मिलता है"
            },
            {
              "icon": "",
              "label": "सभी चार मान मिलते हैं, क्योंकि LIKE लंबाई को अनदेखा करता है"
            }
          ]
        },
        {
          "question": "एक price कॉलम को फ़िल्टर किया जाता है `WHERE price BETWEEN 10 AND 20` के साथ। क्या price बिल्कुल 10 या बिल्कुल 20 वाली पंक्तियों को शामिल किया जाता है?",
          "options": [
            {
              "icon": "",
              "label": "नहीं — BETWEEN दोनों अंतिम बिंदुओं को बाहर करता है"
            },
            {
              "icon": "",
              "label": "हाँ — BETWEEN दोनों सिरों पर समावेशी है, `price >= 10 AND price <= 20` के बराबर"
            },
            {
              "icon": "",
              "label": "केवल price = 10 को शामिल किया जाता है; ऊपरी सीमा बहिष्कृत है"
            },
            {
              "icon": "",
              "label": "केवल price = 20 को शामिल किया जाता है; निचली सीमा बहिष्कृत है"
            }
          ]
        },
        {
          "question": "एक टेबल orders में 10 पंक्तियाँ हैं, और उनमें से 3 में shipped_date NULL है। `SELECT COUNT(*) FROM orders` क्या रिटर्न करता है, और `SELECT COUNT(shipped_date) FROM orders` क्या रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "10, फिर 10 — COUNT हमेशा NULLs की परवाह किए बिना पंक्तियों को गिनता है"
            },
            {
              "icon": "",
              "label": "7, फिर 7 — दोनों रूप NULL पंक्तियों को छोड़ देते हैं"
            },
            {
              "icon": "",
              "label": "10, फिर 7 — COUNT(*) हर पंक्ति को गिनता है, COUNT(column) केवल वह पंक्तियाँ गिनता है जहाँ वह कॉलम NULL नहीं है"
            },
            {
              "icon": "",
              "label": "10, फिर 3 — COUNT(column) केवल NULL मानों को गिनता है"
            }
          ]
        },
        {
          "question": "आप `SELECT name, salary FROM employees ORDER BY 2 DESC` चलाते हैं। 2 किसको संदर्भित करता है?",
          "options": [
            {
              "icon": "",
              "label": "एक सिंटेक्स त्रुटि — ORDER BY केवल कॉलम नामों को स्वीकार करता है, संख्याओं को नहीं"
            },
            {
              "icon": "",
              "label": "परिणाम की दूसरी पंक्ति"
            },
            {
              "icon": "",
              "label": "एक शाब्दिक मान 2, एक टाइब्रेकर के रूप में उपयोग किया"
            },
            {
              "icon": "",
              "label": "SELECT सूची में दूसरा कॉलम, salary — ORDER BY एक शॉर्टहैंड के रूप से कॉलम की स्थिति संख्या स्वीकार करता है"
            }
          ]
        },
        {
          "question": "मानक SQL में, 'Ana' || ' ' || 'Lee' किसका मूल्यांकन करता है?",
          "options": [
            {
              "icon": "",
              "label": "एक सिंटेक्स त्रुटि — SQL का कोई संयोजन ऑपरेटर नहीं है"
            },
            {
              "icon": "",
              "label": "3 — || एक बूलियन OR के रूप में माना जाता है और एक गणना रिटर्न करता है"
            },
            {
              "icon": "",
              "label": "'AnaLee' — || स्पेस को संरक्षित किए बिना संयोजन करता है"
            },
            {
              "icon": "",
              "label": "'Ana Lee' — || मानक SQL स्ट्रिंग संयोजन ऑपरेटर है"
            }
          ]
        },
        {
          "question": "इनमें से कौन सा `WHERE status IN ('open', 'pending', 'review')` के बिल्कुल बराबर है?",
          "options": [
            {
              "icon": "",
              "label": "`WHERE status = 'open' AND status = 'pending' AND status = 'review'`"
            },
            {
              "icon": "",
              "label": "`WHERE status != 'open' OR status != 'pending' OR status != 'review'`"
            },
            {
              "icon": "",
              "label": "`WHERE status = 'open' OR status = 'pending' OR status = 'review'`"
            },
            {
              "icon": "",
              "label": "`WHERE status LIKE 'open,pending,review'`"
            }
          ]
        },
        {
          "question": "customers की 100 पंक्तियाँ हैं; उनमें से 20 कभी कोई ऑर्डर नहीं दिया। आप `SELECT c.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id` चलाते हैं। क्या बिना ऑर्डर वाले 20 customers परिणाम में दिखाई देते हैं?",
          "options": [
            {
              "icon": "",
              "label": "हाँ, एक बार प्रत्येक, o.id को NULL के रूप में दिखाया गया"
            },
            {
              "icon": "",
              "label": "हाँ, लेकिन केवल यदि वे एक WHERE क्लॉज़ में भी दिखाई दें"
            },
            {
              "icon": "",
              "label": "नहीं — INNER JOIN केवल वह पंक्तियाँ रिटर्न करता है जिनके दोनों टेबल में एक मेल हो, इसलिए शून्य ऑर्डर वाले customers पूरी तरह हटा दिए जाते हैं"
            },
            {
              "icon": "",
              "label": "हाँ, लेकिन orders में हर कॉलम के अनुसार डुप्लिकेट किया गया"
            }
          ]
        },
        {
          "question": "आप हर customer को चाहते हैं, चाहे उनके पास ऑर्डर हों या न हों, इसलिए आप `SELECT c.id, o.total FROM customers c LEFT JOIN orders o ON c.id = o.customer_id WHERE o.total > 100` लिखते हैं। क्या यह अभी भी शून्य ऑर्डर वाले customers को रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "नहीं — WHERE क्लॉज़ में o.total पर फ़िल्टरिंग LEFT JOIN द्वारा अमेल के लिए उत्पादित NULL पंक्तियों को हटा देती है, इसलिए यह एक INNER JOIN की तरह व्यवहार करता है"
            },
            {
              "icon": "",
              "label": "हाँ — LEFT JOIN हमेशा customers से हर पंक्ति को संरक्षित करता है, चाहे कुछ भी आए"
            },
            {
              "icon": "",
              "label": "हाँ, o.total को शून्य ऑर्डर वाले customers के लिए 0 के रूप में दिखाया गया"
            },
            {
              "icon": "",
              "label": "नहीं — LEFT JOIN चुपचाप एक RIGHT JOIN में खुद को परिवर्तित करता है जब कोई WHERE क्लॉज़ जोड़ा जाता है"
            }
          ]
        },
        {
          "question": "एक employees टेबल में एक id कॉलम और एक manager_id कॉलम है जो किसी अन्य पंक्ति की id की ओर इशारा करता है। हर employee को उनके manager के नाम के बगल में सूचीबद्ध करने के लिए, आप टेबल को अपने आप से जॉइन करते हैं: `SELECT e.name, m.name FROM employees e JOIN employees m ON e.manager_id = m.id`. यह पैटर्न क्या कहलाता है?",
          "options": [
            {
              "icon": "",
              "label": "एक cross join — हर employee को हर manager के साथ मिलाया जाता है"
            },
            {
              "icon": "",
              "label": "एक recursive join — यह पूरी प्रबंधन श्रृंखला को लाता है"
            },
            {
              "icon": "",
              "label": "एक self-join — एक ही टेबल को दो अलग अलियास का उपयोग करके अपने आप में जॉइन किया जाता है"
            },
            {
              "icon": "",
              "label": "यह अमान्य SQL है — एक टेबल को अपने आप से जॉइन नहीं किया जा सकता"
            }
          ]
        },
        {
          "question": "दो SELECT क्वेरीज़ एक ही कॉलम के साथ UNION से मिलाई जाती हैं। यदि दोनों क्वेरीज़ एक समान पंक्ति रिटर्न करें, तो अंतिम परिणाम में उस पंक्ति की कितनी प्रतियाँ दिखाई देती हैं?",
          "options": [
            {
              "icon": "",
              "label": "एक — UNION संयुक्त परिणाम से डुप्लिकेट पंक्तियों को हटाता है; UNION ALL दोनों प्रतियों को रखेगा"
            },
            {
              "icon": "",
              "label": "दो — UNION दोनों क्वेरीज़ की हर पंक्ति को रखता है"
            },
            {
              "icon": "",
              "label": "शून्य — UNION किसी भी पंक्ति को हटाता है जो दोनों क्वेरीज़ में दिखाई देती है"
            },
            {
              "icon": "",
              "label": "यह इस बात पर निर्भर करता है कि किस क्वेरी ने पंक्ति को पहले सूचीबद्ध किया"
            }
          ]
        },
        {
          "question": "टेबल sizes में 3 पंक्तियाँ हैं और colors में 4 पंक्तियाँ हैं। `SELECT * FROM sizes CROSS JOIN colors` कितनी पंक्तियाँ रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "7 — CROSS JOIN पंक्ति गणना को जोड़ देता है"
            },
            {
              "icon": "",
              "label": "12 — एक CROSS JOIN दोनों टेबल की पंक्तियों का हर संभावित संयोजन रिटर्न करता है (3 x 4)"
            },
            {
              "icon": "",
              "label": "3 — CROSS JOIN पहली टेबल की प्रत्येक पंक्ति के लिए एक पंक्ति रिटर्न करता है"
            },
            {
              "icon": "",
              "label": "0 — CROSS JOIN को एक ON शर्त की जरूरत होती है या यह कुछ नहीं रिटर्न करता"
            }
          ]
        },
        {
          "question": "orders में ऑर्डर #100 के लिए 1 पंक्ति है, और order_items में ऑर्डर #100 के लिए 3 पंक्तियाँ हैं (एक प्रति पंक्ति आइटम)। आप `SELECT o.id, o.total FROM orders o JOIN order_items i ON o.id = i.order_id WHERE o.id = 100` चलाते हैं। ऑर्डर #100 के लिए कितनी पंक्तियाँ वापस आती हैं?",
          "options": [
            {
              "icon": "",
              "label": "3 — जॉइन मिलान करने वाली हर order_items पंक्ति के लिए एक आउटपुट पंक्ति बनाता है, इसलिए ऑर्डर #100 की एक पंक्ति हर पंक्ति आइटम के लिए दोहराई जाती है"
            },
            {
              "icon": "",
              "label": "1 — orders में ऑर्डर #100 के लिए केवल एक पंक्ति है, इसलिए जॉइन ज़्यादा उत्पादन नहीं कर सकता"
            },
            {
              "icon": "",
              "label": "4 — ऑर्डर के लिए एक पंक्ति प्लस एक प्रति पंक्ति आइटम"
            },
            {
              "icon": "",
              "label": "0 — एक पंक्ति-टेबल को एक तीन-पंक्ति वाली टेबल में एक गैर-अद्वितीय कुंजी पर जॉइन करना विफल हो जाता है"
            }
          ]
        },
        {
          "question": "`SELECT c.name, o.id FROM customers c RIGHT JOIN orders o ON c.id = o.customer_id` इनमें से किसी के समान पंक्तियाँ रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "`SELECT c.name, o.id FROM customers c INNER JOIN orders o ON c.id = o.customer_id`"
            },
            {
              "icon": "",
              "label": "`SELECT c.name, o.id FROM orders o LEFT JOIN customers c ON c.id = o.customer_id` — टेबल ऑर्डर को स्वैप करना और RIGHT JOIN के बजाय LEFT JOIN का उपयोग करना बराबर है"
            },
            {
              "icon": "",
              "label": "`SELECT c.name, o.id FROM customers c LEFT JOIN orders o ON c.id = o.customer_id`"
            },
            {
              "icon": "",
              "label": "`SELECT c.name, o.id FROM orders o CROSS JOIN customers c`"
            }
          ]
        },
        {
          "question": "मानक SQL में, आप `SELECT department, name, AVG(salary) FROM employees GROUP BY department` चलाते हैं। क्या यह एक मान्य क्वेरी है?",
          "options": [
            {
              "icon": "",
              "label": "हाँ — GROUP BY को केवल department की जरूरत है क्योंकि वह पहला सूचीबद्ध है"
            },
            {
              "icon": "",
              "label": "नहीं — name को चुना गया है लेकिन न तो एकत्रीकृत किया गया है और न ही GROUP BY में सूचीबद्ध है, और मानक SQL को हर गैर-एकत्रीकृत चुने गए कॉलम को GROUP BY क्लॉज़ में दिखाई देने की आवश्यकता है"
            },
            {
              "icon": "",
              "label": "हाँ — SQL स्वचालित रूप से विभाग के अनुसार एक मनमाना नाम चुन लेता है"
            },
            {
              "icon": "",
              "label": "नहीं — AVG() को GROUP BY के साथ एक ही क्वेरी में संयोजित नहीं किया जा सकता"
            }
          ]
        },
        {
          "question": "आप विभाग चाहते हैं जिनका औसत वेतन 80000 से अधिक है। कौन सा क्लॉज़ एकत्रीकृत मान जैसे AVG(salary) पर समूहन के बाद फ़िल्टर करता है — WHERE या HAVING?",
          "options": [
            {
              "icon": "",
              "label": "WHERE — HAVING केवल UNION क्वेरीज़ के साथ उपयोग किया जाता है"
            },
            {
              "icon": "",
              "label": "कोई भी — दोनों एकत्रीकरण फंक्शन्स के साथ समान रूप से काम करते हैं"
            },
            {
              "icon": "",
              "label": "न ही — एकत्रीकरण फ़िल्टरिंग के लिए एक सबक्वेरी की जरूरत होती है"
            },
            {
              "icon": "",
              "label": "HAVING — WHERE समूहन से पहले अलग पंक्तियों को फ़िल्टर करता है, HAVING एकत्रीकरण के बाद समूह को फ़िल्टर करता है"
            }
          ]
        },
        {
          "question": "आप `SELECT salary * 1.1 AS new_salary FROM employees WHERE new_salary > 50000` लिखते हैं। क्या यह चलता है?",
          "options": [
            {
              "icon": "",
              "label": "हाँ — SELECT में परिभाषित अलियास हमेशा एक ही क्वेरी में WHERE के लिए उपलब्ध होते हैं"
            },
            {
              "icon": "",
              "label": "हाँ, लेकिन केवल संख्यात्मक अलियास के लिए"
            },
            {
              "icon": "",
              "label": "नहीं — एक WHERE-फ़िल्टरित क्वेरी में AS की अनुमति नहीं है"
            },
            {
              "icon": "",
              "label": "नहीं — WHERE का मूल्यांकन SELECT द्वारा अलियास नाम new_salary को निर्दिष्ट करने से पहले किया जाता है, इसलिए अलियास अभी तक मौजूद नहीं है"
            }
          ]
        },
        {
          "question": "`SELECT name FROM employees e WHERE salary > (SELECT AVG(salary) FROM employees WHERE department = e.department)`. यह क्यों एक सहसंबद्ध सबक्वेरी कहलाता है?",
          "options": [
            {
              "icon": "",
              "label": "क्योंकि यह एक WHERE क्लॉज़ के बजाय एक JOIN का उपयोग करता है"
            },
            {
              "icon": "",
              "label": "आंतरिक सबक्वेरी बाहरी क्वेरी से e.department को संदर्भित करता है, इसलिए इसे बाहरी क्वेरी विचार करने वाली हर पंक्ति के लिए पुनः मूल्यांकन किया जाना चाहिए"
            },
            {
              "icon": "",
              "label": "क्योंकि यह एक से अधिक कॉलम रिटर्न करता है"
            },
            {
              "icon": "",
              "label": "क्योंकि यह बाहरी क्वेरी शुरू होने से पहले बिल्कुल एक बार चलता है"
            }
          ]
        },
        {
          "question": "एक सबक्वेरी `SELECT manager_id FROM employees` कुछ NULL मान रिटर्न करता है, असली ids के साथ। आप `SELECT name FROM employees WHERE id NOT IN (SELECT manager_id FROM employees)` चलाते हैं। क्या होता है?",
          "options": [
            {
              "icon": "",
              "label": "यह हर employee को रिटर्न करता है जो manager नहीं है, NULLs को अनदेखा करते हुए"
            },
            {
              "icon": "",
              "label": "यह शून्य पंक्तियाँ रिटर्न करता है — NOT IN सूची में एक एकल NULL हर तुलना को UNKNOWN बनाता है, इसलिए कोई भी पंक्ति शर्त को पूरा नहीं कर सकती"
            },
            {
              "icon": "",
              "label": "यह एक त्रुटि उठाता है क्योंकि NOT IN को सबक्वेरीज़ के साथ उपयोग नहीं किया जा सकता"
            },
            {
              "icon": "",
              "label": "यह हर employee को रिटर्न करता है, क्योंकि NULL को एक वाइल्डकार्ड के रूप में माना जाता है"
            }
          ]
        },
        {
          "question": "`SELECT name FROM customers c WHERE EXISTS (SELECT 1 FROM orders o WHERE o.customer_id = c.id)`. यह क्या रिटर्न करता है?",
          "options": [
            {
              "icon": "",
              "label": "हर customer जिसके पास orders में कम से कम एक पंक्ति है — EXISTS केवल जाँचता है कि क्या सबक्वेरी कोई पंक्तियाँ रिटर्न करती हैं, उनमें क्या मान हैं, नहीं"
            },
            {
              "icon": "",
              "label": "हर customer, क्योंकि `SELECT 1` हमेशा true रिटर्न करता है"
            },
            {
              "icon": "",
              "label": "एक त्रुटि, क्योंकि सबक्वेरी कॉलम नाम के बजाय एक संख्या को चुनता है"
            },
            {
              "icon": "",
              "label": "केवल customers जिनके पास बिल्कुल एक order है"
            }
          ]
        },
        {
          "question": "आप `SELECT name, (SELECT order_id FROM orders WHERE customer_id = c.id) AS last_order FROM customers c` लिखते हैं, और एक दिए गए customer के पास orders में 3 पंक्तियाँ हैं। जब यह क्वेरी चलती है तो क्या होता है?",
          "options": [
            {
              "icon": "",
              "label": "यह पहली मिलान order_id रिटर्न करता है और बाकी दो को चुपचाप अनदेखा करता है"
            },
            {
              "icon": "",
              "label": "यह सभी तीनों order_ids की अल्पविराम-विभाजित सूची रिटर्न करता है"
            },
            {
              "icon": "",
              "label": "यह उस customer के लिए 3 पंक्तियाँ रिटर्न करता है, एक प्रति order"
            },
            {
              "icon": "",
              "label": "यह रनटाइम पर एक त्रुटि उठाता है — SELECT सूची में एक scalar सबक्वेरी को सबसे अधिक एक पंक्ति रिटर्न करनी चाहिए, और यह तीन रिटर्न करती है"
            }
          ]
        },
        {
          "question": "चार पंक्तियें उच्चतम स्कोर के लिए टाई करती हैं। RANK() ORDER BY score DESC का उपयोग करते हुए, सभी चारों को rank 1 मिलता है। अगली पंक्ति को कौन सा rank मिलता है?",
          "options": [
            {
              "icon": "",
              "label": "5 — RANK() टाई की गई पंक्तियों की संख्या के बराबर एक अंतर छोड़ जाता है"
            },
            {
              "icon": "",
              "label": "2 — RANK() हमेशा किसी भी टाई के बाद ठीक एक से बढ़ता है"
            },
            {
              "icon": "",
              "label": "1 — हर बाद की पंक्ति को भी rank 1 मिलता है"
            },
            {
              "icon": "",
              "label": "4 — RANK() टाई की संख्या से गिनती को पुनः आरंभ करता है"
            }
          ]
        },
        {
          "question": "चार पंक्तियें उच्चतम स्कोर के लिए टाई करती हैं। DENSE_RANK() ORDER BY score DESC का उपयोग करते हुए, सभी चारों को rank 1 मिलता है। अगली पंक्ति को कौन सा rank मिलता है?",
          "options": [
            {
              "icon": "",
              "label": "5 — DENSE_RANK() RANK() की तरह ही व्यवहार करता है"
            },
            {
              "icon": "",
              "label": "1 — DENSE_RANK() हर बाद की पंक्ति को वही rank असाइन करता है"
            },
            {
              "icon": "",
              "label": "2 — DENSE_RANK() कभी अंतर नहीं छोड़ता, इसलिए अगला अलग मान हमेशा अगली क्रमागत rank पाता है"
            },
            {
              "icon": "",
              "label": "3 — DENSE_RANK() एक rank को प्रति टाई समूह छोड़ देता है"
            }
          ]
        },
        {
          "question": "एक क्वेरी में `SUM(amount) OVER (PARTITION BY region ORDER BY amount)` जोड़ा जाता है। यहाँ PARTITION BY region क्या करता है?",
          "options": [
            {
              "icon": "",
              "label": "यह पूरे परिणाम सेट में जमा करने के बजाय हर क्षेत्र के लिए अलग से रनिंग सम को पुनः शुरू करता है"
            },
            {
              "icon": "",
              "label": "यह परिणामों को एक ही क्षेत्र में फ़िल्टर करता है"
            },
            {
              "icon": "",
              "label": "यह GROUP BY की तरह पंक्तियों को समूहन और ढहाता है"
            },
            {
              "icon": "",
              "label": "यह क्षेत्रों को वर्णक्रमानुसार योग करने से पहले सॉर्ट करता है"
            }
          ]
        },
        {
          "question": "`ROW_NUMBER() OVER (ORDER BY score DESC)` पाँच पंक्तियों पर लागू किया जाता है, जिनमें से दो स्कोर में बिल्कुल टाई होते हैं। क्या दो पंक्तियों को कभी एक ही पंक्ति संख्या प्राप्त हो सकती है?",
          "options": [
            {
              "icon": "",
              "label": "हाँ — टाई की गई पंक्तियों को हमेशा एक ही पंक्ति संख्या मिलती है"
            },
            {
              "icon": "",
              "label": "केवल यदि PARTITION BY भी उपयोग किया जाता है"
            },
            {
              "icon": "",
              "label": "यह इस बात पर निर्भर करता है कि टाई पहली या अंतिम स्थिति में है या नहीं"
            },
            {
              "icon": "",
              "label": "नहीं — ROW_NUMBER() हमेशा हर पंक्ति को एक अद्वितीय, सख्ती से बढ़ती पूर्णांक असाइन करता है, भले ही मान टाई हों"
            }
          ]
        },
        {
          "question": "`WITH high_earners AS (SELECT * FROM employees WHERE salary > 100000) SELECT department, COUNT(*) FROM high_earners GROUP BY department`. high_earners क्या है?",
          "options": [
            {
              "icon": "",
              "label": "एक सामान्य टेबल अभिव्यक्ति (CTE) — एक नाम दिया हुआ, अस्थायी परिणाम सेट जिसे बाकी क्वेरी एक टेबल की तरह संदर्भित कर सकती है"
            },
            {
              "icon": "",
              "label": "डेटाबेस में बनाया गया एक स्थायी टेबल"
            },
            {
              "icon": "",
              "label": "एक view जो क्वेरी खत्म होने के बाद बना रहता है"
            },
            {
              "icon": "",
              "label": "एक stored procedure जिसे अलग से कॉल किया जाना चाहिए"
            }
          ]
        },
        {
          "question": "एक कॉलम PRIMARY KEY के रूप में घोषित किया गया है। क्या आप एक पंक्ति डाल सकते हैं जहाँ वह कॉलम NULL है?",
          "options": [
            {
              "icon": "",
              "label": "हाँ — PRIMARY KEY केवल अद्वितीयता को लागू करता है, NULL-ness को नहीं"
            },
            {
              "icon": "",
              "label": "हाँ, लेकिन केवल एक NULL पंक्ति की अनुमति है, एक UNIQUE बाधा की तरह"
            },
            {
              "icon": "",
              "label": "नहीं — एक PRIMARY KEY कॉलम निहित रूप से NOT NULL है, इसलिए इसमें NULL डालना खारिज किया जाता है"
            },
            {
              "icon": "",
              "label": "यह इस बात पर निर्भर करता है कि क्या कॉलम में एक डिफ़ॉल्ट मान भी है"
            }
          ]
        },
        {
          "question": "एक खुले लेन-देन के अंदर, आप एक UPDATE चलाते हैं लेकिन अभी तक COMMIT नहीं चलाया है। दूसरे, अलग डेटाबेस कनेक्शन से, क्या वह update दृश्यमान है?",
          "options": [
            {
              "icon": "",
              "label": "हाँ — सभी कनेक्शन हर लिखने को तुरंत देखते हैं जब वह चलता है"
            },
            {
              "icon": "",
              "label": "हाँ, लेकिन केवल यदि दूसरा कनेक्शन भी एक लेन-देन खोले"
            },
            {
              "icon": "",
              "label": "यह केवल इस बात पर निर्भर करता है कि कौन सी टेबल को update किया गया था"
            },
            {
              "icon": "",
              "label": "नहीं — एक अप्रतिबद्ध परिवर्तन केवल उस लेन-देन के अंदर दृश्यमान है जो इसे बनाता है, जब तक COMMIT इसे टिकाऊ और दूसरों के लिए दृश्यमान नहीं बनाता है"
            }
          ]
        },
        {
          "question": "`products.category_id` में एक FOREIGN KEY बाधा है जो `categories.id` को संदर्भित करती है। आप categories से एक पंक्ति DELETE करने का प्रयास करते हैं जिसके लिए अभी भी products इसकी ओर इशारा कर रहे हैं, कोई ON DELETE नियम निर्दिष्ट नहीं है। क्या होता है?",
          "options": [
            {
              "icon": "",
              "label": "category पंक्ति हटा दी जाती है और मिलान करने वाली products.category_id मानों को स्वचालित रूप से NULL पर सेट किया जाता है"
            },
            {
              "icon": "",
              "label": "category पंक्ति हटा दी जाती है और हर product जो इसे संदर्भित करता है भी हटा दिया जाता है"
            },
            {
              "icon": "",
              "label": "DELETE खारिज कर दिया जाता है — डिफ़ॉल्ट विदेशी कुंजी व्यवहार एक संदर्भित पंक्ति को हटाने को अवरुद्ध करता है जबकि निर्भर पंक्तियें अभी भी इसकी ओर इशारा करती हैं"
            },
            {
              "icon": "",
              "label": "DELETE सफलतापूर्वक होता है शांति से, products की category_id को एक ऐसी category की ओर इशारा करते हुए छोड़ जाता है जो अब मौजूद नहीं है"
            }
          ]
        }
      ],
      "optionOrderVersion": "e0466e547cfd8a45"
    }
  }
}