En SQL, quelle est la différence entre count (colonne) et count (*)?

J'ai la requête suivante:

select column_name, count(column_name)
from table
group by column_name
having count(column_name) > 1;

Quelle serait la différence si je remplaçais tous les appels count(column_name)vers count(*)?

Cette question a été inspirée par Comment trouver des valeurs en double dans une table dans Oracle? .

Pour clarifier la réponse acceptée (et peut-être ma question), le remplacer count(column_name)par count(*)retournerait une ligne supplémentaire dans le résultat qui contient a nullet le nombre de nullvaleurs dans la colonne.

count(*)compte les valeurs NULL et count(column)ne

[modifier] a ajouté ce code pour que les gens puissent l'exécuter

create table #bla(id int,id2 int)
insert #bla values(null,null)
insert #bla values(1,null)
insert #bla values(null,1)
insert #bla values(1,null)
insert #bla values(null,1)
insert #bla values(1,null)
insert #bla values(null,null)

select count(*),count(id),count(id2)
from #bla

résultats 7 3 2

Une autre différence mineure, entre l'utilisation de * et une colonne spécifique, est que dans le cas de la colonne, vous pouvez ajouter le mot clé DISTINCT et restreindre le nombre à des valeurs distinctes:

select column_a, count(distinct column_b)
from table
group by column_a
having count(distinct column_b) > 1;

Une autre différence, peut-être subtile, est que dans certaines implémentations de base de données, le nombre (*) est calculé en regardant les index sur la table en question plutôt que les lignes de données réelles. Puisqu'aucune colonne spécifique n'est spécifiée, il n'est pas nécessaire de se préoccuper des lignes réelles et de leurs valeurs (comme ce serait le cas si vous comptiez une colonne spécifique). Autoriser la base de données à utiliser les données d'index peut être beaucoup plus rapide que de lui faire compter des lignes "réelles".

L'explication dans la documentation , aide à expliquer ceci:

COUNT (*) renvoie le nombre d'éléments dans un groupe, y compris les valeurs NULL et les doublons.

COUNT (expression) évalue l'expression pour chaque ligne d'un groupe et renvoie le nombre de valeurs non nulles.

Donc, count (*) inclut des valeurs nulles, l'autre méthode ne le fait pas.

Nous pouvons utiliser l' explorateur de données Exchange Stack pour illustrer la différence avec une simple requête. La table Utilisateurs de la base de données de Stack Overflow contient des colonnes qui sont souvent laissées vides, comme l'URL du site Web de l'utilisateur.

-- count(column_name) vs. count(*)
-- Illustrates the difference between counting a column
-- that can hold null values, a  'not null' column, and  count(*)

select count(WebsiteUrl), count(Id), count(*) from Users

Si vous exécutez la requête ci-dessus dans l' explorateur de données , vous verrez que le nombre est le même pour count(Id)et count(*)parce que la Idcolonne n'autorise pas les nullvaleurs. Le WebsiteUrlnombre est cependant beaucoup plus faible, car cette colonne le permet null.

Fondamentalement, la COUNT(*)fonction renvoie toutes les lignes d'une table alors que ce COUNT(COLUMN_NAME)n'est pas le cas; c'est-à-dire qu'il exclut les valeurs nulles auxquelles tout le monde ici a également répondu ici. Mais la partie la plus intéressante est de rendre les requêtes et la base de données optimisées, il est préférable de les utiliser à COUNT(*)moins de faire plusieurs comptes ou une requête complexe plutôt que COUNT(COLUMN_NAME). Sinon, cela réduira vraiment les performances de votre base de données tout en traitant un grand nombre de données.

• La phrase COUNT (*) indique à SQL Server de renvoyer toutes les lignes d'une table, y compris les valeurs NULL.
• COUNT (nom_colonne) récupère simplement les lignes ayant une valeur non nulle sur les lignes.

Veuillez consulter le code suivant pour les exécutions de test SQL Server 2008:

-- Variable table
DECLARE @Table TABLE
(
      CustomerId int NULL 
    , Name nvarchar(50) NULL
)

-- Insert some records for tests
INSERT INTO @Table VALUES( NULL, 'Pedro')
INSERT INTO @Table VALUES( 1, 'Juan')
INSERT INTO @Table VALUES( 2, 'Pablo')
INSERT INTO @Table VALUES( 3, 'Marcelo')
INSERT INTO @Table VALUES( NULL, 'Leonardo')
INSERT INTO @Table VALUES( 4, 'Ignacio')

-- Get all the collumns by indicating *
SELECT  COUNT(*) AS 'AllRowsCount'
FROM    @Table

-- Get only content columns ( exluce NULLs )
SELECT  COUNT(CustomerId) AS 'OnlyNotNullCounts'
FROM    @Table

COUNT(*) - Renvoie le nombre total d'enregistrements dans une table (y compris les enregistrements de valeur NULL).

COUNT(Column Name) - Renvoie le nombre total d'enregistrements non NULL. Cela signifie que, il ignore le comptage des enregistrements de valeur NULL dans cette colonne particulière.

Il est préférable d'utiliser

Count(1) in place of column name or * 

pour compter le nombre de lignes dans une table, c'est plus rapide que n'importe quel format car il ne va jamais vérifier que le nom de la colonne dans la table existe ou non

Il n'y a pas de différence si une colonne est fixe dans votre table, si vous souhaitez utiliser plus d'une colonne que vous devez spécifier le nombre de colonnes dont vous avez besoin pour compter ......

Merci,

Comme mentionné dans les réponses précédentes, Count(*)compte même les NULLcolonnes, alors qu'il count(Columnname)ne compte que si la colonne a des valeurs.

Il est toujours préférable d'éviter tout *( Select *, count *, ...)