Comptage des valeurs nulles et non nulles dans une seule requête

J'ai une table

create table us
(
 a number
);

Maintenant, j'ai des données comme:

a
1
2
3
4
null
null
null
8
9

Maintenant, j'ai besoin d'une seule requête pour compter les valeurs nulles et non nulles dans la colonne a

Cela fonctionne pour Oracle et SQL Server (vous pourrez peut-être le faire fonctionner sur un autre SGBDR):

select sum(case when a is null then 1 else 0 end) count_nulls
     , count(a) count_not_nulls 
  from us;

Ou:

select count(*) - count(a), count(a) from us;

Si j'ai bien compris, vous voulez compter tous les NULL et tous les NOT NULL dans une colonne ...

Si c'est correct:

SELECT count(*) FROM us WHERE a IS NULL 
UNION ALL
SELECT count(*) FROM us WHERE a IS NOT NULL

Modifié pour avoir la requête complète, après avoir lu les commentaires:]

SELECT COUNT(*), 'null_tally' AS narrative 
  FROM us 
 WHERE a IS NULL 
UNION
SELECT COUNT(*), 'not_null_tally' AS narrative 
  FROM us 
 WHERE a IS NOT NULL;

Voici une version rapide et sale qui fonctionne sur Oracle:

select sum(case a when null then 1 else 0) "Null values",
       sum(case a when null then 0 else 1) "Non-null values"
from us

Comme j'ai compris votre requête, exécutez simplement ce script et obtenez Total Null, Total NotNull,

select count(*) - count(a) as 'Null', count(a) as 'Not Null' from us;

pour les non nuls

select count(a)
from us

pour les nuls

select count(*)
from us

minus 

select count(a)
from us

Par conséquent

SELECT COUNT(A) NOT_NULLS
FROM US

UNION

SELECT COUNT(*) - COUNT(A) NULLS
FROM US

devrait faire le travail

Mieux, les titres des colonnes sont corrects.

SELECT COUNT(A) NOT_NULL, COUNT(*) - COUNT(A) NULLS
FROM US

Dans certains tests sur mon système, cela coûte une analyse complète de la table.

habituellement j'utilise cette astuce

select sum(case when a is null then 0 else 1 end) as count_notnull,
       sum(case when a is null then 1 else 0 end) as count_null
from tab
group by a

Juste pour fournir une autre alternative, Postgres 9.4+ permet d'appliquer un FILTERaux agrégats :

SELECT
  COUNT(*) FILTER (WHERE a IS NULL) count_nulls,
  COUNT(*) FILTER (WHERE a IS NOT NULL) count_not_nulls
FROM us;

SQLFiddle: http://sqlfiddle.com/#!17/80a24/5

C'est peu compliqué. Supposons que la table ne comporte qu'une seule colonne, puis le nombre (1) et le nombre (*) donneront des valeurs différentes.

set nocount on
    declare @table1 table (empid int)
    insert @table1 values (1),(2),(3),(4),(5),(6),(7),(8),(9),(10),(NULL),(11),(12),(NULL),(13),(14);

    select * from @table1
    select COUNT(1) as "COUNT(1)" from @table1
    select COUNT(empid) "Count(empid)" from @table1

Résultats de la requête

Comme vous pouvez le voir sur l'image, le premier résultat montre que le tableau comporte 16 lignes. dont deux lignes sont NULL. Ainsi, lorsque nous utilisons Count (*), le moteur de requête compte le nombre de lignes, donc nous avons obtenu le résultat de count comme 16. Mais dans le cas de Count (empid), il a compté les valeurs non NULL dans la colonne empid . Nous avons donc obtenu le résultat 14.

donc chaque fois que nous utilisons COUNT (Colonne), assurez-vous que nous prenons soin des valeurs NULL comme indiqué ci-dessous.

select COUNT(isnull(empid,1)) from @table1

comptera les valeurs NULL et Non-NULL.

Remarque : la même chose s'applique même lorsque le tableau est composé de plus d'une colonne. Count (1) donnera le nombre total de lignes indépendamment des valeurs NULL / Non-NULL. Ce n'est que lorsque les valeurs de colonne sont comptées à l'aide de Count (Column) que nous devons prendre soin des valeurs NULL.

J'ai eu un problème similaire: compter toutes les valeurs distinctes, en comptant également les valeurs nulles comme 1. Un simple décompte ne fonctionne pas dans ce cas, car il ne prend pas en compte les valeurs nulles.

Voici un extrait de code qui fonctionne sur SQL et n'implique pas de sélection de nouvelles valeurs. Fondamentalement, une fois effectué le distinct, renvoyez également le numéro de ligne dans une nouvelle colonne (n) en utilisant la fonction row_number (), puis effectuez un comptage sur cette colonne:

SELECT COUNT(n)
FROM (
    SELECT *, row_number() OVER (ORDER BY [MyColumn] ASC) n
    FROM (
        SELECT DISTINCT [MyColumn]
                    FROM [MyTable]
        ) items  
) distinctItems

Voici deux solutions:

Select count(columnname) as countofNotNulls, count(isnull(columnname,1))-count(columnname) AS Countofnulls from table name

OU

Select count(columnname) as countofNotNulls, count(*)-count(columnname) AS Countofnulls from table name

Essayer

SELECT 
   SUM(ISNULL(a)) AS all_null,
   SUM(!ISNULL(a)) AS all_not_null
FROM us;

Facile!

Essaye ça..

SELECT CASE 
         WHEN a IS NULL THEN 'Null' 
         ELSE 'Not Null' 
       END a, 
       Count(1) 
FROM   us 
GROUP  BY CASE 
            WHEN a IS NULL THEN 'Null' 
            ELSE 'Not Null' 
          END 

Si vous utilisez MS Sql Server ...

SELECT COUNT(0) AS 'Null_ColumnA_Records',
(
    SELECT COUNT(0)
    FROM your_table
    WHERE ColumnA IS NOT NULL
) AS 'NOT_Null_ColumnA_Records'
FROM your_table
WHERE ColumnA IS NULL;

Je ne vous recommande pas de faire cela ... mais vous l'avez ici (dans le même tableau que le résultat)

utiliser la fonction intégrée ISNULL.

si c'est mysql, vous pouvez essayer quelque chose comme ça.

select 
   (select count(*) from TABLENAME WHERE a = 'null') as total_null, 
   (select count(*) from TABLENAME WHERE a != 'null') as total_not_null
FROM TABLENAME

SELECT SUM(NULLs) AS 'NULLS', SUM(NOTNULLs) AS 'NOTNULLs' FROM 
    (select count(*) AS 'NULLs', 0 as 'NOTNULLs' FROM us WHERE a is null
    UNION select 0 as 'NULLs', count(*) AS 'NOTNULLs' FROM us WHERE a is not null) AS x

C'est fugace, mais il renverra un seul enregistrement avec 2 cols indiquant le nombre de nuls par rapport aux non nuls.

Cela fonctionne dans T-SQL. Si vous comptez simplement le nombre de quelque chose et que vous souhaitez inclure les valeurs nulles, utilisez COALESCE au lieu de case.

IF OBJECT_ID('tempdb..#us') IS NOT NULL
    DROP TABLE #us

CREATE TABLE #us
    (
    a INT NULL
    );

INSERT INTO #us VALUES (1),(2),(3),(4),(NULL),(NULL),(NULL),(8),(9)

SELECT * FROM #us

SELECT CASE WHEN a IS NULL THEN 'NULL' ELSE 'NON-NULL' END AS 'NULL?',
        COUNT(CASE WHEN a IS NULL THEN 'NULL' ELSE 'NON-NULL' END) AS 'Count'
    FROM #us
    GROUP BY CASE WHEN a IS NULL THEN 'NULL' ELSE 'NON-NULL' END

SELECT COALESCE(CAST(a AS NVARCHAR),'NULL') AS a,
        COUNT(COALESCE(CAST(a AS NVARCHAR),'NULL')) AS 'Count'
    FROM #us
    GROUP BY COALESCE(CAST(a AS NVARCHAR),'NULL')

En m'appuyant sur Alberto, j'ai ajouté le rollup.

 SELECT [Narrative] = CASE 
 WHEN [Narrative] IS NULL THEN 'count_total' ELSE    [Narrative] END
,[Count]=SUM([Count]) FROM (SELECT COUNT(*) [Count], 'count_nulls' AS [Narrative]  
FROM [CrmDW].[CRM].[User]  
WHERE [EmployeeID] IS NULL 
UNION
SELECT COUNT(*), 'count_not_nulls ' AS narrative 
FROM [CrmDW].[CRM].[User] 
WHERE [EmployeeID] IS NOT NULL) S 
GROUP BY [Narrative] WITH CUBE;

SELECT
    ALL_VALUES
    ,COUNT(ALL_VALUES)
FROM(
        SELECT 
        NVL2(A,'NOT NULL','NULL') AS ALL_VALUES 
        ,NVL(A,0)
        FROM US
)
GROUP BY ALL_VALUES

select count(isnull(NullableColumn,-1))

Toutes les réponses sont soit fausses, soit extrêmement dépassées.

La manière simple et correcte de faire cette requête est d'utiliser la COUNT_IFfonction.

SELECT
  COUNT_IF(a IS NULL) AS nulls,
  COUNT_IF(a IS NOT NULL) AS not_nulls
FROM
  us

Juste au cas où vous le vouliez dans un seul enregistrement:

select 
  (select count(*) from tbl where colName is null) Nulls,
  (select count(*) from tbl where colName is not null) NonNulls 

;-)

pour compter des valeurs non nulles

select count(*) from us where a is not null;

pour compter les valeurs nulles

 select count(*) from us where a is null;

J'ai créé la table dans postgres 10 et les deux ont fonctionné:

select count(*) from us

et

select count(a is null) from us

Dans mon cas, je voulais la " distribution nulle " entre plusieurs colonnes:

SELECT
       (CASE WHEN a IS NULL THEN 'NULL' ELSE 'NOT-NULL' END) AS a_null,
       (CASE WHEN b IS NULL THEN 'NULL' ELSE 'NOT-NULL' END) AS b_null,
       (CASE WHEN c IS NULL THEN 'NULL' ELSE 'NOT-NULL' END) AS c_null,
       ...
       count(*)
FROM us
GROUP BY 1, 2, 3,...
ORDER BY 1, 2, 3,...

Selon le '...', il est facilement extensible à plus de colonnes, autant que nécessaire

Nombre d'éléments où a est nul:

select count(a) from us where a is null;

Nombre d'éléments où a n'est pas nul:

select count(a) from us where a is not null;