Dalam SQL, COUNT() fungsi adalah fungsi agregat yang mengembalikan jumlah item yang ditemukan dalam grup.
Anda dapat menggunakan COUNT() di beberapa bagian kueri. Misalnya, Anda dapat menggunakannya di SELECT daftar, atau HAVING klausa saat memfilter grup.
Tabel Contoh
Misalkan kita memiliki tabel berikut:
SELECT * FROM Pets;Hasil:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Contoh berikut akan menggunakan COUNT() berfungsi saat menanyakan tabel ini.
Contoh
Berikut ini contoh sederhana untuk memulai.
SELECT COUNT(*) AS Count
FROM Pets;Hasil:
+---------+ | Count | |---------| | 8 | +---------+
Ini memberitahu kita bahwa ada 8 baris dalam tabel. Kami mengetahuinya karena kami menggunakan wildcard asterisk (* ) untuk menentukan semua baris dan semua kolom.
Hitung Kolom Tertentu
Anda juga dapat menentukan kolom tertentu untuk dihitung. COUNT() fungsi hanya menghitung non-NULL hasil, jadi jika Anda menentukan kolom yang berisi NULL nilai, nilai tersebut tidak akan dihitung.
Berikut ini contoh untuk menunjukkan apa yang saya maksud.
SELECT COUNT(DOB) AS Count
FROM Pets;Hasil:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
Dalam hal ini, Pets tabel berisi dua NULL nilai dalam DOB kolom (dua hewan peliharaan belum memberikan tanggal lahir mereka), jadi COUNT(DOB) mengembalikan 6, bukannya 8 saat kita menggunakan COUNT(*) .
Alasan COUNT(*) pada contoh sebelumnya mengembalikan semua baris, karena kedua baris tersebut dilakukan memiliki data di kolom lain.
Dalam contoh saya, DBMS saya juga mengembalikan peringatan tentang ini. Anda mungkin mendapatkan peringatan atau tidak, tergantung pada DBMS dan konfigurasi spesifik Anda.
Hasil yang Difilter
COUNT() fungsi menghitung baris yang dikembalikan oleh kueri. Jadi jika Anda memfilter hasilnya, hasil dari COUNT() akan mencerminkan hal itu.
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Hasil:
+---------+ | Count | |---------| | 2 | +---------+
Dalam hal ini, ada dua hewan peliharaan dengan nama Fluffy. Oleh karena itu, dua baris akan dikembalikan oleh kueri, dan hasil dari COUNT() adalah 2 .
Hitung Kolom Berbeda
Secara default, COUNT() fungsi menyertakan ALL implicit implisit kata kunci. Ini berarti ada duplikat dalam hasilnya.
Tetapi Anda juga memiliki opsi untuk menambahkan DISTINCT kata kunci untuk menentukan bahwa hanya nilai yang berbeda yang dikembalikan. Artinya, Anda dapat menentukan bahwa itu tidak termasuk duplikat.
Mari kita pilih PetName kolom. Jika Anda melihat tabel asli di atas, Anda dapat melihat bahwa PetName kolom berisi dua baris dengan nilai yang sama (Fluffy ).
Pertama kita akan menjalankan COUNT(ALL PetName) kueri untuk memasukkan semua nilai duplikat dalam hitungan:
SELECT COUNT(ALL PetName) AS Count
FROM Pets;Hasil:
+---------+ | Count | |---------| | 8 | +---------+
Jadi, ada delapan baris. Ingatlah bahwa ini adalah hasil yang sama yang akan kita dapatkan jika kita tidak menyertakan ALL kata kunci, karena ALL adalah default.
Sekarang kita akan menjalankan COUNT(DISTINCT PetName) untuk menghilangkan duplikat dari hitungan.
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Hasil:
+---------+ | Count | |---------| | 7 | +---------+
Kali ini hasilnya 7 . Ini karena nilai duplikat kami dihilangkan. Artinya, nilai duplikat diperlakukan seolah-olah hanya ada satu nilai.
Menggunakan COUNT() dengan HAVING Klausa
Anda dapat menyertakan COUNT() berfungsi di beberapa bagian kueri. Tidak hanya terbatas pada SELECT daftar.
Berikut adalah contoh yang menggunakan COUNT() di kedua HAVING klausa dan SELECT daftar.
SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;Hasil:
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
Dalam hal ini, kami menggunakan HAVING klausa dalam hubungannya dengan GROUP BY klausa untuk mengembalikan hanya baris yang memiliki COUNT(PetTypeId) lebih besar dari 2 .
Anda tidak terbatas hanya pada ) Operator untuk Pemula”>lebih besar dari operator (> ) saat menggunakan HAVING ayat. Anda dapat menggunakan operator yang sama yang dapat Anda gunakan dengan WHERE klausa (seperti = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE , dll).
Lihat Operator SQL untuk daftar operator yang tersedia di SQL.
Fungsi Jendela
Bergantung pada DBMS Anda, Anda mungkin dapat menggunakan OVER klausa dengan COUNT() . Anda fungsi untuk membuat fungsi jendela.
Fungsi jendela melakukan operasi seperti agregat pada sekumpulan baris kueri. Ini menghasilkan hasil untuk setiap baris kueri. Ini berbeda dengan operasi agregat, yang mengelompokkan baris kueri ke dalam satu baris hasil.
Berikut adalah contoh untuk mendemonstrasikan konsep tersebut.
Kami telah melihat Pets meja. Basis data kami juga memiliki Owners tabel, dan berisi data berikut:
+-----------+-------------+------------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | |-----------+-------------+------------+----------------+-------------------| | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +-----------+-------------+------------+----------------+-------------------+
Kami dapat mengambil data dari tabel ini dan menyajikannya sebagai satu set hasil dengan menggunakan gabungan.
Kita juga dapat menggunakan COUNT() fungsi dengan OVER klausa untuk menerapkan fungsi jendela ke data.
SELECT
CONCAT(o.FirstName, ' ', o.LastName) AS Owner,
p.PetName,
COUNT(PetId) OVER (PARTITION BY CONCAT(o.FirstName, ' ', o.LastName)) AS "Number of pets from this owner"
FROM Owners o
INNER JOIN Pets p
ON p.OwnerId = o.OwnerId
ORDER BY "Number of pets from this owner" DESC;Hasil:
+---------------+-----------+----------------------------------+ | Owner | PetName | Number of pets from this owner | |---------------+-----------+----------------------------------| | Nancy Simpson | Wag | 3 | | Nancy Simpson | Fluffy | 3 | | Nancy Simpson | Fetch | 3 | | Bart Pitt | Scratch | 2 | | Bart Pitt | Bark | 2 | | Boris Trump | Meow | 2 | | Boris Trump | Fluffy | 2 | | Homer Connery | Tweet | 1 | +---------------+-----------+----------------------------------+
Dalam hal ini kami menggunakan OVER klausa dengan COUNT() . kami klausa untuk mempartisi hitungan menjadi nama pemilik saja.
Hasilnya adalah pemilik dengan banyak hewan peliharaan ditampilkan di beberapa baris (karena setiap hewan peliharaan juga harus ditampilkan), dan setiap baris berisi jumlah keseluruhan hewan peliharaan pemilik tersebut.
Konsep ini juga dapat diterapkan ke fungsi agregat lainnya dalam SQL, seperti SUM() , MIN() , MAX() , dan AVG() .
COUNT_BIG()
Jika Anda menghitung kumpulan data yang sangat besar di SQL Server, Anda mungkin menemukan bahwa COUNT() fungsi menghasilkan kesalahan, karena jumlahnya terlalu tinggi. Ini hanya akan terjadi jumlah Anda lebih besar dari 2.147.483.647.
Dalam kasus seperti itu, Anda dapat menggunakan COUNT_BIG() , yang dapat melayani jumlah yang jauh lebih besar.
Lihat Bagaimana COUNT_BIG() Bekerja di SQL Server dan COUNT() vs COUNT_BIG() untuk penjelasan lebih detail.
Standar SQL ANSI
COUNT() fungsi terdaftar dalam standar SQL, dan tersedia di sebagian besar (jika tidak semua) DBMS utama, dan bekerja hampir sama di antara mereka.
Untuk contoh kode yang dilakukan di berbagai DBMS, lihat SQLite COUNT() , SQL Server COUNT() , dan MySQL COUNT() .
