postgresql - sql - contagem de valores `true`

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

Na tabela acima, se eu fizer:

select count(*), count(myCol);

eu recebo 6, 5

Eu entendo 5, pois não conta a entrada nula.

Como também conto o número de valores verdadeiros (3 no exemplo)?

(Esta é uma simplificação e, na verdade, estou usando uma expressão muito mais complicada na função de contagem)

Editar resumo: também quero incluir uma contagem simples (*) na consulta, portanto, não posso usar uma cláusula where

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

ou, como você descobriu por si mesmo:

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

Converta o Booleano em um número inteiro e some.

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

Você consegue 6,3.

Desde o PostgreSQL 9.4 existe a FILTERcláusula , que permite uma consulta muito concisa para contar os valores verdadeiros:

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

A consulta acima é um mau exemplo, pois uma cláusula WHERE simples seria suficiente e serve apenas para demonstrar a sintaxe. O ponto forte da cláusula FILTER é que é fácil de combinar com outros agregados:

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

A cláusula é especialmente útil para agregados em uma coluna que usa outra coluna como predicado, enquanto permite buscar agregados filtrados de forma diferente em uma única consulta:

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

provavelmente, a melhor abordagem é usar a função nullif.

em geral

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

ou em suma

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

A solução mais curta e preguiçosa (sem fundir) seria usar a fórmula:

SELECT COUNT(myCol OR NULL) FROM myTable;

Tente você mesmo:

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

dá o mesmo resultado que

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

No MySQL, você também pode fazer isso:

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

Acho que no Postgres isso funciona:

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

ou melhor (para evitar :: e usar a sintaxe SQL padrão):

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 talvez isso

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;

Basta converter o campo booleano em inteiro e fazer uma soma. Isso funcionará no postgresql:

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

Espero que ajude!

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

Esta é uma maneira de usar a função de janela:

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
;

irá agrupar os 3 estados possíveis de bool (falso, verdadeiro, 0) em três linhas especialmente úteis ao agrupar junto com outra coluna como dia