क्या मैं एक ही क्वेरी के भीतर पेजेड पंक्तियों और कुल गणना को पुनर्प्राप्त कर सकता हूं?

Question

मेरे पास मेरे वेब ऐप में पेजिंग सक्षम एक मूल ग्रिड है। इस ग्रिड को डैपर का उपयोग करके वेब एपीआई के माध्यम से एसक्यूएल डेटा द्वारा पॉप्युलेट किया जा रहा है। मेरे एपीआई नियंत्रक में मैं दो अलग-अलग प्रश्नों को चला रहा हूं: पंक्तियों को निकालने के लिए एक (जो मेरी ग्रिड में दिखाया गया है), और एक रिकॉर्ड की कुल संख्या प्राप्त करने के लिए (मेरे पेजिंग नियंत्रण में दिखाने के लिए)। और यह काम करता है। हालांकि, मैं अपने प्रश्नों को अनुकूलित करने की कोशिश कर रहा हूं।

मेरा पहला प्रश्न है, जो पंक्तियों निकालता है, एक समय में केवल 50 पंक्तियों रिटर्न (OFFSET और FETCH का उपयोग कर, पेजिंग प्रदान करने के लिए:

SELECT DISTINCT T_INDEX.* 
FROM T_INDEX 
INNER JOIN T_INDEXCALLER ON T_INDEX.IndexId = T_INDEXCALLER.IndexId 
WHERE... --a fairly complex WHERE statement 
ORDER BY CallTime DESC 
OFFSET (@offset) ROWS FETCH NEXT 50 ROWS ONLY 

मेरी दूसरी क्वेरी सभी पंक्तियों की गिनती के अर्क, लेकिन एक ही टेबल, एक ही जुड़ जाता है, और एक ही WHERE खंड का उपयोग करता है:।

SELECT COUNT(DISTINCT T_INDEX.IndexId) 
FROM T_INDEX 
INNER JOIN T_INDEXCALLER ON T_INDEX.IndexId = T_INDEXCALLER.IndexId 
WHERE... --the same fairly complex WHERE statement 

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

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

SELECT * 
FROM (
    SELECT *, COUNT(*) OVER() AS cnt 
    FROM (
     SELECT DISTINCT T_INDEX.*, 
     FROM T_INDEX 
     INNER JOIN T_INDEXCALLER ON T_INDEX.IndexId = T_INDEXCALLER.IndexId 
     WHERE... --a fairly complex WHERE statement 
    ) AS t1) AS t2 
ORDER BY CallTime DESC 
OFFSET (@offset) ROWS FETCH NEXT 50 ROWS ONLY 

आप उपरोक्त क्वेरी क्या परिणाम सेट में एक विशिष्ट रिकॉर्ड निर्धारित करता है पर निर्भर करता है को आसान बनाने में कर सकते हैं:

Answer 1

आपने इस क्वेरी एक कोशिश दे सकते हैं।

Answer 2

SELECT DISTINCT T_INDEX.*, 
     (SELECT COUNT(DISTINCT T_INDEX.IndexId) FROM T_INDEX 
      INNER JOIN T_INDEXCALLER ON T_INDEX.IndexId = 
      T_INDEXCALLER.IndexIdAS) AS TotalCount 
FROM T_INDEX 
INNER JOIN T_INDEXCALLER ON T_INDEX.IndexId = T_INDEXCALLER.IndexId 
WHERE... --a fairly complex WHERE statement 
ORDER BY CallTime DESC 
OFFSET (@offset) ROWS FETCH NEXT 50 ROWS ONLY 

Answer 3

मैं एक और समाधान प्रस्तावित करता हूं: यह अंधा अनुकूलन मत करें।

आप बस भाग्यशाली होने की कोशिश कर रहे हैं - यह अनुचित है।

वे ऐसा नहीं करते हैं और इसलिए उन्हें व्यक्तिगत रूप से अनुकूलित किया जा सकता है। लेकिन यह अधिक महत्वपूर्ण है कि आपके दोनों प्रश्न 2.5 सेकेंड के लिए निष्पादित किए गए हैं जो 50 records या count all प्राप्त करने के सरल सरल और सरल कार्य के साथ प्रश्नों के लिए अजीब लगते हैं। मुझे पता है कि यह टेबल के आकार और आपके सर्वर के हार्डवेयर पर निर्भर करता है, लेकिन फिर भी।

तो मुझे लगता है कि आप दोनों को अनुकूलित कर सकते हैं और उन्हें एक में "विलय" करने की आवश्यकता नहीं होगी।

मैं पहले क्वेरी निष्पादन योजना को देखता हूं। मुझे पूरा यकीन है कि इसे बहुत तेज किया जा सकता है। तो, कृपया, अपने प्रश्न के लिए क्वेरी योजनाएं जोड़ें।

लेकिन फिर भी प्रश्नों के बिना मैं पहले से ही कुछ सवाल हैं:

• क्यों distinct?
• क्या आपके पास T_INDEX.CallTime पर एक सूचकांक है?