HAVING: fix array_agg(bool) vs a constant bool array always failing, by reconciling PostgreSQL's scalar ('true'/'false') and array-element ('t'/'f') boolean text forms

Author: PierreSenellart

src/having_semantics.cpp

@@ -49,6 +49,17 @@ bool aggtype_is_boolean(unsigned oid) {
   return oid == BOOLOID;
 }
 
+// array_agg's result type is the array type (e.g. boolean[]); its element type
+// is the comparison domain.  PostgreSQL serialises a scalar bool as
+// 'true'/'false' but a bool array element as 't'/'f', so the array_agg
+// comparison must know when the elements are boolean to reconcile the two.
+bool aggtype_elem_is_boolean(unsigned oid) {
+  if (oid == BOOLOID)
+    return true;
+  Oid elem = get_element_type(oid);
+  return elem == BOOLOID;
+}
+
 // Types handled by the numeric comparison domain (scaled to a common integer
 // grid).  choose() over these is evaluated there -- including ordering
 // comparisons; choose() over any other type falls to the value-as-text domain.

src/having_semantics.hpp

@@ -37,6 +37,10 @@ bool semimod_extract_string_and_K(GenericCircuit &c, gate_t semimod_gate, std::s
 bool aggtype_is_text(unsigned oid);
 bool aggtype_is_integer(unsigned oid);
 bool aggtype_is_boolean(unsigned oid);
+// True if @p oid is boolean, or an array whose element type is boolean.  Used
+// by the array_agg comparison to reconcile PostgreSQL's two boolean text forms
+// (scalar 'true'/'false' vs array-element 't'/'f').
+bool aggtype_elem_is_boolean(unsigned oid);
 bool aggtype_is_numeric(unsigned oid);
 bool parse_array_literal(const std::string &s, std::vector<std::string> &out);
 bool parse_decimal_scaled(const std::string &s, long &mantissa, int &scale);
@@ -437,6 +441,19 @@ void provsql_having(
           kvals.push_back(c.evaluate<SemiringT>(k_gate, mapping, S));
         }
 
+        // Boolean elements: the row values carry the scalar bool text
+        // ('true'/'false') while the constant array's elements come back in
+        // PostgreSQL's array form ('t'/'f').  Canonicalise both sides so the
+        // text comparison below sees the same representation.
+        if (aggtype_elem_is_boolean(aggtype)) {
+          auto canon_bool = [](std::string &s) {
+            if (s == "t" || s == "true"  || s == "1") s = "true";
+            else if (s == "f" || s == "false" || s == "0") s = "false";
+          };
+          for (auto &e : target) canon_bool(e);
+          for (auto &v : vals)   canon_bool(v);
+        }
+
         auto worlds = enumerate_array_agg_worlds(
           vals, target, effective_op == ComparisonOperator::EQ);
         pw_out = combine_exhaustive_worlds(worlds, kvals, /*upset=*/false,

test/expected/having_array_agg.out

@@ -30,3 +30,27 @@ q|g|p
 text =[a,b]|A|0.2500
 text =[a,b]|B|0.0000
 (2 rows)
+add_provenance
+
+(1 row)
+remove_provenance
+
+(1 row)
+q|g|p
+bool =[t]|A|0.2500
+bool =[t]|B|0.5000
+(2 rows)
+remove_provenance
+
+(1 row)
+q|g|p
+bool =[f,t]|A|0.2500
+bool =[f,t]|B|0.0000
+(2 rows)
+remove_provenance
+
+(1 row)
+q|g|p
+bool <>[t]|A|0.5000
+bool <>[t]|B|0.0000
+(2 rows)

test/sql/having_array_agg.sql

@@ -31,5 +31,29 @@ CREATE TABLE r4 AS SELECT g, round(probability_evaluate(provenance())::numeric,4
   FROM haa GROUP BY g HAVING array_agg(nm ORDER BY nm) = ARRAY['a','b'];
 SELECT remove_provenance('r4'); SELECT 'text =[a,b]' AS q, g, p FROM r4 ORDER BY g;
 
+-- Boolean elements: PostgreSQL renders a scalar bool as 'true'/'false' but a
+-- bool array element as 't'/'f'; the array_agg comparison reconciles the two so
+-- the value-as-text match works.  hb: A = {true, false}, B = {true}, p = 0.5.
+CREATE TABLE hb(g text, flag boolean);
+INSERT INTO hb VALUES ('A', true), ('A', false), ('B', true);
+SELECT add_provenance('hb');
+DO $$ BEGIN PERFORM set_prob(provenance(), 0.5) FROM hb; END $$;
+
+-- = ARRAY[true]: only the true row present.                      A 0.25  B 0.5
+CREATE TABLE r5 AS SELECT g, round(probability_evaluate(provenance())::numeric,4) AS p
+  FROM hb GROUP BY g HAVING array_agg(flag ORDER BY flag) = ARRAY[true];
+SELECT remove_provenance('r5'); SELECT 'bool =[t]' AS q, g, p FROM r5 ORDER BY g;
+
+-- = ARRAY[false,true]: both A-rows present (ordered).            A 0.25  B 0
+CREATE TABLE r6 AS SELECT g, round(probability_evaluate(provenance())::numeric,4) AS p
+  FROM hb GROUP BY g HAVING array_agg(flag ORDER BY flag) = ARRAY[false,true];
+SELECT remove_provenance('r6'); SELECT 'bool =[f,t]' AS q, g, p FROM r6 ORDER BY g;
+
+-- <> ARRAY[true]: non-empty and not exactly [true].              A 0.5   B 0
+CREATE TABLE r7 AS SELECT g, round(probability_evaluate(provenance())::numeric,4) AS p
+  FROM hb GROUP BY g HAVING array_agg(flag ORDER BY flag) <> ARRAY[true];
+SELECT remove_provenance('r7'); SELECT 'bool <>[t]' AS q, g, p FROM r7 ORDER BY g;
+
 DROP TABLE r1; DROP TABLE r2; DROP TABLE r3; DROP TABLE r4;
-DROP TABLE haa;
+DROP TABLE r5; DROP TABLE r6; DROP TABLE r7;
+DROP TABLE haa; DROP TABLE hb;