postgresql - sql - conteggio dei valori "true"

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

Nella tabella sopra, se lo faccio:

select count(*), count(myCol);

ottengo 6, 5

Ottengo 5perché non conta la voce nulla.

Come faccio a contare anche il numero di valori veri (3 nell'esempio)?

(Questa è una semplificazione e in realtà sto usando un'espressione molto più complicata all'interno della funzione count)

Modifica riepilogo: voglio anche includere un conteggio normale (*) nella query, quindi non posso utilizzare una clausola where

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

oppure, come hai scoperto tu stesso:

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

Converti il ​​valore booleano su un numero intero e somma.

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

Ottieni 6,3.

Da PostgreSQL 9.4 c'è la FILTERclausola , che consente una query molto concisa per contare i valori veri:

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

La query precedente è un cattivo esempio in quanto una semplice clausola WHERE sarebbe sufficiente e serve solo per dimostrare la sintassi. Dove brilla la clausola FILTER è che è facile da combinare con altri aggregati:

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

La clausola è particolarmente utile per le aggregazioni su una colonna che utilizza un'altra colonna come predicato, consentendo al contempo di recuperare aggregazioni filtrate in modo diverso in una singola query:

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

probabilmente l'approccio migliore è usare la funzione nullif.

in generale

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

o in breve

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 soluzione più breve e più pigra (senza casting) sarebbe usare la formula:

SELECT COUNT(myCol OR NULL) FROM myTable;

Provate voi stessi:

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

dà lo stesso risultato di

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

In MySQL, puoi fare anche questo:

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

Penso che in Postgres funzioni:

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

o meglio (per evitare :: e utilizzare la sintassi 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

O forse questo

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;

Converti semplicemente il campo booleano in numero intero e fai una somma. Questo funzionerà su postgresql:

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

Spero che aiuti!

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

Ecco un modo con la funzione Windowing:

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
;

raggrupperà i 3 possibili stati di bool (false, true, 0) in tre righe particolarmente utili quando si raggruppano insieme a un'altra colonna come il giorno