map_partition_varattnos(List*expr,inttarget_varno,

Relationpartrel,Relationparent)

Relationpartrel,Relationparent,

bool*found_whole_row)

{

AttrNumber*part_attnos;

boolfound_whole_row;

boolmy_found_whole_row;

if (expr==NIL)

returnNIL;

target_varno,0,

part_attnos,

RelationGetDescr(parent)->natts,

if (found_whole_row)

elog(ERROR,"unexpected whole-row reference found in partition key");

*found_whole_row=my_found_whole_row;

returnexpr;

}

List*my_qual=NIL,

*result=NIL;

Relationparent;

boolfound_whole_row;

check_stack_depth();

result=map_partition_varattnos(result,1,rel,parent);

result=map_partition_varattnos(result,1,rel,parent,

&found_whole_row);

if (found_whole_row)

elog(ERROR,"unexpected whole-row reference found in partition key");

oldcxt=MemoryContextSwitchTo(CacheMemoryContext);

expr=map_variable_attnos(stringToNode(check[i].ccbin),

1,0,

newattno,tupleDesc->natts,

&found_whole_row);

InvalidOid,&found_whole_row);

map_variable_attnos(def->cooked_default,

1,0,

attmap,RelationGetDescr(rel)->natts,

&found_whole_row);

InvalidOid,&found_whole_row);

if (found_whole_row)

ereport(ERROR,

(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),

Oidpart_relid=lfirst_oid(lc);

Relationpart_rel;

Expr*constr;

boolfound_whole_row;

if (part_relid!=RelationGetRelid(attachRel))

constr=linitial(partConstraint);

tab->partition_constraint= (Expr*)

map_partition_varattnos((List*)constr,1,

part_rel,rel);

part_rel,rel,

&found_whole_row);

if (found_whole_row)

elog(ERROR,"unexpected whole-row reference found in partition key");

if (part_rel!=attachRel)

heap_close(part_rel,NoLock);

mapped_wcoList=map_partition_varattnos(wcoList,

node->nominalRelation,

partrel,rel);

partrel,rel,NULL);

foreach(ll,mapped_wcoList)

{

WithCheckOption*wco=castNode(WithCheckOption,lfirst(ll));

rlist=map_partition_varattnos(returningList,

node->nominalRelation,

partrel,rel);

partrel,rel,NULL);

ExecBuildProjectionInfo(rlist,econtext,slot,&mtstate->ps,

resultRelInfo->ri_RelationDesc->rd_att);

ccbin_node=map_variable_attnos(stringToNode(ccbin),

1,0,

attmap,tupleDesc->natts,

&found_whole_row);

InvalidOid,&found_whole_row);

indexkey=map_variable_attnos(indexkey,

1,0,

attmap,attmap_length,

&found_whole_row);

InvalidOid,&found_whole_row);

if (found_whole_row)

pred_tree=map_variable_attnos(pred_tree,

1,0,

attmap,attmap_length,

&found_whole_row);

InvalidOid,&found_whole_row);

if (found_whole_row)

intsublevels_up;/* (current) nesting depth */

constAttrNumber*attno_map;/* map array for user attnos */

intmap_length;/* number of entries in attno_map[] */

Oidto_rowtype;

bool*found_whole_row;/* output flag */

}map_variable_attnos_context;

{

*(context->found_whole_row)= true;

if (OidIsValid(context->to_rowtype))

{

Assert(var->vartype!=RECORDOID);

if (context->to_rowtype!=var->vartype)

{

ConvertRowtypeExpr*r;

newvar->vartype=context->to_rowtype;

r=makeNode(ConvertRowtypeExpr);

r->arg= (Expr*)newvar;

r->resulttype=var->vartype;

r->convertformat=COERCE_IMPLICIT_CAST;

r->location=-1;

return (Node*)r;

}

}

}

return (Node*)newvar;

}

map_variable_attnos(Node*node,

inttarget_varno,intsublevels_up,

constAttrNumber*attno_map,intmap_length,

bool*found_whole_row)

Oidto_rowtype,bool*found_whole_row)

{

map_variable_attnos_contextcontext;

context.target_varno=target_varno;

context.sublevels_up=sublevels_up;

context.attno_map=attno_map;

context.map_length=map_length;

context.to_rowtype=to_rowtype;

context.found_whole_row=found_whole_row;

*found_whole_row= false;

externList*get_qual_from_partbound(Relationrel,Relationparent,

PartitionBoundSpec*spec);

externList*map_partition_varattnos(List*expr,inttarget_varno,

Relationpartrel,Relationparent);

Relationpartrel,Relationparent,

bool*found_whole_row);

externList*RelationGetPartitionQual(Relationrel);

externExpr*get_partition_qual_relid(Oidrelid);

externNode*map_variable_attnos(Node*node,

inttarget_varno,intsublevels_up,

constAttrNumber*attno_map,intmap_length,

bool*found_whole_row);

Oidto_rowtype,bool*found_whole_row);

externNode*ReplaceVarsFromTargetList(Node*node,

inttarget_varno,intsublevels_up,

(11 rows)

drop table mcrparted;

-- check that wholerow vars in the RETURNING list work with partitioned tables

create table returningwrtest (a int) partition by list (a);

create table returningwrtest1 partition of returningwrtest for values in (1);

insert into returningwrtest values (1) returning returningwrtest;

returningwrtest

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

(1)

(1 row)

-- check also that the wholerow vars in RETURNING list are converted as needed

alter table returningwrtest add b text;

create table returningwrtest2 (b text, c int, a int);

alter table returningwrtest2 drop c;

alter table returningwrtest attach partition returningwrtest2 for values in (2);

insert into returningwrtest values (2, 'foo') returning returningwrtest;

returningwrtest

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

(2,foo)

(1 row)

drop table returningwrtest;

DETAIL: Failing row contains (1, 2, null).

drop view ptv, ptv_wco;

drop table pt, pt1, pt11;

-- check that wholerow vars appearing in WITH CHECK OPTION constraint expressions

-- work fine with partitioned tables

create table wcowrtest (a int) partition by list (a);

create table wcowrtest1 partition of wcowrtest for values in (1);

create view wcowrtest_v as select * from wcowrtest where wcowrtest = '(2)'::wcowrtest with check option;

insert into wcowrtest_v values (1);

ERROR: new row violates check option for view "wcowrtest_v"

DETAIL: Failing row contains (1).

alter table wcowrtest add b text;

create table wcowrtest2 (b text, c int, a int);

alter table wcowrtest2 drop c;

alter table wcowrtest attach partition wcowrtest2 for values in (2);

create table sometable (a int, b text);

insert into sometable values (1, 'a'), (2, 'b');

create view wcowrtest_v2 as

select *

from wcowrtest r

where r in (select s from sometable s where r.a = s.a)

with check option;

-- WITH CHECK qual will be processed with wcowrtest2's

-- rowtype after tuple-routing

insert into wcowrtest_v2 values (2, 'no such row in sometable');

ERROR: new row violates check option for view "wcowrtest_v2"

DETAIL: Failing row contains (2, no such row in sometable).

drop view wcowrtest_v, wcowrtest_v2;

drop table wcowrtest, sometable;

('commons',0), ('d',-10), ('e',0);

select tableoid::regclass,*from mcrpartedorder by a, b;

droptable mcrparted;

createtablereturningwrtest (aint) partition by list (a);

createtablereturningwrtest1 partition of returningwrtest forvaluesin (1);

insert into returningwrtestvalues (1) returning returningwrtest;

altertable returningwrtest add btext;

createtablereturningwrtest2 (btext, cint, aint);

altertable returningwrtest2 drop c;

altertable returningwrtest attach partition returningwrtest2 forvaluesin (2);

insert into returningwrtestvalues (2,'foo') returning returningwrtest;

droptable returningwrtest;

insert into ptv_wcovalues (1,2);

dropview ptv, ptv_wco;

droptable pt, pt1, pt11;

createtablewcowrtest (aint) partition by list (a);

createtablewcowrtest1 partition of wcowrtest forvaluesin (1);

createviewwcowrtest_vasselect*from wcowrtestwhere wcowrtest='(2)'::wcowrtest withcheck option;

insert into wcowrtest_vvalues (1);

altertable wcowrtest add btext;

createtablewcowrtest2 (btext, cint, aint);

altertable wcowrtest2 drop c;

altertable wcowrtest attach partition wcowrtest2 forvaluesin (2);

createtablesometable (aint, btext);

insert into sometablevalues (1,'a'), (2,'b');

from wcowrtest r

where rin (select sfrom sometable swherer.a=s.a)

withcheck option;

insert into wcowrtest_v2values (2,'no such row in sometable');

dropview wcowrtest_v, wcowrtest_v2;

droptable wcowrtest, sometable;