casePARTCLAUSE_MATCH_NULLNESS:

if (!clause_is_not_null)

{

if (bms_is_member(i,notnullkeys))

if (bms_is_member(i,notnullkeys)||

keyclauses[i]!=NIL)

{

context->contradictory= true;

returnNIL;

{

casePARTITION_STRATEGY_LIST:

casePARTITION_STRATEGY_RANGE:

{

PartClauseInfo*last=NULL;

if (btree_clauses[pc->op_strategy]!=NIL)

last=llast(btree_clauses[pc->op_strategy]);

if (last==NULL||

i==last->keyno||i==last->keyno+1)

btree_clauses[pc->op_strategy]=

lappend(btree_clauses[pc->op_strategy],pc);

btree_clauses[pc->op_strategy]=

lappend(btree_clauses[pc->op_strategy],pc);

if (pc->op_strategy==BTLessStrategyNumber||

pc->op_strategy==BTGreaterStrategyNumber)

consider_next_key= false;

break;

}

if (pc->op_strategy==BTLessStrategyNumber||

pc->op_strategy==BTGreaterStrategyNumber)

consider_next_key= false;

break;

casePARTITION_STRATEGY_HASH:

if (pc->op_strategy!=HTEqualStrategyNumber)

List*eq_clauses=btree_clauses[BTEqualStrategyNumber];

List*le_clauses=btree_clauses[BTLessEqualStrategyNumber];

List*ge_clauses=btree_clauses[BTGreaterEqualStrategyNumber];

boolpk_has_clauses[PARTITION_MAX_KEYS];

intstrat;

ListCell*lc1;

List*prefix=NIL;

List*pc_steps;

boolprefix_valid= true;

if (pc->keyno==0)

{

Assert(pc->op_strategy==strat);

pc_steps=get_steps_using_prefix(context,strat,

pc->op_is_ne,

pc->expr,

pc->cmpfn,

0,

NULL,

NIL);

opsteps=list_concat(opsteps,pc_steps);

continue;

}

Assert(pc->keyno>0);

for (i=0;i<pc->keyno;i++)

pk_has_clauses[i]= false;

if (eqpc->keyno==pc->keyno)

break;

if (eqpc->keyno<pc->keyno)

{

prefix=lappend(prefix,eqpc);

pk_has_clauses[eqpc->keyno]= true;

}

}

if (lepc->keyno==pc->keyno)

break;

if (lepc->keyno<pc->keyno)

{

prefix=lappend(prefix,lepc);

pk_has_clauses[lepc->keyno]= true;

}

}

}

if (gepc->keyno==pc->keyno)

break;

if (gepc->keyno<pc->keyno)

{

prefix=lappend(prefix,gepc);

pk_has_clauses[gepc->keyno]= true;

}

}

}

for (i=0;i<pc->keyno;i++)

{

if (!pk_has_clauses[i])

{

prefix_valid= false;

break;

}

}

Assert(pc->op_strategy==strat);

pc_steps=get_steps_using_prefix(context,strat,

pc->op_is_ne,

pc->expr,

pc->cmpfn,

pc->keyno,

NULL,

prefix);

opsteps=list_concat(opsteps,pc_steps);

if (prefix_valid)

{

Assert(pc->op_strategy==strat);

pc_steps=get_steps_using_prefix(context,strat,

pc->op_is_ne,

pc->expr,

pc->cmpfn,

pc->keyno,

NULL,

prefix);

opsteps=list_concat(opsteps,pc_steps);

}

break;

}

}

break;

get_steps_using_prefix(GeneratePruningStepsContext*context,

Bitmapset*step_nullkeys,

List*prefix)

{

Assert(step_nullkeys==NULL||

context->rel->part_scheme->strategy==PARTITION_STRATEGY_HASH);

if (list_length(prefix)==0)

{

ListCell*next_start;

for_each_cell(lc,prefix,start)

{

List*moresteps;

List*step_exprs1,

*step_cmpfns1;

pc=lfirst(lc);

if (pc->keyno==cur_keyno)

{

if (cur_keyno==0)

{

list_free(step_exprs);

list_free(step_cmpfns);

step_exprs=list_make1(pc->expr);

step_cmpfns=list_make1_oid(pc->cmpfn);

}

{

step_exprs=lappend(step_exprs,pc->expr);

step_cmpfns=lappend_oid(step_cmpfns,pc->cmpfn);

}

step_exprs1=list_copy(step_exprs);

step_exprs1=lappend(step_exprs1,pc->expr);

step_cmpfns1=list_copy(step_cmpfns);

step_cmpfns1=lappend_oid(step_cmpfns1,pc->cmpfn);

}

{

step_nullkeys,

prefix,

next_start,

step_exprs,

step_cmpfns);

step_exprs1,

step_cmpfns1);

result=list_concat(result,moresteps);

list_free(step_exprs1);

list_free(step_cmpfns1);

}

}

{

Assert(list_length(step_exprs)==cur_keyno||

!bms_is_empty(step_nullkeys));

Assert(list_length(step_exprs)==cur_keyno);

Assert(context->rel->part_scheme->strategy

list_length(step_exprs)+2+bms_num_members(step_nullkeys)==

context->rel->part_scheme->partnatts);

for_each_cell(lc,prefix,start)

{

PartClauseInfo*pc=lfirst(lc);

reset constraint_exclusion;

reset enable_partition_pruning;

drop table listp;

--

-- Check that gen_prune_steps_from_opexps() works well for various cases of

-- clauses for different partition keys

--

create table rp_prefix_test1 (a int, b varchar) partition by range(a, b);

create table rp_prefix_test1_p1 partition of rp_prefix_test1 for values from (1, 'a') to (1, 'b');

create table rp_prefix_test1_p2 partition of rp_prefix_test1 for values from (2, 'a') to (2, 'b');

-- Don't call get_steps_using_prefix() with the last partition key b plus

-- an empty prefix

explain (costs off) select * from rp_prefix_test1 where a <= 1 and b = 'a';

QUERY PLAN

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

Seq Scan on rp_prefix_test1_p1 rp_prefix_test1

Filter: ((a <= 1) AND ((b)::text = 'a'::text))

(2 rows)

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

create table rp_prefix_test2_p1 partition of rp_prefix_test2 for values from (1, 1, 0) to (1, 1, 10);

create table rp_prefix_test2_p2 partition of rp_prefix_test2 for values from (2, 2, 0) to (2, 2, 10);

-- Don't call get_steps_using_prefix() with the last partition key c plus

-- an invalid prefix (ie, b = 1)

explain (costs off) select * from rp_prefix_test2 where a <= 1 and b = 1 and c >= 0;

QUERY PLAN

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

Seq Scan on rp_prefix_test2_p1 rp_prefix_test2

Filter: ((a <= 1) AND (c >= 0) AND (b = 1))

(2 rows)

create table rp_prefix_test3 (a int, b int, c int, d int) partition by range(a, b, c, d);

create table rp_prefix_test3_p1 partition of rp_prefix_test3 for values from (1, 1, 1, 0) to (1, 1, 1, 10);

create table rp_prefix_test3_p2 partition of rp_prefix_test3 for values from (2, 2, 2, 0) to (2, 2, 2, 10);

-- Test that get_steps_using_prefix() handles a prefix that contains multiple

-- clauses for the partition key b (ie, b >= 1 and b >= 2)

explain (costs off) select * from rp_prefix_test3 where a >= 1 and b >= 1 and b >= 2 and c >= 2 and d >= 0;

QUERY PLAN

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

Seq Scan on rp_prefix_test3_p2 rp_prefix_test3

Filter: ((a >= 1) AND (b >= 1) AND (b >= 2) AND (c >= 2) AND (d >= 0))

(2 rows)

create table hp_prefix_test (a int, b int, c int, d int) partition by hash (a part_test_int4_ops, b part_test_int4_ops, c part_test_int4_ops, d part_test_int4_ops);

create table hp_prefix_test_p1 partition of hp_prefix_test for values with (modulus 2, remainder 0);

create table hp_prefix_test_p2 partition of hp_prefix_test for values with (modulus 2, remainder 1);

-- Test that get_steps_using_prefix() handles non-NULL step_nullkeys

explain (costs off) select * from hp_prefix_test where a = 1 and b is null and c = 1 and d = 1;

QUERY PLAN

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

Seq Scan on hp_prefix_test_p1 hp_prefix_test

Filter: ((b IS NULL) AND (a = 1) AND (c = 1) AND (d = 1))

(2 rows)

drop table rp_prefix_test1;

drop table rp_prefix_test2;

drop table rp_prefix_test3;

drop table hp_prefix_test;

--

-- Check that gen_partprune_steps() detects self-contradiction from clauses

-- regardless of the order of the clauses (Here we use a custom operator to

-- prevent the equivclass.c machinery from reordering the clauses)

--

create operator === (

leftarg = int4,

rightarg = int4,

procedure = int4eq,

commutator = ===,

hashes

);

create operator class part_test_int4_ops2

for type int4

using hash as

operator 1 ===,

function 2 part_hashint4_noop(int4, int8);

create table hp_contradict_test (a int, b int) partition by hash (a part_test_int4_ops2, b part_test_int4_ops2);

create table hp_contradict_test_p1 partition of hp_contradict_test for values with (modulus 2, remainder 0);

create table hp_contradict_test_p2 partition of hp_contradict_test for values with (modulus 2, remainder 1);

explain (costs off) select * from hp_contradict_test where a is null and a === 1 and b === 1;

QUERY PLAN

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

Result

One-Time Filter: false

(2 rows)

explain (costs off) select * from hp_contradict_test where a === 1 and b === 1 and a is null;

QUERY PLAN

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

Result

One-Time Filter: false

(2 rows)

drop table hp_contradict_test;

drop operator class part_test_int4_ops2 using hash;

drop operator ===(int4, int4);