postgresql - sql - nombre de valeurs `true`

myCol
------
 true
 true
 true
 false
 false
 null

Dans le tableau ci-dessus, si je le fais:

select count(*), count(myCol);

Je reçois 6, 5

J'obtiens 5car il ne compte pas l'entrée nulle.

Comment compter également le nombre de valeurs vraies (3 dans l'exemple)?

(Ceci est une simplification et j'utilise en fait une expression beaucoup plus compliquée dans la fonction de comptage)

Modifier le résumé: je souhaite également inclure un nombre brut (*) dans la requête, je ne peux donc pas utiliser de clause where

SELECT COALESCE(sum(CASE WHEN myCol THEN 1 ELSE 0 END),0) FROM <table name>

ou, comme vous l'avez découvert vous-même:

SELECT count(CASE WHEN myCol THEN 1 END) FROM <table name>

Convertissez le booléen en entier et en somme.

SELECT count(*),sum(myCol::int);

Vous obtenez 6,3.

Depuis PostgreSQL 9.4, il y a la FILTERclause , qui permet une requête très concise pour compter les vraies valeurs:

select count(*) filter (where myCol)
from tbl;

La requête ci-dessus est un mauvais exemple dans la mesure où une simple clause WHERE suffirait, et sert uniquement à démontrer la syntaxe. Là où la clause FILTER brille, c'est qu'il est facile de la combiner avec d'autres agrégats:

select count(*), -- all
       count(myCol), -- non null
       count(*) filter (where myCol) -- true
from tbl;

La clause est particulièrement pratique pour les agrégats sur une colonne qui utilise une autre colonne comme prédicat, tout en permettant de récupérer des agrégats filtrés différemment dans une seule requête:

select count(*),
       sum(otherCol) filter (where myCol)
from tbl;

probablement, la meilleure approche consiste à utiliser la fonction nullif.

en général

select
    count(nullif(myCol = false, true)),  -- count true values
    count(nullif(myCol = true, true)),   -- count false values
    count(myCol);

ou en bref

select
    count(nullif(myCol, true)),  -- count false values
    count(nullif(myCol, false)), -- count true values
    count(myCol);

http://www.postgresql.org/docs/9.0/static/functions-conditional.html

La solution la plus courte et la plus paresseuse (sans coulée) serait d'utiliser la formule:

SELECT COUNT(myCol OR NULL) FROM myTable;

Essayez-le vous-même:

SELECT COUNT(x < 7 OR NULL)
   FROM GENERATE_SERIES(0,10) t(x);

donne le même résultat que

SELECT SUM(CASE WHEN x < 7 THEN 1 ELSE 0 END)
   FROM GENERATE_SERIES(0,10) t(x);

Dans MySQL, vous pouvez également le faire:

SELECT count(*) AS total
     , sum(myCol) AS countTrue --yes, you can add TRUEs as TRUE=1 and FALSE=0 !!
FROM yourTable
;

Je pense que dans Postgres, cela fonctionne:

SELECT count(*) AS total
     , sum(myCol::int) AS countTrue --convert Boolean to Integer
FROM yourTable
;

ou mieux (pour éviter :: et utiliser la syntaxe SQL standard):

SELECT count(*) AS total
     , sum(CAST(myCol AS int)) AS countTrue --convert Boolean to Integer
FROM yourTable
;

select f1,
       CASE WHEN f1 = 't' THEN COUNT(*) 
            WHEN f1 = 'f' THEN COUNT(*) 
            END AS counts,
       (SELECT COUNT(*) FROM mytable) AS total_counts
from mytable
group by f1

Ou peut-être ceci

SELECT SUM(CASE WHEN f1 = 't' THEN 1 END) AS t,
       SUM(CASE WHEN f1 = 'f' THEN 1 END) AS f,
       SUM(CASE WHEN f1 NOT IN ('t','f') OR f1 IS NULL THEN 1 END) AS others,
       SUM(CASE WHEN f1 IS NOT NULL OR f1 IS NULL THEN 1 ELSE 0 END) AS total_count
FROM mytable;

Convertissez simplement le champ booléen en entier et faites une somme. Cela fonctionnera sur postgresql:

select sum(myCol::int) from <table name>

J'espère que cela pourra aider!

SELECT count(*)         -- or count(myCol)
FROM   <table name>     -- replace <table name> with your table
WHERE  myCol = true;

Voici un moyen avec la fonction de fenêtrage:

SELECT DISTINCT *, count(*) over(partition by myCol)
FROM   <table name>;

-- Outputs:
-- --------------
-- myCol | count
-- ------+-------
--  f    |  2
--  t    |  3
--       |  1

select count(myCol)
from mytable
group by myCol
;

regroupera les 3 états possibles de bool (false, true, 0) en trois lignes particulièrement pratique lors du regroupement avec une autre colonne comme day