{

PartClauseInfo*partclause;

if (noteq)

{

List*new_clauses;

List*or_clause;

BooleanTest*new_booltest= (BooleanTest*)copyObject(clause);

NullTest*nulltest;

Assert(IsA(clause,BooleanTest));

if (new_booltest->booltesttype==IS_NOT_TRUE)

new_booltest->booltesttype=IS_FALSE;

elseif (new_booltest->booltesttype==IS_NOT_FALSE)

new_booltest->booltesttype=IS_TRUE;

{

Assert(false);

}

nulltest=makeNode(NullTest);

nulltest->arg=copyObject(partkey);

nulltest->nulltesttype=IS_NULL;

nulltest->argisrow= false;

nulltest->location=-1;

new_clauses=list_make2(new_booltest,nulltest);

or_clause=list_make1(makeBoolExpr(OR_EXPR,new_clauses,-1));

*clause_steps=gen_partprune_steps_internal(context,or_clause);

if (context->contradictory)

returnPARTCLAUSE_MATCH_CONTRADICT;/* shouldn't happen */

elseif (*clause_steps==NIL)

returnPARTCLAUSE_UNSUPPORTED;/* step generation failed */

returnPARTCLAUSE_MATCH_STEPS;

}

partclause= (PartClauseInfo*)palloc(sizeof(PartClauseInfo));

partclause->keyno=partkeyidx;

partclause->opno=BooleanEqualOperator;

partclause->op_is_ne=noteq;

partclause->op_is_ne=false;

partclause->expr=expr;

partclause->cmpfn=part_scheme->partsupfunc[partkeyidx].fn_oid;

t

(2 rows)

-- try some other permutations with a NULL partition instead of a DEFAULT

delete from boolpart where a is null;

create table boolpart_null partition of boolpart for values in (null);

insert into boolpart values(null);

explain (costs off) select * from boolpart where a is not true;

QUERY PLAN

--------------------------------------------

Append

-> Seq Scan on boolpart_f boolpart_1

Filter: (a IS NOT TRUE)

-> Seq Scan on boolpart_null boolpart_2

Filter: (a IS NOT TRUE)

(5 rows)

explain (costs off) select * from boolpart where a is not true and a is not false;

QUERY PLAN

--------------------------------------------------

Seq Scan on boolpart_null boolpart

Filter: ((a IS NOT TRUE) AND (a IS NOT FALSE))

(2 rows)

explain (costs off) select * from boolpart where a is not false;

QUERY PLAN

--------------------------------------------

Append

-> Seq Scan on boolpart_t boolpart_1

Filter: (a IS NOT FALSE)

-> Seq Scan on boolpart_null boolpart_2

Filter: (a IS NOT FALSE)

(5 rows)

select * from boolpart where a is not true;

a

---

f

(2 rows)

select * from boolpart where a is not true and a is not false;

a

---

(1 row)

select * from boolpart where a is not false;

a

---

t

(2 rows)

-- inverse boolean partitioning - a seemingly unlikely design, but we've got

-- code for it, so we'd better test it.

create table iboolpart (a bool) partition by list ((not a));

f

(2 rows)

-- Try some other permutations with a NULL partition instead of a DEFAULT

delete from iboolpart where a is null;

create table iboolpart_null partition of iboolpart for values in (null);

insert into iboolpart values(null);

-- Pruning shouldn't take place for these. Just check the result is correct

select * from iboolpart where a is not true;

a

---

f

(2 rows)

select * from iboolpart where a is not true and a is not false;

a

---

(1 row)

select * from iboolpart where a is not false;

a

---

t

(2 rows)

create table boolrangep (a bool, b bool, c int) partition by range (a,b,c);

create table boolrangep_tf partition of boolrangep for values from ('true', 'false', 0) to ('true', 'false', 100);

create table boolrangep_ft partition of boolrangep for values from ('false', 'true', 0) to ('false', 'true', 100);

create table boolrangep_ff1 partition of boolrangep for values from ('false', 'false', 0) to ('false', 'false', 50);

create table boolrangep_ff2 partition of boolrangep for values from ('false', 'false', 50) to ('false', 'false', 100);

create table boolrangep_null partition of boolrangep default;

-- try a more complex case that's been known to trip up pruning in the past

explain (costs off) select * from boolrangep where not a and not b and c = 25;

QUERY PLAN

Filter: ((NOT a) AND (NOT b) AND (c = 25))

(2 rows)

-- ensure we prune boolrangep_tf

explain (costs off) select * from boolrangep where a is not true and not b and c = 25;

QUERY PLAN

------------------------------------------------------------

Append

-> Seq Scan on boolrangep_ff1 boolrangep_1

Filter: ((a IS NOT TRUE) AND (NOT b) AND (c = 25))

-> Seq Scan on boolrangep_ff2 boolrangep_2

Filter: ((a IS NOT TRUE) AND (NOT b) AND (c = 25))

-> Seq Scan on boolrangep_ft boolrangep_3

Filter: ((a IS NOT TRUE) AND (NOT b) AND (c = 25))

-> Seq Scan on boolrangep_null boolrangep_4

Filter: ((a IS NOT TRUE) AND (NOT b) AND (c = 25))

(9 rows)

-- ensure we prune everything apart from boolrangep_tf and boolrangep_null

explain (costs off) select * from boolrangep where a is not false and not b and c = 25;

QUERY PLAN

-------------------------------------------------------------

Append

-> Seq Scan on boolrangep_tf boolrangep_1

Filter: ((a IS NOT FALSE) AND (NOT b) AND (c = 25))

-> Seq Scan on boolrangep_null boolrangep_2

Filter: ((a IS NOT FALSE) AND (NOT b) AND (c = 25))

(5 rows)

-- test scalar-to-array operators

create table coercepart (a varchar) partition by list (a);

create table coercepart_ab partition of coercepart for values in ('ab');

select*from boolpartwhere a is unknown;

select*from boolpartwhere a is not unknown;

deletefrom boolpartwhere a isnull;

createtableboolpart_null partition of boolpart forvaluesin (null);

insert into boolpartvalues(null);

explain (costs off)select*from boolpartwhere a is not true;

explain (costs off)select*from boolpartwhere a is not trueand a is not false;

explain (costs off)select*from boolpartwhere a is not false;

select*from boolpartwhere a is not true;

select*from boolpartwhere a is not trueand a is not false;

select*from boolpartwhere a is not false;

createtableiboolpart (a bool) partition by list ((not a));

select*from iboolpartwhere a is unknown;

select*from iboolpartwhere a is not unknown;

deletefrom iboolpartwhere a isnull;

createtableiboolpart_null partition of iboolpart forvaluesin (null);

insert into iboolpartvalues(null);

select*from iboolpartwhere a is not true;

select*from iboolpartwhere a is not trueand a is not false;

select*from iboolpartwhere a is not false;

createtableboolrangep (a bool, b bool, cint) partition by range (a,b,c);

createtableboolrangep_tf partition of boolrangep forvaluesfrom ('true','false',0) to ('true','false',100);

createtableboolrangep_ft partition of boolrangep forvaluesfrom ('false','true',0) to ('false','true',100);

createtableboolrangep_ff1 partition of boolrangep forvaluesfrom ('false','false',0) to ('false','false',50);

createtableboolrangep_ff2 partition of boolrangep forvaluesfrom ('false','false',50) to ('false','false',100);

createtableboolrangep_null partition of boolrangep default;

explain (costs off)select*from boolrangepwhere not aand not band c=25;

explain (costs off)select*from boolrangepwhere a is not trueand not band c=25;

explain (costs off)select*from boolrangepwhere a is not falseand not band c=25;

createtablecoercepart (avarchar) partition by list (a);

createtablecoercepart_ab partition of coercepart forvaluesin ('ab');