SQL सर्वर में COUNT () कैसे काम करता है

SQL सर्वर में, COUNT() फ़ंक्शन समूह में मिली वस्तुओं की संख्या देता है। आप इसका उपयोग यह पता लगाने के लिए कर सकते हैं कि किसी तालिका या परिणाम सेट में कितनी पंक्तियाँ हैं।

सिंटैक्स

वाक्य रचना इस प्रकार है:

-- Aggregation Function Syntax  
COUNT ( { [ [ ALL | DISTINCT ] expression ] | * } )  

-- Analytic Function Syntax  
COUNT ( [ ALL ]  { expression | * } ) OVER ( [  ] )

ALL सभी मानों के लिए समग्र कार्य लागू करता है। यह डिफ़ॉल्ट मान है।

DISTINCT निर्दिष्ट करता है कि फ़ंक्शन अद्वितीय गैर-शून्य मानों की संख्या लौटाता है।

expression छवि . को छोड़कर, किसी भी प्रकार की अभिव्यक्ति है , ntext , या पाठ . एक्सप्रेशन में एग्रीगेट फ़ंक्शन और सबक्वेरी समर्थित नहीं हैं।

* निर्दिष्ट करता है कि सभी पंक्तियों को गिना और लौटाया जाना चाहिए, जिसमें डुप्लिकेट पंक्तियां और शून्य मान वाली पंक्तियां शामिल हैं। COUNT(*) कोई पैरामीटर नहीं लेता है और DISTINCT . के उपयोग का समर्थन नहीं करता है . इसके लिए अभिव्यक्ति . की भी आवश्यकता नहीं है पैरामीटर (क्योंकि यह किसी विशेष कॉलम के बारे में जानकारी का उपयोग नहीं करता है)।

OVER ( [ <partition_by_clause> ] FROM . द्वारा निर्मित परिणाम सेट को विभाजित करता है विभाजन में खंड जिस पर फ़ंक्शन लागू होता है। यदि निर्दिष्ट नहीं है, तो फ़ंक्शन क्वेरी परिणाम सेट की सभी पंक्तियों को एक समूह के रूप में मानता है।

उदाहरण 1 - मूल उपयोग

यह फ़ंक्शन कैसे काम करता है, इसका एक बुनियादी उदाहरण यहां दिया गया है:

SELECT COUNT(*) AS 'Row Count'
FROM Artists;

परिणाम:

+-------------+
| Row Count   |
|-------------|
| 16          |
+-------------+

इस मामले में कलाकारों . में 16 पंक्तियाँ हैं टेबल।

बस सुनिश्चित होने के लिए, वे ये हैं:

SELECT *
FROM Artists;

परिणाम:

+------------+------------------------+--------------+-------------+
| ArtistId   | ArtistName             | ActiveFrom   | CountryId   |
|------------+------------------------+--------------+-------------|
| 1          | Iron Maiden            | 1975-12-25   | NULL        |
| 2          | AC/DC                  | 1973-01-11   | NULL        |
| 3          | Allan Holdsworth       | 1969-01-01   | NULL        |
| 4          | Buddy Rich             | 1919-01-01   | NULL        |
| 5          | Devin Townsend         | 1993-01-01   | NULL        |
| 6          | Jim Reeves             | 1948-01-01   | NULL        |
| 7          | Tom Jones              | 1963-01-01   | NULL        |
| 8          | Maroon 5               | 1994-01-01   | NULL        |
| 9          | The Script             | 2001-01-01   | NULL        |
| 10         | Lit                    | 1988-06-26   | NULL        |
| 11         | Black Sabbath          | 1968-01-01   | NULL        |
| 12         | Michael Learns to Rock | 1988-03-15   | NULL        |
| 13         | Carabao                | 1981-01-01   | NULL        |
| 14         | Karnivool              | 1997-01-01   | NULL        |
| 15         | Birds of Tokyo         | 2004-01-01   | NULL        |
| 16         | Bodyjar                | 1990-01-01   | NULL        |
+------------+------------------------+--------------+-------------+

जैसी कि अपेक्षित थी, 16 पंक्तियाँ लौटा दी गई हैं।

ध्यान दें कि देश आईडी कॉलम में शून्य मानों के अलावा कुछ भी नहीं है। यह अगले उदाहरण के लिए उपयोगी होगा।

उदाहरण 2 - एक कॉलम निर्दिष्ट करें

पिछले उदाहरण में तारक का इस्तेमाल किया गया था (* ) सभी पंक्तियों को निर्दिष्ट करने के लिए। इसके परिणामस्वरूप सभी पंक्तियों की गणना की जाती है, भले ही डुप्लीकेट हों या कोई शून्य मान हों।

आप एक विशेष कॉलम भी निर्दिष्ट कर सकते हैं। जब आप ऐसा करते हैं, तो शून्य मानों की गणना नहीं की जाती है। अर्थात्, उस कॉलम के लिए शून्य मान वाली किसी भी पंक्ति की गणना नहीं की जाती है।

यहां CountryId . का उपयोग करके एक उदाहरण दिया गया है स्तंभ जैसा कि पिछले उदाहरण में बताया गया है:

SELECT COUNT(CountryId) AS 'Row Count'
FROM Artists;

परिणाम:

+-------------+
| Row Count   |
|-------------|
| 0           |
+-------------+

जैसा कि हमने पिछले उदाहरण में देखा, इस कॉलम की सभी पंक्तियाँ NULL हैं . इसलिए, परिणामी पंक्ति गणना शून्य है।

आइए उस कॉलम में कुछ मान जोड़ें:

UPDATE Artists
SET CountryId = 2
WHERE ArtistName IN (
    'AC/DC', 
    'Karnivool', 
    'Birds of Tokyo', 
    'Bodyjar'
    );

आइए अब उस कॉलम की पंक्तियों को फिर से गिनें:

SELECT COUNT(CountryId) AS 'Row Count'
FROM Artists;

परिणाम:

+-------------+
| Row Count   |
|-------------|
| 4           |
+-------------+

उदाहरण 3 - DISTINCT के साथ

यह उदाहरण DISTINCT . का उपयोग करता है केवल अलग पंक्तियों (यानी गैर-डुप्लिकेट) को वापस करने के लिए क्लॉज।

पिछले उदाहरण में, मैंने तालिका को अपडेट किया ताकि वही देश आईडी चार कलाकारों पर लागू किया गया था (मैंने SET CountryId = 2 . का उपयोग किया था सभी चार कलाकारों के लिए)। इसके परिणामस्वरूप एक ही CountryId . के साथ चार पंक्तियाँ बन गईं ।

यहां बताया गया है कि क्या होता है यदि मैं गिनता हूं कि कितने अलग देश आईडी s उस तालिका में हैं:

SELECT COUNT(DISTINCT CountryId) 'Distinct CountryIds'
FROM Artists;

परिणाम:

+-----------------------+
| Distinct CountryIds   |
|-----------------------|
| 1                     |
+-----------------------+

यह अपेक्षित है, क्योंकि, हालांकि CountryId . के साथ चार पंक्तियाँ हैं , यह अभी भी केवल एक विशिष्ट CountryId . है ।

बस यह सुनिश्चित करने के लिए, आइए इसे इसके "गैर विशिष्ट" संस्करण के साथ चलाएं:

SELECT 
  COUNT(CountryId) 'Non Distinct',
  COUNT(DISTINCT CountryId) 'Distinct'
FROM Artists;

परिणाम:

+----------------+------------+
| Non Distinct   | Distinct   |
|----------------+------------|
| 4              | 1          |
+----------------+------------+

तो गैर विशिष्ट संस्करण दिखाता है कि कितनी बार देश आईडी तालिका में दिखाई देता है, जबकि DISTINCT संस्करण एकाधिक घटनाओं को 1 के रूप में गिनता है।

आइए एक और देश आईडी जोड़ें मेज पर:

UPDATE Artists
SET CountryId = 1
WHERE ArtistName = 'Carabao';

और अब क्वेरी को फिर से चलाएँ:

SELECT 
  COUNT(CountryId) 'Non Distinct',
  COUNT(DISTINCT CountryId) 'Distinct'
FROM Artists;

परिणाम:

+----------------+------------+
| Non Distinct   | Distinct   |
|----------------+------------|
| 5              | 2          |
+----------------+------------+

उदाहरण 4 - WHERE क्लॉज का उपयोग करें

यहां WHERE . का उपयोग करके एक त्वरित उदाहरण दिया गया है खंड।

SELECT COUNT(*) AS 'Row Count'
FROM Artists
WHERE ActiveFrom >= '2000-01-01';

परिणाम:

+-------------+
| Row Count   |
|-------------|
| 2           |
+-------------+

उदाहरण 5 - ग्रुप बाय के साथ

यहां एक कॉलम में कलाकारों को समूहबद्ध करने, फिर दूसरे कॉलम में प्रत्येक कलाकार के लिए सभी एल्बम गिनने का एक उदाहरण दिया गया है।

उदाहरण:

SELECT 
  ArtistName,
  COUNT(al.AlbumId) 'Number of Albums'
FROM Artists ar
INNER JOIN Albums al
ON al.ArtistId = ar.ArtistId
GROUP BY ArtistName
ORDER BY 'Number of Albums' DESC;

परिणाम:

+------------------------+--------------------+
| ArtistName             | Number of Albums   |
|------------------------+--------------------|
| Iron Maiden            | 5                  |
| Michael Learns to Rock | 3                  |
| The Script             | 3                  |
| Tom Jones              | 3                  |
| Devin Townsend         | 3                  |
| Allan Holdsworth       | 2                  |
| Buddy Rich             | 1                  |
| AC/DC                  | 1                  |
| Jim Reeves             | 1                  |
+------------------------+--------------------+

उदाहरण 6 - हैविंग क्लॉज के साथ

हम केवल उन कलाकारों को शामिल करने के लिए पिछले उदाहरण में बदलाव कर सकते हैं जिनके पास एक निश्चित संख्या से अधिक एल्बम हैं। हम HAVING . का उपयोग करके ऐसा कर सकते हैं खंड।

SELECT 
  ArtistName,
  COUNT(al.AlbumId) 'Number of Albums'
FROM Artists ar
INNER JOIN Albums al
ON al.ArtistId = ar.ArtistId
GROUP BY ArtistName
HAVING COUNT(al.AlbumId) > 2
ORDER BY 'Number of Albums' DESC;

परिणाम:

+------------------------+--------------------+
| ArtistName             | Number of Albums   |
|------------------------+--------------------|
| Iron Maiden            | 5                  |
| Michael Learns to Rock | 3                  |
| The Script             | 3                  |
| Tom Jones              | 3                  |
| Devin Townsend         | 3                  |
+------------------------+--------------------+

उदाहरण 7 - ओवर क्लॉज के साथ विभाजन

आप OVER . का उपयोग कर सकते हैं PARTITION BY के साथ क्लॉज परिणामों को विभाजन में विभाजित करने के लिए।

इस उदाहरण में, मैं OVER (PARTITION BY ArtistName) . का उपयोग करता हूं प्रत्येक एल्बम को सूचीबद्ध करने के लिए जिसे कलाकार ने निर्मित किया है, साथ ही उस कलाकार के लिए एल्बमों की कुल संख्या।

SELECT  
  ArtistName,
  AlbumName,
  COUNT(AlbumId) OVER (PARTITION BY ArtistName) 'Number of Albums from this Artist'
FROM Artists ar
INNER JOIN Albums al
ON al.ArtistId = ar.ArtistId
ORDER BY 'Number of Albums from this Artist' DESC;

परिणाम:

+------------------------+--------------------------+-------------------------------------+
| ArtistName             | AlbumName                | Number of Albums from this Artist   |
|------------------------+--------------------------+-------------------------------------|
| Iron Maiden            | Powerslave               | 5                                   |
| Iron Maiden            | Somewhere in Time        | 5                                   |
| Iron Maiden            | Piece of Mind            | 5                                   |
| Iron Maiden            | Killers                  | 5                                   |
| Iron Maiden            | No Prayer for the Dying  | 5                                   |
| AC/DC                  | Powerage                 | 3                                   |
| AC/DC                  | Back in Black            | 3                                   |
| AC/DC                  | Rock or Bust             | 3                                   |
| Michael Learns to Rock | Blue Night               | 3                                   |
| Michael Learns to Rock | Eternity                 | 3                                   |
| Michael Learns to Rock | Scandinavia              | 3                                   |
| Devin Townsend         | Ziltoid the Omniscient   | 3                                   |
| Devin Townsend         | Casualties of Cool       | 3                                   |
| Devin Townsend         | Epicloud                 | 3                                   |
| Tom Jones              | Long Lost Suitcase       | 3                                   |
| Tom Jones              | Praise and Blame         | 3                                   |
| Tom Jones              | Along Came Jones         | 3                                   |
| Allan Holdsworth       | All Night Wrong          | 2                                   |
| Allan Holdsworth       | The Sixteen Men of Tain  | 2                                   |
| Buddy Rich             | Big Swing Face           | 1                                   |
| Jim Reeves             | Singing Down the Lane    | 1                                   |
| The Script             | No Sound Without Silence | 1                                   |
+------------------------+--------------------------+-------------------------------------+

ध्यान दें कि इससे कलाकार और एल्बम की गिनती कई पंक्तियों में दोहराई जाती है, लेकिन यह तब अपेक्षित है जब हम प्रत्येक एल्बम को उसकी अपनी पंक्ति में सूचीबद्ध करना चाहते हैं।

उदाहरण 8 - STRING_AGG() के साथ

यदि आप नहीं चाहते कि प्रत्येक कलाकार और एल्बम की गणना पिछले उदाहरण की तरह कई पंक्तियों में दोहराई जाए, तो आप हमेशा STRING_AGG() का उपयोग कर सकते हैं एल्बम को सूची के रूप में आउटपुट करने के लिए कार्य करता है। इस मामले में, आपको OVER . की आवश्यकता नहीं होगी खंड।

उदाहरण:

SELECT
  ArtistName,
  STRING_AGG(AlbumName, ', ') 'Albums',
  COUNT(AlbumId) 'Count'
FROM Artists ar
INNER JOIN Albums al
ON al.ArtistId = ar.ArtistId
GROUP BY ArtistName
ORDER BY 'Count' DESC;

परिणाम:

+------------------------+--------------------------------------------------------------------------------+---------+
| ArtistName             | Albums                                                                         | Count   |
|------------------------+--------------------------------------------------------------------------------+---------|
| Iron Maiden            | Powerslave, Somewhere in Time, Piece of Mind, Killers, No Prayer for the Dying | 5       |
| AC/DC                  | Powerage, Back in Black, Rock or Bust                                          | 3       |
| Michael Learns to Rock | Blue Night, Eternity, Scandinavia                                              | 3       |
| Devin Townsend         | Ziltoid the Omniscient, Casualties of Cool, Epicloud                           | 3       |
| Tom Jones              | Long Lost Suitcase, Praise and Blame, Along Came Jones                         | 3       |
| Allan Holdsworth       | All Night Wrong, The Sixteen Men of Tain                                       | 2       |
| Buddy Rich             | Big Swing Face                                                                 | 1       |
| Jim Reeves             | Singing Down the Lane                                                          | 1       |
| The Script             | No Sound Without Silence                                                       | 1       |
+------------------------+--------------------------------------------------------------------------------+---------+

बहुत सारी पंक्तियाँ?

COUNT() फ़ंक्शन अपना परिणाम int . के रूप में देता है डेटा प्रकार। यदि आपके पास इतनी पंक्तियाँ हैं कि परिणाम int . से बड़ा है संभाल सकते हैं, कोशिश करें COUNT_BIG() इसके बजाय।

COUNT_BIG() COUNT() . जैसा ही काम करता है , सिवाय इसके कि इसके परिणाम बिगिंट . के रूप में लौटाए जाते हैं डेटा प्रकार मान।

आप APPROX_COUNT_DISTINCT() . का उपयोग करने पर भी विचार कर सकते हैं कुछ मामलों में।

APPROX_COUNT_DISTINCT() एक सटीक मान के बजाय एक अनुमानित मान देता है। हालांकि, इसे COUNT() . की तुलना में अधिक प्रतिक्रियाशील होने के लिए डिज़ाइन किया गया है और COUNT_BIG() , इसलिए यह उस समय के लिए उपयोगी हो सकता है जब सटीकता की तुलना में जवाबदेही अधिक महत्वपूर्ण होती है।

यह अद्वितीय, गैर-शून्य मानों को वापस करने के लिए डिज़ाइन किया गया है, इसलिए यह केवल उस समय के लिए प्रासंगिक होगा जहां आप आमतौर पर DISTINCT का उपयोग करेंगे। COUNT_BIG() . के साथ क्लॉज ।

यह भी ध्यान रखें कि, लिखते समय APPROX_COUNT_DISTINCT() सार्वजनिक पूर्वावलोकन स्थिति में है।