चुनौती

मेरे ऐप (रिएक्ट स्प्रिंग बूट ओरेकल) में, बड़े डेटासेट से निपटने के कारण प्रसंस्करण समय निराशाजनक रूप से धीमा हो गया। मुझे सटीकता या पूर्णता से समझौता किए बिना प्रदर्शन में तेजी लाने के लिए एक समाधान की आवश्यकता थी।

समाधान: NTILE समानांतर प्रसंस्करण

एनटीआईएलई एक शक्तिशाली एसक्यूएल विंडो फ़ंक्शन है जिसे परिणाम सेट को लगभग समान आकार के टुकड़ों की एक निर्दिष्ट संख्या में विभाजित करने के लिए डिज़ाइन किया गया है, जिसे "टाइल्स" के रूप में जाना जाता है। प्रत्येक पंक्ति को क्रमित सेट में उसकी स्थिति के आधार पर एक विभाजन संख्या दी गई है।

NTILE का उपयोग करके, मैंने क्वेरी परिणामों को प्रबंधनीय भागों में विभाजित किया और इन विभाजनों को समानांतर में संसाधित किया। इस दृष्टिकोण ने मुझे एक साथ डेटा लाने और संभालने की अनुमति दी, जिससे प्रतीक्षा समय काफी कम हो गया।

इसे कैसे लागू किया जाए इसका एक व्यावहारिक उदाहरण यहां दिया गया है:

WITH PartitionedSales AS (
    SELECT 
        sales_id,
        sales_amount,
        sales_date,
        NTILE(2) OVER (ORDER BY sales_id) AS partition_number -- Assigns a partition number (1 or 2) to each row
    FROM 
        sales
    WHERE 
        sales_date BETWEEN '2023-01-01' AND '2023-12-31'
)
SELECT * 
FROM PartitionedSales
WHERE partition_number = :partitionNumber -- Replace :partitionNumber with the actual partition number (1 or 2)

उपरोक्त SQL स्निपेट में:

• NTILE(2) डेटा को दो बराबर भागों में विभाजित करता है जिसे sales_id के आधार पर क्रमबद्ध किया जाएगा।
• संबंधित विभाजन से डेटा लाने के लिए :partitionNumber को 1 या 2 से बदलें।

फ्रंटएंड पर, आप प्रत्येक विभाजन को कुशलतापूर्वक लाने के लिए समानांतर प्रसंस्करण का उपयोग कर सकते हैं:

async function fetchPartition(partitionNumber) {
    const response = await fetch('/api/sales?partition='   partitionNumber});
    return response.json();
}

async function fetchData() {
    try {
        const [partition1, partition2] = await Promise.all([
            fetchPartition(1), // Fetch the first partition
            fetchPartition(2)  // Fetch the second partition
        ]);

        // Combine and process results
        const combinedResults = [...partition1, ...partition2];
        processResults(combinedResults);
    } catch (error) {
        console.error('Error fetching data:', error);
    }
}

इस कोड में:

• fetchPartition एक विशिष्ट विभाजन के लिए डेटा पुनर्प्राप्त करता है।
• fetchData दोनों फ़ेच ऑपरेशन समानांतर में चलाता है और संयुक्त परिणामों को संसाधित करता है।

आप भी यह कैसे कर सकते हैं

• भारी क्वेरीज़ को पहचानें: उन क्वेरीज़ को ढूंढें जो आपके ऐप को धीमा कर रही हैं।
• NTILE लागू करें: क्वेरी परिणामों को छोटे भागों में विभाजित करने के लिए NTILE फ़ंक्शन का उपयोग करें।
• समानांतर प्रसंस्करण: समवर्ती कार्यों को संभालने के लिए अपने ऐप की क्षमता का लाभ उठाते हुए, इन छोटे प्रश्नों को समानांतर में निष्पादित करें।

यदि आप अपने डेटा-भारी अनुप्रयोगों में प्रदर्शन को बढ़ावा देना चाहते हैं, तो इस विधि को आज़माएं। यह आपके प्रश्नों को अधिक समय तक नहीं, बल्कि अधिक कठिन बनाने का एक स्मार्ट, प्रभावी तरीका है।

महत्वपूर्ण विचार

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