SQL में Cartesian Product: एक व्यापक गाइड

Cartesian product SQL में एक बुनियादी अवधारणा है जो शक्तिशाली भी है और जटिल भी। इसे प्रभावी ढंग से उपयोग करना समझना आपकी डेटा प्रबंधन क्षमता को काफी बढ़ा सकता है। इस गाइड में, हम Cartesian products के सभी पहलुओं की पड़ताल करेंगे और व्यावहारिक अंतर्दृष्टि व उदाहरण देंगे। 

यदि आप SQL में नए हैं, तो एक मजबूत नींव बनाने के लिए हमारे Intermediate SQL कोर्स से शुरुआत करें। साथ ही, डाउनलोड योग्य SQL Basics Cheat Sheet एक उपयोगी संदर्भ है क्योंकि इसमें सबसे सामान्य SQL फ़ंक्शंस शामिल हैं।

Cartesian Product क्या है?

SQL में Cartesian product वह परिणाम है जिसमें एक टेबल की हर पंक्ति दूसरी टेबल की हर पंक्ति से संयोजित की जाती है। यह ऑपरेशन प्रायः CROSS JOIN से उत्पन्न होता है, जो दो टेबलों की पंक्तियों के सभी संभावित युग्मों वाला परिणाम-सेट बनाता है। यद्यपि यह शक्तिशाली है, बड़ी पंक्ति-संख्या वाली टेबलों पर यह बहुत बड़े परिणाम-सेट पैदा कर सकता है, इसलिए इसे सावधानी से उपयोग करना चाहिए। वास्तव में, कई डेवलपर संभवतः पहली बार Cartesian product को अनजाने में किसी जॉइन कंडीशन को छोड़ देने पर ही खोजते हैं—और अंततः एक विशाल परिणाम-सेट पा बैठते हैं।

गणितीय पृष्‍ठभूमि

गणित में, Cartesian product (A × B) वह समुच्चय है जिसमें समुच्चय A के प्रत्येक अवयव को समुच्चय B के प्रत्येक अवयव के साथ जोड़कर बनाए गए सभी संभव क्रमबद्ध युग्म शामिल होते हैं। SQL में इसका अर्थ है एक टेबल की हर पंक्ति को दूसरी टेबल की हर पंक्ति के साथ जोड़ना।

Cartesian product उदाहरण। चित्र: लेखक द्वारा।

SQL cross join

SQL में cross join ऑपरेशन पहले टेबल की हर पंक्ति को दूसरे टेबल की हर पंक्ति से जोड़कर Cartesian product बनाता है। परिणामस्वरूप, cross-join डेटा के सभी संभावित पंक्ति-संयोजन तैयार करता है। आइए SQL में cross join ऑपरेशन का एक उदाहरण देखते हैं।

मान लीजिए आपके पास दो टेबल हैं, Students और Courses:

Students टेबल

Courses टेबल

निम्न क्वेरी में, प्रत्येक छात्र को हर कोर्स के साथ जोड़ा गया है, जिसमें उनका ग्रेड और कठिनाई स्तर दिखता है।

-- Perform the cross join to list each student with every course
SELECT Students.name, Students.grade, Courses.course, Courses.level
FROM Students
CROSS JOIN Courses;संचालित द्वारा

SQL में cross join से उत्पन्न Cartesian product का उदाहरण। चित्र: लेखक द्वारा।

SQL में Cartesian Product कब उपयोग करें और कब नहीं

जब इसके व्यवहार को समझकर और उद्देश्यपूर्वक इस्तेमाल किया जाए, तो SQL में Cartesian product बहुत उपयोगी हो सकता है। आइए इसके उपयोग-प्रकरणों (और संभावित जोखिमों) को देखें।

उपयोग-प्रकरण

निम्न परिदृश्यों में Cartesian product का उपयोग उपयोगी हो सकता है:

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

संभावित जोखिम

यद्यपि कुछ परिदृश्यों में Cartesian product उपयोगी है, इसके कुछ जोखिम भी हैं, जिनमें शामिल हैं:

• प्रदर्शन संबंधी समस्याएँ: क्योंकि Cartesian product एक टेबल की पंक्तियों को दूसरी की पंक्तियों से गुणित करता है, परिणाम तेजी से बढ़ सकता है। बहुत बड़े डेटासेट पर यह धीमी क्वेरी, अत्यधिक मेमोरी उपयोग और यहाँ तक कि डेटाबेस क्रैश तक करा सकता है।
• अनपेक्षित डेटा-डुप्लीकेशन: यदि सावधानी से फ़िल्टर न किया जाए, तो Cartesian products ऐसे पंक्तियाँ बना सकते हैं जो विश्लेषण के लिए डुप्लीकेट या अप्रासंगिक लगें, जिससे डेटा-व्याख्या बिगड़ सकती है या गलत परिणाम मिल सकते हैं यदि डुप्लीकेट अपेक्षित न हों या ठीक से प्रबंधित न किए जाएँ।
• डीबगिंग में कठिनाई: जैसे कि किसी जॉइन कंडीशन को निर्दिष्ट करना भूलना—ऐसे अनपेक्षित Cartesian products inner या outer join के बजाय cross join करा देते हैं। यह अप्रत्याशित आउटपुट दे सकते हैं, जिनका स्रोत ढूँढना और सुधारना चुनौतीपूर्ण होता है।

Cartesian Product के वास्तविक अनुप्रयोग

यद्यपि संभावित जोखिमों के कारण Cartesian product का संयमित उपयोग होता है, यह उन परिदृश्यों में उपयोगी है जहाँ आपको डेटा-तत्वों के हर संभव युग्म को संयोजित करना होता है।

डेटा संयोजन परिदृश्य

Cartesian product सापेक्ष प्रदर्शन मीट्रिक्स निकालने, अनुकूलता का विश्लेषण करने, या रैंकिंग सिस्टम बनाने में उपयोगी है। जब आपको दो डेटासेट्स के सभी तत्वों की तुलना करनी हो, आप Cartesian product का प्रयोग कर प्रत्येक आइटम को हर दूसरे आइटम से जोड़ सकते हैं। 

उदाहरण के लिए, प्रत्येक कर्मचारी के प्रदर्शन की तुलना हर दूसरे कर्मचारी से करने हेतु, Cartesian product सभी संभावित कर्मचारी-युग्म बनाएगा:

-- Select two columns with employee names from the Employees table
SELECT 
    A.employee_name AS Employee1,
    B.employee_name AS Employee2
FROM Employees AS A
-- Cross join to create all possible pairs of employees
CROSS JOIN Employees AS B;संचालित द्वारा

ई-कॉमर्स एनालिटिक्स में भी उत्पाद-छूट के पूरे दायरे की पड़ताल करने के लिए Cartesian product महत्त्वपूर्ण है। मान लीजिए आपके पास Products और Discounts टेबल हैं, तो cross join सभी उत्पाद-छूट संयोजनों की सूची बना सकता है:

-- Select product names and discount types
SELECT 
    Products.product_name,
    Discounts.discount_type
FROM Products
-- Generate all product and discount combinations
CROSS JOIN Discounts;संचालित द्वारा

टेस्टिंग और वैलिडेशन

टेस्टिंग वातावरण में सभी संभावित पैरामीटर संयोजन बनाने के लिए Cartesian product सक्षम बनाता है, जो व्यापक परिदृश्य-परीक्षण के लिए आवश्यक है। उदाहरण के लिए, विभिन्न OS, डिवाइस और ब्राउज़र कॉन्फ़िगरेशन्स वाले सिस्टम का परीक्षण करते समय, cross-join यह सुनिश्चित करता है कि हर संभव कॉन्फ़िगरेशन परखा जाए।

-- Select combinations of operating systems, devices, and browsers
SELECT 
    OS.name AS OperatingSystem,
    Device.name AS Device,
    Browser.name AS Browser
FROM OperatingSystems AS OS
-- All combinations with devices
CROSS JOIN Devices AS Device
-- All combinations with browsers           
CROSS JOIN Browsers AS Browser;संचालित द्वारा

डेटा पूर्णता सुनिश्चित करने के लिए Cartesian product लुप्‍त रिकॉर्ड्स की पहचान करने में मदद कर सकता है। उदाहरण के लिए, दैनिक बिक्री डेटा का विश्लेषण करते समय और यह सत्यापित करते हुए कि प्रत्येक दिन हर उत्पाद के लिए डेटा मौजूद है, आप Products और Dates टेबल का Cartesian product बना सकते हैं। फिर वास्तविक बिक्री डेटा को लेफ्ट-जॉइन कर लापता तिथि-उत्पाद प्रविष्टियों की पहचान कर सकते हैं।

-- Select dates and products with no sales
SELECT 
    Dates.date,
    Products.product_name,
    Sales.sales_amount
FROM Dates
-- Create all date and product combinations
CROSS JOIN Products                          
-- Match sales by date and product
LEFT JOIN 
    Sales ON Dates.date = Sales.date 
           AND Products.product_name = Sales.product_name  
-- Filter for combinations with no sales
WHERE Sales.sales_amount IS NULL;संचालित द्वारा

प्रदर्शन पर कुछ विचार

क्योंकि Cartesian products दो टेबलों के बीच संभावित डेटा-संयोजन बनाते हैं, बड़ी टेबलों पर महत्वपूर्ण प्रदर्शन-समस्याएँ आ सकती हैं। क्वेरी अनुकूलन और बड़े डेटासेट प्रबंधन के लिए मैं निम्न तकनीकों का सुझाव देता/देती हूँ ताकि डेटाबेस प्रदर्शन सुधरे।

क्वेरी अनुकूलन

Cartesian products वाली क्वेरियों को दक्षतापूर्वक लिखने के लिए निम्न तरीकों पर विचार करें।

• जॉइन से पहले पंक्ति-संख्या सीमित करें: Cartesian product में शामिल पंक्तियों की संख्या घटाने के लिए cross join से पहले प्रत्येक टेबल पर फ़िल्टर लगाएँ। उदाहरण के लिए, WHERE क्लॉज़ का उपयोग कर प्रासंगिक मानदंडों से प्रत्येक टेबल को फ़िल्टर करें, जिससे परिणामी डेटासेट न्यूनतम हो।

• SELECT में विशिष्ट कॉलम चुनें: Cartesian product करते समय SELECT क्लॉज़ में केवल आवश्यक कॉलम ही चुनें ताकि मेमोरी उपयोग घटे और प्रदर्शन सुधरे। SELECT * से बचें क्योंकि यह सभी कॉलम लौटाता है और परिणाम-सेट भारी हो सकता है।

• शर्तें लगाकर Cross Join को Inner Join में बदलें: यदि केवल कुछ पंक्ति-संयोजन प्रासंगिक हों, तो ऐसी अतिरिक्त शर्तें जोड़ें जो INNER JOIN जैसी कार्य करें। इससे आउटपुट सीमित होगा और यह तय होगा कि किन पंक्तियों को जोड़ा जाना चाहिए।

• बैच प्रोसेसिंग: बड़े डेटासेट के लिए क्वेरियों को प्रबंधनीय हिस्सों में बाँटकर बैच प्रोसेस करें। यह मेमोरी ओवरफ्लो रोक सकता है और विशेषकर बड़ी टेबलों पर क्वेरी करते समय प्रतिक्रिया समय सुधार सकता है।

बड़े डेटासेट प्रबंधन

Cartesian products से बने बड़े डेटासेट को प्रबंधित करने के लिए निम्न तकनीकों का प्रयोग करें।

• इंडेक्सिंग: अक्सर जोड़ी जाने वाली कॉलम्स पर इंडेक्स जोड़ें ताकि बड़े टेबलों को फ़िल्टर या पेयर करते समय प्रदर्शन सुधरे। यद्यपि इंडेक्सिंग cross joins को सीधे तेज़ नहीं करती, लेकिन बाद में जब आप Cartesian product को अन्य टेबलों से फ़िल्टर या जॉइन करते हैं, तब यह पंक्तियों तक पहुँच तेज़ बनाती है।

• बड़ी टेबलों का विभाजन (Partitioning): Partitioning Cartesian product वाली क्वेरियों का प्रदर्शन सुधार सकता है। यह टेबलों को निर्दिष्ट कॉलम्स के आधार पर छोटे, प्रबंधनीय हिस्सों में बाँटता है, जिससे क्वेरी निष्पादन के दौरान केवल प्रासंगिक partitions पढ़े जाते हैं।

• परिणामी पंक्तियाँ सीमित करें: जब आपको केवल परीक्षण या सत्यापन हेतु नमूना चाहिए, तो LIMIT क्लॉज़ का उपयोग करें ताकि लौटाई जाने वाली पंक्तियों की संख्या सीमित रहे।

• मध्यवर्ती परिणामों के लिए अस्थायी टेबलों का उपयोग: यदि आपको एक Cartesian product को कई बार पुन: उपयोग करना है, तो मध्यवर्ती परिणामों को अस्थायी टेबलों में संग्रहीत करें ताकि पुनर्गणना घटे और अगली कार्रवाइयाँ तेज़ हों।

अन्य सहायक SQL ऑपरेशंस

जहाँ पूर्ण Cartesian product बनाना कुशल न हो, वहाँ वैकल्पिक तरीके मौजूद हैं। नीचे दिए गए तरीके आपको वांछित परिणाम पाने में मदद करते हैं, बिना डेटाबेस पर अत्यधिक बोझ डाले।

Inner और Outer Joins

INNER JOIN केवल वही पंक्तियाँ लौटाता है जिनमें दोनों टेबलों के निर्दिष्ट कॉलम्स में मेल मिलता है। यह तकनीक परिणाम को प्रासंगिक संयोजनों तक सीमित करती है और Cartesian product से आने वाली बहु-पंक्तियों से बचाती है। जब आपको केवल वे पंक्तियाँ चाहिए जो दोनों टेबलों में विशिष्ट मानदंड पूरा करती हों, तब inner join उपयुक्त है। 

नीचे के उदाहरण में, INNER JOIN केवल उन्हीं उत्पादों और छूटों को लौटाता है जो एक ही श्रेणी साझा करते हैं।

-- Select products and corresponding discounts by category
SELECT 
    A.product_name,
    B.discount_type
FROM Products AS A
-- Match products and discounts by category
INNER JOIN Discounts AS B ON A.category_id = B.category_id;संचालित द्वारा

Outer join (LEFT JOIN, RIGHT JOIN, और FULL JOIN) एक या दोनों टेबलों से मेल खाती और न मिलती पंक्तियाँ लौटाते हैं। जब आप एक टेबल की सभी पंक्तियाँ और दूसरी की केवल मेल खाती पंक्तियाँ पाना चाहते हैं—परंतु सभी संभावित संयोजन नहीं बनाना चाहते—तब यह तकनीक सहायक है। Outer join तब उपयुक्त है जब आप विश्लेषण हेतु बिना-मैच डेटा शामिल करना चाहते हैं, लेकिन पूर्ण Cartesian पेयरिंग नहीं।

नीचे की क्वेरी में LEFT JOIN सभी उत्पाद लौटाता है, जिनमें वे भी शामिल हैं जिन पर कोई संबंधित छूट नहीं है; ऐसे मामलों में NULL मान आते हैं।

-- Select products with corresponding discounts, (NULL if no matching discount)
SELECT 
    A.product_name,
    B.discount_type
FROM Products AS A
-- Match products with discounts by category
LEFT JOIN Discounts AS B ON A.category_id = B.category_id;  संचालित द्वारा

टेबल्स को कैसे जोड़ा जाए और कई टेबलों से डेटा कैसे निकाला जाए, यह और सीखने के लिए मैं DataCamp का Introduction to SQL Server कोर्स सुझाता/सुझाती हूँ।

Subqueries और CTEs

Subqueries आपको एक टेबल से विशिष्ट डेटा चुनने और उसे मुख्य क्वेरी में परिणाम फ़िल्टर करने के लिए उपयोग करने देती हैं। इससे केवल प्रासंगिक प्रविष्टियों तक डेटा सीमित कर अनावश्यक पंक्ति-संयोजन से बचा जा सकता है। जब आपको डेटा को पहले से फ़िल्टर करना हो या मुख्य क्वेरी में उपयोग हेतु विशिष्ट मान निकालने हों, तब subqueries उपयोगी हैं—बिना पूर्ण Cartesian join की आवश्यकता के।

यह subquery जॉइन से पहले 10 से अधिक मान वाली छूटों को फ़िल्टर करती है, जिससे प्रोसेस किए जाने वाले डेटा की मात्रा घटती है और अनावश्यक cross join से बचा जाता है।

-- Select products with discounts greater than 10 by category
SELECT 
    A.product_name,
    B.discount
FROM Products AS A
-- Subquery to filter discounts over 10
INNER JOIN 
    (SELECT discount, category_id   
     FROM Discounts 
     WHERE discount > 10) AS B
-- Match products with filtered discounts by category
ON A.category_id = B.category_id;   संचालित द्वारा

CTEs, या WITH क्लॉज़, जटिल क्वेरियों को चरणों में बाँटने देते हैं। यह तरीका जॉइन से पहले डेटा को फ़िल्टर या एग्रीगेट कर Cartesian products से बचने में मदद करता है। जब आप बहु-चरणीय क्वेरियों को सरल बनाना चाहते हैं—विशेषकर पूर्व-एग्रीगेशन या कई जॉइनों के साथ—पर पूर्ण Cartesian परिणाम से बचना चाहते हैं, तब CTEs उपयुक्त हैं।

नीचे की क्वेरी Common Table Expression (CTE) का उपयोग कर 10 से अधिक छूटों को फ़िल्टर करती है और फिर श्रेणी के आधार पर उत्पादों से जॉइन करती है।

-- Filter discounts and join with products by category
WITH FilteredDiscounts AS (
    SELECT discount, category_id
    FROM Discounts
    WHERE discount > 10
)
SELECT 
    A.product_name,
    FD.discount
FROM Products AS A
-- Join with filtered discounts by category
INNER JOIN 
    FilteredDiscounts AS FD ON A.category_id = FD.category_id;संचालित द्वारा

Cartesian Product के नवाचारी उपयोग

यद्यपि Cartesian product का व्यापक उपयोग बुनियादी SQL ऑपरेशनों में होता है, इसके पारंपरिक डेटाबेस उपयोग-प्रकरणों से परे भी अनुप्रयोग हैं। आइए देखें कि मशीन लर्निंग डेटा तैयारी और सिमुलेशन के लिए सिंथेटिक डेटासेट बनाने में इसे कैसे उपयोग किया जा सकता है।

मशीन लर्निंग डेटा तैयारी

मजबूत मॉडल प्रशिक्षित करने के लिए विविध और व्यापक डेटासेट महत्त्वपूर्ण होते हैं। Cartesian products फीचर-मूल्यों के सभी संभावित संयोजनों वाला पूर्ण डेटासेट बना सकते हैं, जिससे मॉडल विभिन्न परिदृश्यों से सीख सके। 

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

सिंथेटिक डेटा जेनरेशन

सिंथेटिक डेटा का उपयोग अक्सर व्यापक परिस्थितियों में सिस्टम की जाँच के लिए या गोपनीयता की रक्षा हेतु वास्तविक डेटा के स्थान पर किया जाता है। Cartesian products विविध सिंथेटिक डेटासेट बनाने में मदद करते हैं, जो सिमुलेशन्स से लेकर मशीन लर्निंग के लिए डेटा ऑग्मेंटेशन तक के अनुप्रयोगों में उपयोगी हैं।

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

नीचे SQL में, यूँ कहें कि, “कुछ भी नहीं” से सिंथेटिक डेटा बनाने और फिर CROSS JOIN से उसे बड़े डेटासेट में विस्तार देने का एक सरल उदाहरण दिया गया है। विचार यह है कि प्रत्येक छोटी टेबल हमारे टेस्ट डेटा के एक आयाम का प्रतिनिधित्व करती है और जब हम उन्हें cross-join करते हैं, तो सभी संभावित संयोजन मिलते हैं।

उदाहरण 1: कई आयामों का संयोजन

मान लीजिए आप बाज़ार की स्थिति, ब्याज दरें और ग्राहक प्रोफाइल्स के आधार पर अलग-अलग वित्तीय परिदृश्यों का सिमुलेशन करना चाहते हैं। हम प्रत्येक आयाम को Common Table Expression (CTE) या अस्थायी टेबल में लिटरल वैल्यूज़ से परिभाषित कर सकते हैं। फिर, CROSS JOIN उन्हें हर संभव संयोजन में मिला देता है:

WITH MarketConditions AS (
    SELECT 'Bull' AS condition
    UNION ALL
    SELECT 'Bear'
    UNION ALL
    SELECT 'Sideways'
),
InterestRates AS (
    SELECT 1.5 AS rate
    UNION ALL
    SELECT 2.0
    UNION ALL
    SELECT 3.25
),
CustomerProfiles AS (
    SELECT 'Younger' AS profile
    UNION ALL
    SELECT 'Mid-career'
    UNION ALL
    SELECT 'Retired'
)
SELECT 
    mc.condition,
    ir.rate,
    cp.profile
FROM 
    MarketConditions mc
CROSS JOIN 
    InterestRates ir
CROSS JOIN 
    CustomerProfiles cp;संचालित द्वारा

परिणाम-सेट में 3×3×3 = 27 पंक्तियाँ होंगी। प्रत्येक पंक्ति बाज़ार-स्थिति, ब्याज दर और ग्राहक प्रोफाइल का एक अद्वितीय संयोजन है।

Cartesian product का उपयोग कर सिंथेटिक डेटा जेनरेशन का उदाहरण। चित्र: लेखक द्वारा।

उदाहरण 2: सीक्वेंस या साधारण VALUES से पंक्तियाँ बनाना

एक और तकनीक यह है कि छोटी टेबलों को स्वयं से cross-join करके संख्याओं के रेंज या समय-अंतराल उत्पन्न किए जाएँ। इसका उपयोग त्वरित परीक्षण के लिए बड़े पैमाने पर सिंथेटिक पंक्तियाँ बनाने में किया जा सकता है। उदाहरण के लिए, नीचे दी गई क्वेरी 1 से 10 तक की संख्याएँ बनाती है।

WITH
Nums AS (
    SELECT 1 AS n
    UNION ALL SELECT 2
    UNION ALL SELECT 3
    UNION ALL SELECT 4
    UNION ALL SELECT 5
    UNION ALL SELECT 6
    UNION ALL SELECT 7
    UNION ALL SELECT 8
    UNION ALL SELECT 9
    UNION ALL SELECT 10
)
SELECT n
FROM Nums;संचालित द्वारा

सीक्वेंस का उपयोग कर पंक्तियाँ बनाने में Cartesian product का उपयोग। चित्र: लेखक द्वारा।

इसके बाद हम इसी 10-पंक्ति सेट को स्वयं से cross join कर 10×10=100 बना सकते हैं:

WITH
Nums AS (
    SELECT 1 AS n
    UNION ALL SELECT 2
    UNION ALL SELECT 3
    UNION ALL SELECT 4
    UNION ALL SELECT 5
    UNION ALL SELECT 6
    UNION ALL SELECT 7
    UNION ALL SELECT 8
    UNION ALL SELECT 9
    UNION ALL SELECT 10
)
SELECT A.n AS n1, B.n AS n2
FROM Nums A
CROSS JOIN Nums B
ORDER BY A.n, B.n;संचालित द्वारा

परिणाम में आपको 100 पंक्तियाँ मिलेंगी, प्रत्येक पंक्ति में मानों की एक जोड़ी (n1,n2) होगी। आप इस लॉजिक को सैकड़ों, हज़ारों, यहाँ तक कि लाखों पंक्तियों तक बढ़ा सकते हैं—हालाँकि प्रदर्शन और स्टोरेज का ध्यान रखें।

इन तरीकों—आयाम-परिभाषा हेतु CTEs (या VALUES क्लॉज़) और संयोजन के लिए CROSS JOIN—का उपयोग करके आप बिना मौजूदा टेबलों पर निर्भर हुए SQL में शीघ्रता से सिंथेटिक डेटासेट बना सकते हैं।

निष्कर्ष

SQL में Cartesian product को समझना डेटा प्रबंधन और विश्लेषण के लिए कई संभावनाएँ खोलता है। इस अवधारणा में निपुण होकर, आप जटिल डेटासेट्स के साथ बेहतर काम कर सकते हैं और अपनी डेटाबेस क्वेरियों का अनुकूलन कर सकते हैं। और उन्नत जानकारी के लिए हमारा SQL Server Fundamentals स्किल ट्रैक देखें और अपनी विशेषज्ञता बढ़ाएँ। 

आपके करियर दिशा-निर्देश के अनुसार, मैं सुझाव दूँगा/दूँगी कि आप या तो DataCamp का Associate Data Analyst in SQL करियर ट्रैक जॉइन करें ताकि डेटा एनालिस्ट बनने के लिए उद्योग-स्तरीय कौशल सीख सकें, या हमारा Associate Date Engineer in SQL करियर ट्रैक आज़माएँ ताकि डेटा इंजीनियर बन सकें।