एक शाब्दिक रूप से पागल जवाब, लेकिन अगर आपके पास किसी तरह की प्रतिकृति प्रणाली स्थापित है (एक बिलियन पंक्तियों वाली प्रणाली के लिए, मुझे आशा है कि आप करते हैं), तो आप किसी न किसी अनुमानक (जैसे MAX(pk)) का उपयोग कर सकते हैं , उस मूल्य को दासों की संख्या से विभाजित कर सकते हैं आपके पास समानांतर में कई प्रश्न हैं।
अधिकांश भाग के लिए, आप सबसे अच्छी कुंजी (या प्राथमिक कुंजी जो मुझे लगता है) के आधार पर दासों के प्रश्नों का विभाजन करेंगे, इस तरह से (हम अपनी पंक्तियों / दासों के रूप में 250000000 का उपयोग करने जा रहे हैं):
-- First slave
SELECT COUNT(pk) FROM t WHERE pk < 250000000
-- Ith slave where 2 <= I <= N - 1
SELECT COUNT(pk) FROM t WHERE pk >= I*250000000 and pk < (I+1)*250000000
-- Last slave
SELECT COUNT(pk) FROM t WHERE pk > (N-1)*250000000
लेकिन आपको SQL की ही जरूरत है। क्या हलचल है। ठीक है, तो हम कहते हैं कि तुम एक sadomasochist हो। मास्टर (या निकटतम दास) पर आपको इसके लिए एक तालिका बनाने की आवश्यकता होगी:
CREATE TABLE counter_table (minpk integer, maxpk integer, cnt integer, slaveid integer)
इसलिए केवल आपके गुलामों में चयन होने के बजाय, आपको इसके लिए एक इंसर्ट करना होगा, जैसे:
INSERT INTO counter_table VALUES (I*25000000, (I+1)*250000000, (SELECT COUNT(pk) FROM ... ), @@SLAVE_ID)
आप गुलामों के साथ मास्टर की मेज पर लिखने के मुद्दों में भाग सकते हैं। आपको और अधिक दुख प्राप्त करने की आवश्यकता हो सकती है- मेरा मतलब है, रचनात्मक:
-- A table per slave!
INSERT INTO counter_table_slave_I VALUES (...)
आपको अंत में एक गुलाम होना चाहिए जो पहले ग्राफ के सापेक्ष प्रतिकृति ग्राफ के आधार पर पथ में अंतिम रूप से मौजूद है। उस दास के पास अब अन्य सभी काउंटर मूल्य होने चाहिए, और उसके अपने मूल्य होने चाहिए। लेकिन जब तक आप समाप्त कर लेते हैं, तब संभवतः पंक्तियाँ जुड़ जाती हैं, इसलिए आपको अपने काउंटर_टेबल में रिकॉर्ड किए गए अधिकतम pk और वर्तमान अधिकतम pk के लिए एक और क्षतिपूर्ति करनी होगी।
उस बिंदु पर, आपको कुल पंक्तियों का पता लगाने के लिए एक समग्र कार्य करना होगा, लेकिन यह आसान है क्योंकि आप इसे "आपके पास मौजूद दासों की संख्या और पंक्तियों को बदलने" पर सबसे अधिक चल रहे हैं।
यदि आप उस स्थिति में हैं जहां आपके पास दासों में अलग-अलग टेबल हैं, तो आप उन UNIONसभी पंक्तियों को प्राप्त कर सकते हैं जिनकी आपको आवश्यकता है।
SELECT SUM(cnt) FROM (
SELECT * FROM counter_table_slave_1
UNION
SELECT * FROM counter_table_slave_2
UNION
...
)
या आप जानते हैं, थोड़ा कम पागल हो और अपने डेटा को एक वितरित प्रसंस्करण प्रणाली में माइग्रेट करें, या शायद एक डेटा वेयरहाउसिंग समाधान का उपयोग करें (जो आपको भविष्य में भी भयानक डेटा क्रंचिंग देगा)।
ध्यान दें, यह इस बात पर निर्भर करता है कि आपकी प्रतिकृति कितनी अच्छी है। चूंकि प्राथमिक अड़चन सबसे अधिक संभावना होगी, अगर आपके पास भारी पड़ोसी शोर के साथ खराब भंडारण या खराब रूप से अलग किए गए डेटा स्टोर हैं, तो यह संभवतः आपको एक ही इंतजार करने की तुलना में धीमी गति से चलाएगा।SELECT COUNT(*) ...
लेकिन अगर आपके पास अच्छी प्रतिकृति है, तो आपका गति लाभ सीधे संख्या या दास से संबंधित होना चाहिए। वास्तव में, यदि काउंटिंग क्वेरी को अकेले चलाने में 10 मिनट लगते हैं, और आपके पास 8 दास हैं, तो आप अपना समय एक दो मिनट से भी कम समय में काट लेंगे। हो सकता है कि इस समाधान के विवरण को जानने के लिए एक घंटे का समय हो।
बेशक, आपको वास्तव में एक आश्चर्यजनक सटीक उत्तर नहीं मिलेगा क्योंकि यह वितरित समाधान समय का एक सा परिचय देता है जहां पंक्तियों को हटा दिया और डाला जा सकता है, लेकिन आप एक ही उदाहरण में पंक्तियों के वितरित लॉक को प्राप्त करने और एक सटीक गणना प्राप्त करने का प्रयास कर सकते हैं। समय में एक विशेष क्षण के लिए तालिका में पंक्तियों की।
वास्तव में, यह असंभव लगता है, क्योंकि आप मूल रूप से एक एसक्यूएल-केवल समाधान के साथ फंस गए हैं, और मुझे नहीं लगता है कि आपको कई दासों को तुरंत एक शार्प और लॉक किए गए क्वेरी को चलाने के लिए एक तंत्र प्रदान किया गया है। हो सकता है कि यदि आपके पास प्रतिकृति लॉग फ़ाइल का नियंत्रण था ... जिसका अर्थ है कि आप सचमुच इस उद्देश्य के लिए गुलाम बनेंगे, जो कि वैसे भी एक मशीन पर गिनती क्वेरी को चलाने की तुलना में कोई संदेह नहीं है।
तो वहाँ मेरे दो 2013 पैसा है।