CODEWITHSUNDEEP
databasepostgresqlrdbms
Tomas Greif
Tomas Greif

Reputation: 22663

Why aggregate functions in PostgreSQL do not work with boolean data type

Why we cannot use boolean values in aggregate functions without casting to some integer type first? In many cases it makes perfect sense to calculate sum, average or correlation from columns of boolean data type.

Consider the following example where boolean input has to be always casted to int in order to make it work: 

select
   sum(boolinput::int),
   avg(boolinput::int),
   max(boolinput::int),
   min(boolinput::int),
   stddev(boolinput::int),
   corr(boolinput::int,boolinputb::int)   
from
   (select 
      (random() > .5)::boolean as boolinput,
      (random() > .5)::boolean as boolinputB 
    from 
      generate_series(1,100)
   ) a

From PostgreSQL documentation:

Valid literal values for the "true" state are: TRUE 't' 'true' 'y' 'yes' 'on' '1'

For the "false" state, the following values can be used: FALSE 'f' 'false' 'n' 'no' 'off' '0'

Because by definition TRUE equals 1 and FALSE equals 0 I do not understand why casting is necessary.

Allowing boolean in aggregation would have also interesting side effects - we can for example simplify many case statements:

Current version (clean and easy to understand):

select sum(case when gs > 50 then 1 else 0 end) from generate_series(1,100) gs;

Using old fashioned casting operator :::

select sum((gs > 50)::int) from generate_series(1,100) gs;

Direct aggregation of boolean values (not working currently):

select sum(gs > 50) from generate_series(1,100) gs;

Is direct aggregation of boolean values possible in other DBMSs? Why this is not possible in PostgreSQL?

Upvotes: 18

Views: 21634

Answers (6)

AterLux
AterLux

Reputation: 4654

In Postgresql, there are bool_or and bool_and aggregate functions, which work in the way you do expect from min or max over boolean values;

bool_or returns true if there is at least one true value, null if all values are null, or false if there are false values without null. That is an equivalent of max.

bool_and returns true only if all not-null values are true, false if there are some false values and null if all values are null. That is an equivalent of min.

select bool_and(t), bool_or(t) from unnest(array[null, true, false]::bool[]) t; -- false, true
select bool_and(t), bool_or(t) from unnest(array[null, true, true]::bool[]) t; -- true, true
select bool_and(t), bool_or(t) from unnest(array[null, false, false]::bool[]) t; -- false, false
select bool_and(t), bool_or(t) from unnest(array[null, null, null]::bool[]) t; -- NULL, null
select bool_and(t), bool_or(t) from unnest(array[]::bool[]) t; -- NULL, NULL

Upvotes: 2

sdgfsdh
sdgfsdh

Reputation: 37095

Another option is ARRAY_AGG:

SELECT 
  id,
  COALESCE(true = ANY(ARRAY_AGG(flag)), false) AS flag
FROM my_table
GROUP BY id

Upvotes: 4

big
big

Reputation: 1938

Here is how one can achieve max(boolean)

CREATE AGGREGATE max(boolean) (
  SFUNC=boolor_statefunc,
  STYPE=bool,
  SORTOP=">"
);

where "boolor_statefunc" is built in function

Upvotes: 4

Sergey Mirvoda
Sergey Mirvoda

Reputation: 3239

Here are some possibilities 

select max(c::int)::boolean, min(c::int)::boolean, bool_or(c) as max_b,bool_and(c) as min_b from
(
        select false as c
  union select true
  union select null
) t

Upvotes: 5

Tomas Greif
Tomas Greif

Reputation: 22663

To sum boolean values, I have created the following custom aggregate function:

create or replace function badd (bigint, boolean)
  returns bigint as
$body$
select $1 + case when true then 1 else 0 end;
$body$ language sql;

create aggregate sum(boolean) (
  sfunc=badd,
  stype=int8,
  initcond='0'
);

Now I can easily sum boolean values or count rows meeting specific condition:

with test (a, b, c) as (
   values
      ('true'::boolean,'a'::varchar, 'd'::text),
      ('true'::boolean,'a'::varchar, 'e'::text),      
      ('false'::boolean,'a'::varchar, 'f'::text),
      ('true'::boolean,'b'::varchar, 'd'::text),
      ('false'::boolean,'b'::varchar, 'd'::text),
      ('true'::boolean,'c'::varchar, 'f'::text),                
      (NULL,'c'::varchar,'d')      
    ) 
select 
   b,
   bsum(a) as sum, -- sum boolean value (TRUE=1, FALSE=0)
   bsum(c = 'd') as dsum -- counts all rows where column c equals to value 'd'
from 
   test
group by
   b

Upvotes: 0

Denis de Bernardy
Denis de Bernardy

Reputation: 78513

Because by definition TRUE equals 1 and FALSE equals 0 I do not understand why casting is necessary.

Per the docs you have quoted in your question, a boolean is not, by definition, 1 for TRUE and 0 for FALSE. It's not true in C either, where TRUE is anything non-zero.

For that matter, nor is it for languages that mimic C in this respect, of which there are many. Nor is it for languages such as Ruby, where anything non-Nil/non-False evaluates to True, including zero and empty strings. Nor is it for POSIX shell and variations thereof, where testing a return code yields TRUE if it is zero, and FALSE for anything non-zero.

Point is, a boolean is a boolean, with all sorts of colorful implementation details from a platform to the next; not an integer.

It's unclear how you were expecting Postgres to average true/false values. I'm suspicious that many if any platform will yield a result for that.

Even summing booleans is awkward: would expecting Postgres to OR the input values, or to count TRUE values?

At any rate, there are some boolean aggregate functions, namely bool_or() and bool_and(). These replace the more standard any() and some(). The reason Postgres deviates from the standard here is due to potential ambiguity. Per the docs:

SELECT b1 = ANY((SELECT b2 FROM t2 ...)) FROM t1 ...;

Here ANY can be considered either as introducing a subquery, or as being an aggregate function, if the subquery returns one row with a Boolean value.

http://www.postgresql.org/docs/current/static/functions-aggregate.html

Upvotes: 14

Related Questions