जैसा कि आपने बताया, सच में . का एकमात्र तरीका पता है कि निष्पादन योजनाओं की तुलना करना है। वास्तव में, सबसे अच्छा तरीका होगा EXPLAIN ANALYZE . का उपयोग करना , ताकि यह वास्तव में क्वेरी को निष्पादित करे और परिणामों को अनुमानों के साथ आउटपुट में सम्मिलित करे, ताकि आप क्वेरी प्लानर बनाम वास्तविकता का बोध प्राप्त कर सकें।
हालांकि, सामान्य तौर पर, मैं इस तरह की स्थिति में क्या करूँगा शायद एक अस्थायी तालिका बनाना होगा क्लाइंट सबसेट के लिए और फिर JOIN कि orders . के लिए मेज़। आप वैकल्पिक रूप से WITH . का उपयोग कर सकते हैं सब कुछ एक प्रश्न में करने के बजाय।
तो, कुछ इस तरह:
CREATE TEMP TABLE tmp_clients AS
SELECT c.clientid
FROM clients c
WHERE c.city = 'New York'
ORDER BY c.clientid;
SELECT *
FROM orders AS o
JOIN tmp_clients AS c ON (o.clientid = c.clientid)
ORDER BY o.clientid;
इस तरह, tmp_clients इसमें केवल न्यूयॉर्क के क्लाइंट शामिल हैं -- ~5K पंक्तियाँ -- और यह वह तालिका है जिसे ऑर्डर तालिका से जोड़ा जाएगा।
आप आगे अनुकूलित करने के लिए, अस्थायी तालिका (क्लाइंटिड पर) पर एक अनुक्रमणिका बना सकते हैं और फिर ANALYZE इसे करने से पहले JOIN यह सुनिश्चित करने के लिए कि जॉइन पूरी तरह से इंडेक्स पर किया जाता है। आप सापेक्ष अंतर देखने के लिए प्रत्येक मामले में क्वेरी योजनाओं की जांच करना चाहेंगे (या बस इसे ध्यान में रखें यदि JOIN उतना तेज़ नहीं है जितना आप चाहेंगे)।
@posest की टिप्पणी का जवाब:
यह अस्थायी तालिकाओं . जैसा लगता है स्टैकिंग कर रहे हैं, जो मेमोरी फ़ुटप्रिंट को बढ़ाएगा, और, लंबे समय तक चलने वाले कनेक्शन के लिए, कार्यक्षमता एक मेमोरी लीक प्रतीत होती है।
उस स्थिति में, यह एक वास्तविक रिसाव नहीं होगा, हालांकि, अस्थायी तालिकाओं . के रूप में एक कनेक्शन के दायरे में हैं। वे स्वचालित रूप से गायब हो जाते हैं, लेकिन कनेक्शन समाप्त होने तक नहीं। हालाँकि, जब आप उनका काम पूरा कर लेंगे तो आप उन्हें तुरंत गायब कर सकते हैं। बस DROP तालिका के रूप में आप किसी अन्य के साथ एक बार उनके साथ कर लेंगे, और मुझे संदेह है कि आप फ़ंक्शन को कई बार कॉल करने में सक्षम होंगे - एक ही कनेक्शन पर - एक ही प्रकार की मोनोटोनिक मेमोरी पदचिह्न वृद्धि के बिना।
