SQL सर्वर में, COUNT_BIG() फ़ंक्शन समूह में मिली वस्तुओं की संख्या देता है। आप इसका उपयोग यह पता लगाने के लिए कर सकते हैं कि किसी तालिका या परिणाम सेट में कितनी पंक्तियाँ हैं।
यह फ़ंक्शन COUNT() . के समान कार्य करता है समारोह। अंतर यह है कि COUNT() अपना परिणाम int . के रूप में देता है , जबकि COUNT_BIG() अपना परिणाम बिगिंट . के रूप में लौटाता है .
इसलिए COUNT_BIG() यदि आप अपने परिणाम सेट में पंक्तियों की एक बहुत बड़ी संख्या (यानी 2,147,483,647 से बड़ा) होने की अपेक्षा करते हैं, तो यह आपके काम आ सकता है।
सिंटैक्स
वाक्य रचना इस प्रकार है:
-- Aggregation Function Syntax
COUNT_BIG ( { [ [ ALL | DISTINCT ] expression ] | * } )
-- Analytic Function Syntax
COUNT_BIG ( [ ALL ] { expression | * } ) OVER ( [ ] )
ALL सभी मानों के लिए समग्र कार्य लागू करता है। यह डिफ़ॉल्ट मान है।
DISTINCT निर्दिष्ट करता है कि फ़ंक्शन अद्वितीय गैर-शून्य मानों की संख्या लौटाता है।
expression किसी भी प्रकार की अभिव्यक्ति है। एक्सप्रेशन में एग्रीगेट फ़ंक्शन और सबक्वेरी समर्थित नहीं हैं।
* निर्दिष्ट करता है कि सभी पंक्तियों को गिना और लौटाया जाना चाहिए, जिसमें डुप्लिकेट पंक्तियां और शून्य मान वाली पंक्तियां शामिल हैं। COUNT(*) कोई पैरामीटर नहीं लेता है और DISTINCT . के उपयोग का समर्थन नहीं करता है . इसके लिए अभिव्यक्ति . की भी आवश्यकता नहीं है पैरामीटर (क्योंकि यह किसी विशेष कॉलम के बारे में जानकारी का उपयोग नहीं करता है)।
OVER ( [ <partition_by_clause> ] FROM . द्वारा निर्मित परिणाम सेट को विभाजित करता है विभाजन में खंड जिस पर फ़ंक्शन लागू होता है। यदि निर्दिष्ट नहीं है, तो फ़ंक्शन क्वेरी परिणाम सेट की सभी पंक्तियों को एक समूह के रूप में मानता है।
उदाहरण 1 - मूल उपयोग
यह फ़ंक्शन कैसे काम करता है, इसका एक बुनियादी उदाहरण यहां दिया गया है:
USE WideWorldImportersDW; SELECT COUNT_BIG(*) AS 'Row Count' FROM Fact.[Order];
परिणाम:
+-------------+ | Row Count | |-------------| | 231412 | +-------------+
इस मामले में तथ्य में 231412 पंक्तियाँ हैं।[आदेश] टेबल।
इस मामले में, मैं COUNT() . का उपयोग कर सकता था उसी परिणाम को वापस करने के लिए, क्योंकि पंक्ति गणना int . के लिए काफी छोटी है संभालना।
उदाहरण 2 - एक बड़ा परिणाम सेट
COUNT_BIG() . का उपयोग करने का वास्तविक लाभ तब होता है जब आपका परिणाम सेट पिछले उदाहरण से बहुत बड़ा होता है।
उदाहरण:
SELECT COUNT_BIG(*) AS 'Row Count' FROM ReallyBigTable;
परिणाम:
+-----------------+ | Row Count | |-----------------| | 9147483648 | +-----------------+
इस मामले में, पंक्तियों की संख्या इतनी बड़ी है कि एक int इसे संभालने में सक्षम नहीं होगा। सौभाग्य से हम उपयोग कर सकते हैं COUNT_BIG() , क्योंकि यह अपना परिणाम बिगिंट . के रूप में देता है ।
अधिक उदाहरण
अधिक उदाहरणों के लिए, देखें कैसे COUNT() SQL सर्वर में काम करता है। वह लेख यहां सूचीबद्ध की तुलना में अधिक उदाहरण प्रदान करता है, जो सभी COUNT_BIG() पर भी लागू होते हैं ।
एक विकल्प:APPROX_COUNT_DISTINCT()
यदि आप बहुत बड़े डेटा सेट के साथ काम कर रहे हैं, तो आप APPROX_COUNT_DISTINCT() का उपयोग करने पर विचार कर सकते हैं COUNT_BIG(DISTINCT ) . के बजाय कुछ मामलों में।
APPROX_COUNT_DISTINCT() सटीक मान के बजाय अनुमानित मान देता है। हालांकि, इसे COUNT_BIG() . की तुलना में बहुत अधिक प्रतिक्रियाशील होने के लिए डिज़ाइन किया गया है , इसलिए यह उस समय के लिए उपयोगी हो सकता है जब सटीकता की तुलना में जवाबदेही अधिक महत्वपूर्ण होती है।
यह अद्वितीय, गैर-शून्य मानों को वापस करने के लिए डिज़ाइन किया गया है, इसलिए यह केवल उस समय के लिए प्रासंगिक होगा जहां आप आमतौर पर DISTINCT का उपयोग करेंगे। COUNT_BIG() . के साथ क्लॉज ।
यह भी ध्यान रखें कि, लिखते समय APPROX_COUNT_DISTINCT() सार्वजनिक पूर्वावलोकन स्थिति में है।
