{

SubPlan*subplan=node->subplan;

PlanState*planstate=node->planstate;

intncols=list_length(subplan->paramIds);

intncols=node->numCols;

ExprContext*innerecontext=node->innerecontext;

MemoryContextoldcontext;

longnbuckets;

ALLOCSET_SMALL_SIZES);

sstate->innerecontext=CreateExprContext(estate);

ncols=list_length(subplan->paramIds);

sstate->keyColIdx= (AttrNumber*)palloc(ncols*sizeof(AttrNumber));

for (i=0;i<ncols;i++)

sstate->keyColIdx[i]=i+1;

(int)nodeTag(subplan->testexpr));

oplist=NIL;/* keep compiler quiet */

}

Assert(list_length(oplist)==ncols);

ncols=list_length(oplist);

lefttlist=righttlist=NIL;

sstate->numCols=ncols;

sstate->keyColIdx= (AttrNumber*)palloc(ncols*sizeof(AttrNumber));

sstate->tab_eq_funcoids= (Oid*)palloc(ncols*sizeof(Oid));

sstate->tab_collations= (Oid*)palloc(ncols*sizeof(Oid));

sstate->tab_hash_funcs= (FmgrInfo*)palloc(ncols*sizeof(FmgrInfo));

sstate->tab_eq_funcs= (FmgrInfo*)palloc(ncols*sizeof(FmgrInfo));

sstate->tab_collations= (Oid*)palloc(ncols*sizeof(Oid));

sstate->lhs_hash_funcs= (FmgrInfo*)palloc(ncols*sizeof(FmgrInfo));

sstate->cur_eq_funcs= (FmgrInfo*)palloc(ncols*sizeof(FmgrInfo));

sstate->tab_collations[i-1]=opexpr->inputcollid;

sstate->keyColIdx[i-1]=i;

i++;

}

staticNode*build_subplan(PlannerInfo*root,Plan*plan,PlannerInfo*subroot,

List*plan_params,

SubLinkTypesubLinkType,intsubLinkId,

Node*testexpr,booladjust_testexpr,

Node*testexpr,List*testexpr_paramids,

boolunknownEqFalse);

staticList*generate_subquery_params(PlannerInfo*root,List*tlist,

List**paramIds);

staticNode*convert_testexpr_mutator(Node*node,

convert_testexpr_context*context);

staticboolsubplan_is_hashable(Plan*plan);

staticbooltestexpr_is_hashable(Node*testexpr);

staticbooltestexpr_is_hashable(Node*testexpr,List*param_ids);

staticbooltest_opexpr_is_hashable(OpExpr*testexpr,List*param_ids);

staticboolhash_ok_operator(OpExpr*expr);

staticboolcontain_dml(Node*node);

staticboolcontain_dml_walker(Node*node,void*context);

result=build_subplan(root,plan,subroot,plan_params,

subLinkType,subLinkId,

testexpr,true,isTopQual);

testexpr,NIL,isTopQual);

plan_params,

ANY_SUBLINK,0,

newtestexpr,

false, true));

paramIds,

true));

Assert(hashplan->parParam==NIL);

Assert(hashplan->useHashTable);

hashplan->paramIds=paramIds;

asplan=makeNode(AlternativeSubPlan);

build_subplan(PlannerInfo*root,Plan*plan,PlannerInfo*subroot,

List*plan_params,

SubLinkTypesubLinkType,intsubLinkId,

Node*testexpr,booladjust_testexpr,

Node*testexpr,List*testexpr_paramids,

boolunknownEqFalse)

{

Node*result;

{

if (testexpr&&adjust_testexpr)

if (testexpr&&testexpr_paramids==NIL)

{

List*params;

params);

}

{

splan->testexpr=testexpr;

splan->paramIds=testexpr_paramids;

}

if (subLinkType==ANY_SUBLINK&&

subplan_is_hashable(plan)&&

testexpr_is_hashable(splan->testexpr))

testexpr_is_hashable(splan->testexpr,splan->paramIds))

splan->useHashTable= true;

testexpr_is_hashable(Node*testexpr)

testexpr_is_hashable(Node*testexpr,List*param_ids)

{

if (testexpr&&IsA(testexpr,OpExpr))

{

if (hash_ok_operator((OpExpr*)testexpr))

if (test_opexpr_is_hashable((OpExpr*)testexpr,param_ids))

return true;

}

elseif (is_andclause(testexpr))

if (!IsA(andarg,OpExpr))

return false;

if (!hash_ok_operator((OpExpr*)andarg))

if (!test_opexpr_is_hashable((OpExpr*)andarg,param_ids))

return false;

}

return true;

return false;

}

test_opexpr_is_hashable(OpExpr*testexpr,List*param_ids)

{

if (!hash_ok_operator(testexpr))

return false;

if (list_length(testexpr->args)!=2)

return false;

if (contain_exec_param((Node*)linitial(testexpr->args),param_ids))

return false;

if (contain_var_clause((Node*)lsecond(testexpr->args)))

return false;

return true;

}

staticboolmax_parallel_hazard_walker(Node*node,

max_parallel_hazard_context*context);

staticboolcontain_nonstrict_functions_walker(Node*node,void*context);

staticboolcontain_exec_param_walker(Node*node,List*param_ids);

staticboolcontain_context_dependent_node(Node*clause);

staticboolcontain_context_dependent_node_walker(Node*node,int*flags);

staticboolcontain_leaked_vars_walker(Node*node,void*context);

context);

}

contain_exec_param(Node*clause,List*param_ids)

{

returncontain_exec_param_walker(clause,param_ids);

}

contain_exec_param_walker(Node*node,List*param_ids)

{

if (node==NULL)

return false;

if (IsA(node,Param))

{

Param*p= (Param*)node;

if (p->paramkind==PARAM_EXEC&&

list_member_int(param_ids,p->paramid))

return true;

}

returnexpression_tree_walker(node,contain_exec_param_walker,param_ids);

}

MemoryContexthashtablecxt;/* memory context containing hash tables */

MemoryContexthashtempcxt;/* temp memory context for hash tables */

ExprContext*innerecontext;/* econtext for computing inner tuples */

intnumCols;/* number of columns being hashed */

AttrNumber*keyColIdx;/* control data for hash tables */

Oid*tab_eq_funcoids;/* equality func oids for table

externcharmax_parallel_hazard(Query*parse);

externboolis_parallel_safe(PlannerInfo*root,Node*node);

externboolcontain_nonstrict_functions(Node*clause);

externboolcontain_exec_param(Node*clause,List*param_ids);

externboolcontain_leaked_vars(Node*clause);

externRelidsfind_nonnullable_rels(Node*clause);

insert into outer_text values ('b', null);

create temp table inner_text (c1 text, c2 text);

insert into inner_text values ('a', null);

insert into inner_text values ('123', '456');

select * from outer_text where (f1, f2) not in (select * from inner_text);

f1 | f2

----+----

t

(1 row)

--

-- Test that we don't try to use a hashed subplan if the simplified

-- testexpr isn't of the right shape

--

-- this fails by default, of course

select * from int8_tbl where q1 in (select c1 from inner_text);

ERROR: operator does not exist: bigint = text

LINE 1: select * from int8_tbl where q1 in (select c1 from inner_tex...

^

HINT: No operator matches the given name and argument types. You might need to add explicit type casts.

begin;

-- make an operator to allow it to succeed

create function bogus_int8_text_eq(int8, text) returns boolean

language sql as 'select $1::text = $2';

create operator = (procedure=bogus_int8_text_eq, leftarg=int8, rightarg=text);

explain (costs off)

select * from int8_tbl where q1 in (select c1 from inner_text);

QUERY PLAN

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

Seq Scan on int8_tbl

Filter: (hashed SubPlan 1)

SubPlan 1

-> Seq Scan on inner_text

(4 rows)

select * from int8_tbl where q1 in (select c1 from inner_text);

q1 | q2

-----+------------------

123 | 456

123 | 4567890123456789

(2 rows)

-- inlining of this function results in unusual number of hash clauses,

-- which we can still cope with

create or replace function bogus_int8_text_eq(int8, text) returns boolean

language sql as 'select $1::text = $2 and $1::text = $2';

explain (costs off)

select * from int8_tbl where q1 in (select c1 from inner_text);

QUERY PLAN

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

Seq Scan on int8_tbl

Filter: (hashed SubPlan 1)

SubPlan 1

-> Seq Scan on inner_text

(4 rows)

select * from int8_tbl where q1 in (select c1 from inner_text);

q1 | q2

-----+------------------

123 | 456

123 | 4567890123456789

(2 rows)

-- inlining of this function causes LHS and RHS to be switched,

-- which we can't cope with, so hashing should be abandoned

create or replace function bogus_int8_text_eq(int8, text) returns boolean

language sql as 'select $2 = $1::text';

explain (costs off)

select * from int8_tbl where q1 in (select c1 from inner_text);

QUERY PLAN

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

Seq Scan on int8_tbl

Filter: (SubPlan 1)

SubPlan 1

-> Materialize

-> Seq Scan on inner_text

(5 rows)

select * from int8_tbl where q1 in (select c1 from inner_text);

q1 | q2

-----+------------------

123 | 456

123 | 4567890123456789

(2 rows)

rollback; -- to get rid of the bogus operator

--

-- Test case for planner bug with nested EXISTS handling

--