postgresql - sql - recuento de valores `verdaderos`

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

En la tabla anterior, si lo hago:

select count(*), count(myCol);

yo obtengo 6, 5

Obtengo 5ya que no cuenta la entrada nula.

¿Cómo también cuento el número de valores verdaderos (3 en el ejemplo)?

(Esta es una simplificación y en realidad estoy usando una expresión mucho más complicada dentro de la función de conteo)

Editar resumen: también quiero incluir un recuento simple (*) en la consulta, por lo que no puedo usar una cláusula where

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

o, como lo descubrió por sí mismo:

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

Convierte el booleano en un número entero y suma.

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

Usted consigue 6,3.

Desde PostgreSQL 9.4 existe la FILTERcláusula , que permite una consulta muy concisa para contar los valores verdaderos:

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

La consulta anterior es un mal ejemplo en el sentido de que una simple cláusula WHERE sería suficiente y es solo para demostrar la sintaxis. Donde brilla la cláusula FILTER es que es fácil de combinar con otros agregados:

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

La cláusula es especialmente útil para agregados en una columna que usa otra columna como predicado, mientras que permite obtener agregados filtrados de manera diferente en una sola consulta:

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

probablemente, el mejor enfoque es utilizar la función nullif.

en general

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

o en resumen

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 solución más corta y perezosa (sin fundición) sería usar la fórmula:

SELECT COUNT(myCol OR NULL) FROM myTable;

Inténtalo tú mismo:

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

da el mismo resultado que

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

En MySQL, también puede hacer esto:

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

Creo que en Postgres, esto funciona:

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

o mejor (para evitar :: y usar la sintaxis SQL estándar):

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

O tal vez esto

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;

Simplemente convierta el campo booleano en entero y haga una suma. Esto funcionará en postgresql:

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

¡Espero que ayude!

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

He aquí una forma con la función de ventana:

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
;

agrupará los 3 estados posibles de bool (falso, verdadero, 0) en tres filas especialmente útiles cuando se agrupan con otra columna como día