IndexStmt*childStmt=copyObject(stmt);

boolfound_whole_row;

ListCell*lc;

ObjectAddresschildAddr;

Assert(GetUserId()==child_save_userid);

SetUserIdAndSecContext(root_save_userid,

root_save_sec_context);

DefineIndex(childRelid,childStmt,

InvalidOid,/* no predefined OID */

indexRelationId,/* this is our child */

createdConstraintId,

-1,

is_alter_table,check_rights,check_not_in_use,

skip_build,quiet);

DefineIndex(childRelid,childStmt,

InvalidOid,/* no predefined OID */

indexRelationId,/* this is our child */

createdConstraintId,

-1,

is_alter_table,check_rights,

check_not_in_use,

skip_build,quiet);

SetUserIdAndSecContext(child_save_userid,

child_save_sec_context);

if (!get_index_isvalid(childAddr.objectId))

invalidate_parent= true;

}

free_attrmap(attmap);

ReleaseSysCache(tup);

table_close(pg_index,RowExclusiveLock);

heap_freetuple(newtup);

CommandCounterIncrement();

}

}

(5 rows)

drop table parted_inval_tab;

-- Check setup of indisvalid across a complex partition tree on index

-- creation. If one index in a partition index is invalid, so should its

-- partitioned index.

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

create table parted_isvalid_tab_1 partition of parted_isvalid_tab

for values from (1) to (10) partition by range (a);

create table parted_isvalid_tab_2 partition of parted_isvalid_tab

for values from (10) to (20) partition by range (a);

create table parted_isvalid_tab_11 partition of parted_isvalid_tab_1

for values from (1) to (5);

create table parted_isvalid_tab_12 partition of parted_isvalid_tab_1

for values from (5) to (10);

-- create an invalid index on one of the partitions.

insert into parted_isvalid_tab_11 values (1, 0);

create index concurrently parted_isvalid_idx_11 on parted_isvalid_tab_11 ((a/b));

ERROR: division by zero

-- The previous invalid index is selected, invalidating all the indexes up to

-- the top-most parent.

create index parted_isvalid_idx on parted_isvalid_tab ((a/b));

select indexrelid::regclass, indisvalid,

indrelid::regclass, inhparent::regclass

from pg_index idx left join

pg_inherits inh on (idx.indexrelid = inh.inhrelid)

where indexrelid::regclass::text like 'parted_isvalid%'

order by indexrelid::regclass::text collate "C";

indexrelid | indisvalid | indrelid | inhparent

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

parted_isvalid_idx | f | parted_isvalid_tab |

parted_isvalid_idx_11 | f | parted_isvalid_tab_11 | parted_isvalid_tab_1_expr_idx

parted_isvalid_tab_12_expr_idx | t | parted_isvalid_tab_12 | parted_isvalid_tab_1_expr_idx

parted_isvalid_tab_1_expr_idx | f | parted_isvalid_tab_1 | parted_isvalid_idx

parted_isvalid_tab_2_expr_idx | t | parted_isvalid_tab_2 | parted_isvalid_idx

(5 rows)

drop table parted_isvalid_tab;

where indexrelid::regclass::textlike'parted_inval%'

order by indexrelid::regclass::text collate"C";

droptable parted_inval_tab;

createtableparted_isvalid_tab (aint, bint) partition by range (a);

createtableparted_isvalid_tab_1 partition of parted_isvalid_tab

forvaluesfrom (1) to (10) partition by range (a);

createtableparted_isvalid_tab_2 partition of parted_isvalid_tab

forvaluesfrom (10) to (20) partition by range (a);

createtableparted_isvalid_tab_11 partition of parted_isvalid_tab_1

forvaluesfrom (1) to (5);

createtableparted_isvalid_tab_12 partition of parted_isvalid_tab_1

forvaluesfrom (5) to (10);

insert into parted_isvalid_tab_11values (1,0);

createindexconcurrently parted_isvalid_idx_11on parted_isvalid_tab_11 ((a/b));

createindexparted_isvalid_idxon parted_isvalid_tab ((a/b));

select indexrelid::regclass, indisvalid,

indrelid::regclass, inhparent::regclass

from pg_index idxleft join

pg_inherits inhon (idx.indexrelid=inh.inhrelid)

where indexrelid::regclass::textlike'parted_isvalid%'

order by indexrelid::regclass::text collate"C";

droptable parted_isvalid_tab;