diff --git a/doc/src/sgml/ddl.sgml b/doc/src/sgml/ddl.sgml index cdb1a07e9d3b..15cca2e48c1c 100644 --- a/doc/src/sgml/ddl.sgml +++ b/doc/src/sgml/ddl.sgml @@ -4410,14 +4410,12 @@ ALTER TABLE measurement ATTACH PARTITION measurement_y2008m02 As mentioned earlier, it is possible to create indexes on partitioned tables so that they are applied automatically to the entire hierarchy. This can be very convenient as not only will all existing partitions be - indexed, but any future partitions will be as well. However, one - limitation when creating new indexes on partitioned tables is that it - is not possible to use the CONCURRENTLY - qualifier, which could lead to long lock times. To avoid this, you can - use CREATE INDEX ON ONLY the partitioned table, which + indexed, but any future partitions will be as well. For more control over + locking of the partitions you can use CREATE INDEX ON ONLY + on the partitioned table, which creates the new index marked as invalid, preventing automatic application to existing partitions. Instead, indexes can then be created individually - on each partition using CONCURRENTLY and + on each partition and attached to the partitioned index on the parent using ALTER INDEX ... ATTACH PARTITION. Once indexes for all the partitions are attached to the parent index, the parent index will diff --git a/doc/src/sgml/ref/create_index.sgml b/doc/src/sgml/ref/create_index.sgml index 208389e80060..5b8b55fef3a3 100644 --- a/doc/src/sgml/ref/create_index.sgml +++ b/doc/src/sgml/ref/create_index.sgml @@ -645,7 +645,10 @@ CREATE [ UNIQUE ] INDEX [ CONCURRENTLY ] [ [ IF NOT EXISTS ] If a problem arises while scanning the table, such as a deadlock or a uniqueness violation in a unique index, the CREATE INDEX - command will fail but leave behind an invalid index. This index + command will fail but leave behind an invalid index. + If this happens while build an index concurrently on a partitioned + table, the command can also leave behind valid or + invalid indexes on table partitions. The invalid index will be ignored for querying purposes because it might be incomplete; however it will still consume update overhead. The psql \d command will report such an index as INVALID: @@ -692,15 +695,6 @@ Indexes: cannot. - - Concurrent builds for indexes on partitioned tables are currently not - supported. However, you may concurrently build the index on each - partition individually and then finally create the partitioned index - non-concurrently in order to reduce the time where writes to the - partitioned table will be locked out. In this case, building the - partitioned index is a metadata only operation. - - diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c index 32ff3ca9a28d..c4d1171b9763 100644 --- a/src/backend/commands/indexcmds.c +++ b/src/backend/commands/indexcmds.c @@ -98,6 +98,11 @@ static char *ChooseIndexName(const char *tabname, Oid namespaceId, bool primary, bool isconstraint); static char *ChooseIndexNameAddition(const List *colnames); static List *ChooseIndexColumnNames(const List *indexElems); +static void DefineIndexConcurrentInternal(Oid relationId, + Oid indexRelationId, + IndexInfo *indexInfo, + LOCKTAG heaplocktag, + LockRelId heaprelid); static void ReindexIndex(const ReindexStmt *stmt, const ReindexParams *params, bool isTopLevel); static void RangeVarCallbackForReindexIndex(const RangeVar *relation, @@ -573,7 +578,6 @@ DefineIndex(Oid tableId, amoptions_function amoptions; bool exclusion; bool partitioned; - bool safe_index; Datum reloptions; int16 *coloptions; IndexInfo *indexInfo; @@ -581,12 +585,10 @@ DefineIndex(Oid tableId, bits16 constr_flags; int numberOfAttributes; int numberOfKeyAttributes; - TransactionId limitXmin; ObjectAddress address; LockRelId heaprelid; LOCKTAG heaplocktag; LOCKMODE lockmode; - Snapshot snapshot; Oid root_save_userid; int root_save_sec_context; int root_save_nestlevel; @@ -724,20 +726,6 @@ DefineIndex(Oid tableId, * partition. */ partitioned = rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE; - if (partitioned) - { - /* - * Note: we check 'stmt->concurrent' rather than 'concurrent', so that - * the error is thrown also for temporary tables. Seems better to be - * consistent, even though we could do it on temporary table because - * we're not actually doing it concurrently. - */ - if (stmt->concurrent) - ereport(ERROR, - (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), - errmsg("cannot create index on partitioned table \"%s\" concurrently", - RelationGetRelationName(rel)))); - } /* * Don't try to CREATE INDEX on temp tables of other backends. @@ -1172,10 +1160,6 @@ DefineIndex(Oid tableId, } } - /* Is index safe for others to ignore? See set_indexsafe_procflags() */ - safe_index = indexInfo->ii_Expressions == NIL && - indexInfo->ii_Predicate == NIL; - /* * Report index creation if appropriate (delay this till after most of the * error checks) @@ -1240,6 +1224,11 @@ DefineIndex(Oid tableId, if (pd->nparts != 0) flags |= INDEX_CREATE_INVALID; } + else if (concurrent && OidIsValid(parentIndexId)) + { + /* If concurrent, initially build index partitions as "invalid" */ + flags |= INDEX_CREATE_INVALID; + } if (stmt->deferrable) constr_flags |= INDEX_CONSTR_CREATE_DEFERRABLE; @@ -1557,21 +1546,7 @@ DefineIndex(Oid tableId, */ if (invalidate_parent) { - Relation pg_index = table_open(IndexRelationId, RowExclusiveLock); - HeapTuple tup, - newtup; - - tup = SearchSysCache1(INDEXRELID, - ObjectIdGetDatum(indexRelationId)); - if (!HeapTupleIsValid(tup)) - elog(ERROR, "cache lookup failed for index %u", - indexRelationId); - newtup = heap_copytuple(tup); - ((Form_pg_index) GETSTRUCT(newtup))->indisvalid = false; - CatalogTupleUpdate(pg_index, &tup->t_self, newtup); - ReleaseSysCache(tup); - table_close(pg_index, RowExclusiveLock); - heap_freetuple(newtup); + index_set_state_flags(indexRelationId, INDEX_DROP_CLEAR_VALID); /* * CCI here to make this update visible, in case this recurses @@ -1583,37 +1558,49 @@ DefineIndex(Oid tableId, /* * Indexes on partitioned tables are not themselves built, so we're - * done here. + * done here in the non-concurrent case. */ - AtEOXact_GUC(false, root_save_nestlevel); - SetUserIdAndSecContext(root_save_userid, root_save_sec_context); - table_close(rel, NoLock); - if (!OidIsValid(parentIndexId)) - pgstat_progress_end_command(); - else + if (!concurrent) { - /* Update progress for an intermediate partitioned index itself */ - pgstat_progress_incr_param(PROGRESS_CREATEIDX_PARTITIONS_DONE, 1); - } + AtEOXact_GUC(false, root_save_nestlevel); + SetUserIdAndSecContext(root_save_userid, root_save_sec_context); + table_close(rel, NoLock); - return address; + if (!OidIsValid(parentIndexId)) + pgstat_progress_end_command(); + else + { + /* + * Update progress for an intermediate partitioned index + * itself + */ + pgstat_progress_incr_param(PROGRESS_CREATEIDX_PARTITIONS_DONE, 1); + } + + return address; + } } AtEOXact_GUC(false, root_save_nestlevel); SetUserIdAndSecContext(root_save_userid, root_save_sec_context); - if (!concurrent) + /* + * All done in the non-concurrent case, and when building catalog entries + * of partitions for CIC. + */ + if (!concurrent || OidIsValid(parentIndexId)) { - /* Close the heap and we're done, in the non-concurrent case */ table_close(rel, NoLock); /* * If this is the top-level index, the command is done overall; - * otherwise, increment progress to report one child index is done. + * otherwise (when being called recursively), increment progress to + * report that one child index is done. Except in the concurrent + * (catalog-only) case, which is handled later. */ if (!OidIsValid(parentIndexId)) pgstat_progress_end_command(); - else + else if (!concurrent) pgstat_progress_incr_param(PROGRESS_CREATEIDX_PARTITIONS_DONE, 1); return address; @@ -1624,6 +1611,141 @@ DefineIndex(Oid tableId, SET_LOCKTAG_RELATION(heaplocktag, heaprelid.dbId, heaprelid.relId); table_close(rel, NoLock); + if (!partitioned) + { + /* CREATE INDEX CONCURRENTLY on a nonpartitioned table */ + DefineIndexConcurrentInternal(tableId, indexRelationId, + indexInfo, heaplocktag, heaprelid); + pgstat_progress_end_command(); + return address; + } + else + { + /* + * For CIC on a partitioned table, finish by building indexes on + * partitions + */ + + ListCell *lc; + List *childs; + List *tosetvalid = NIL; + MemoryContext cic_context, + old_context; + + /* Create special memory context for cross-transaction storage */ + cic_context = AllocSetContextCreate(PortalContext, + "Create index concurrently", + ALLOCSET_DEFAULT_SIZES); + + old_context = MemoryContextSwitchTo(cic_context); + childs = find_all_inheritors(indexRelationId, ShareUpdateExclusiveLock, NULL); + MemoryContextSwitchTo(old_context); + + foreach(lc, childs) + { + Oid indrelid = lfirst_oid(lc); + Oid tabrelid; + char relkind; + + /* + * Partition could have been dropped, since we looked it up. In + * this case consider it done and go to the next one. + */ + tabrelid = IndexGetRelation(indrelid, true); + if (!tabrelid) + { + pgstat_progress_incr_param(PROGRESS_CREATEIDX_PARTITIONS_DONE, 1); + continue; + } + rel = try_table_open(tabrelid, ShareUpdateExclusiveLock); + if (!rel) + { + pgstat_progress_incr_param(PROGRESS_CREATEIDX_PARTITIONS_DONE, 1); + continue; + } + + /* + * Pre-existing partitions which were ATTACHED were already + * counted in the progress report. + */ + if (get_index_isvalid(indrelid)) + { + table_close(rel, ShareUpdateExclusiveLock); + continue; + } + + /* + * Partitioned indexes are counted in the progress report, but + * don't need to be further processed. + */ + relkind = get_rel_relkind(indrelid); + if (!RELKIND_HAS_STORAGE(relkind)) + { + /* The toplevel index doesn't count towards "partitions done" */ + if (indrelid != indexRelationId) + pgstat_progress_incr_param(PROGRESS_CREATEIDX_PARTITIONS_DONE, 1); + + /* + * Build up a list of all the intermediate partitioned tables + * which will later need to be set valid. + */ + old_context = MemoryContextSwitchTo(cic_context); + tosetvalid = lappend_oid(tosetvalid, indrelid); + MemoryContextSwitchTo(old_context); + table_close(rel, ShareUpdateExclusiveLock); + continue; + } + + heaprelid = rel->rd_lockInfo.lockRelId; + + /* + * Close the table but retain the lock, that should be extended to + * session level in DefineIndexConcurrentInternal. + */ + table_close(rel, NoLock); + SET_LOCKTAG_RELATION(heaplocktag, heaprelid.dbId, heaprelid.relId); + + /* Process each partition in a separate transaction */ + DefineIndexConcurrentInternal(tabrelid, indrelid, indexInfo, + heaplocktag, heaprelid); + + PushActiveSnapshot(GetTransactionSnapshot()); + pgstat_progress_incr_param(PROGRESS_CREATEIDX_PARTITIONS_DONE, 1); + } + + /* Set as valid all partitioned indexes, including the parent */ + foreach(lc, tosetvalid) + { + Oid indrelid = lfirst_oid(lc); + Relation indrel = try_index_open(indrelid, ShareUpdateExclusiveLock); + + if (!indrel) + continue; + index_set_state_flags(indrelid, INDEX_CREATE_SET_READY); + CommandCounterIncrement(); + index_set_state_flags(indrelid, INDEX_CREATE_SET_VALID); + index_close(indrel, ShareUpdateExclusiveLock); + } + + MemoryContextDelete(cic_context); + pgstat_progress_end_command(); + PopActiveSnapshot(); + return address; + } +} + + +static void +DefineIndexConcurrentInternal(Oid tableId, Oid indexRelationId, IndexInfo *indexInfo, + LOCKTAG heaplocktag, LockRelId heaprelid) +{ + TransactionId limitXmin; + Snapshot snapshot; + + /* Is index safe for others to ignore? See set_indexsafe_procflags() */ + bool safe_index = indexInfo->ii_Expressions == NIL && + indexInfo->ii_Predicate == NIL; + /* * For a concurrent build, it's important to make the catalog entries * visible to other transactions before we start to build the index. That @@ -1827,10 +1949,6 @@ DefineIndex(Oid tableId, * Last thing to do is release the session-level lock on the parent table. */ UnlockRelationIdForSession(&heaprelid, ShareUpdateExclusiveLock); - - pgstat_progress_end_command(); - - return address; } diff --git a/src/test/isolation/expected/partitioned-cic.out b/src/test/isolation/expected/partitioned-cic.out new file mode 100644 index 000000000000..b66acc6f6a28 --- /dev/null +++ b/src/test/isolation/expected/partitioned-cic.out @@ -0,0 +1,135 @@ +Parsed test spec with 3 sessions + +starting permutation: lock_p1 cic insert drop2 commit chk_content +step lock_p1: lock cictab_part_1 in row exclusive mode; +step cic: CREATE INDEX CONCURRENTLY ON cictab(i); +step insert: insert into cictab values (1, 1), (11, 1); +step drop2: DROP TABLE cictab_part_2; +step commit: COMMIT; +step cic: <... completed> +step chk_content: + set enable_seqscan to off; + explain (costs off) select * from cictab where i > 0; + select * from cictab where i > 0; + +QUERY PLAN +------------------------------------------------------------ +Index Scan using cictab_part_1_i_idx on cictab_part_1 cictab + Index Cond: (i > 0) +(2 rows) + +i|j +-+- +1|0 +1|1 +(2 rows) + + +starting permutation: lock_p2 cic insert drop1 commit chk_content +step lock_p2: lock cictab_part_2 in row exclusive mode; +step cic: CREATE INDEX CONCURRENTLY ON cictab(i); +step insert: insert into cictab values (1, 1), (11, 1); +step drop1: DROP TABLE cictab_part_1; +step commit: COMMIT; +step cic: <... completed> +step chk_content: + set enable_seqscan to off; + explain (costs off) select * from cictab where i > 0; + select * from cictab where i > 0; + +QUERY PLAN +------------------------------------------------------------ +Index Scan using cictab_part_2_i_idx on cictab_part_2 cictab + Index Cond: (i > 0) +(2 rows) + + i|j +--+- +11|0 +11|1 +(2 rows) + + +starting permutation: lock_p1 cic insert detach2 commit chk_content chk_content_part2 +step lock_p1: lock cictab_part_1 in row exclusive mode; +step cic: CREATE INDEX CONCURRENTLY ON cictab(i); +step insert: insert into cictab values (1, 1), (11, 1); +step detach2: ALTER TABLE cictab DETACH PARTITION cictab_part_2; +step commit: COMMIT; +step cic: <... completed> +step chk_content: + set enable_seqscan to off; + explain (costs off) select * from cictab where i > 0; + select * from cictab where i > 0; + +QUERY PLAN +------------------------------------------------------------ +Index Scan using cictab_part_1_i_idx on cictab_part_1 cictab + Index Cond: (i > 0) +(2 rows) + +i|j +-+- +1|0 +1|1 +(2 rows) + +step chk_content_part2: + set enable_seqscan to off; + explain (costs off) select * from cictab_part_2 where i > 0; + select * from cictab_part_2 where i > 0; + +QUERY PLAN +----------------------------------------------------- +Index Scan using cictab_part_2_i_idx on cictab_part_2 + Index Cond: (i > 0) +(2 rows) + + i|j +--+- +11|0 +11|1 +(2 rows) + + +starting permutation: lock_p2 cic insert detach1 commit chk_content chk_content_part1 +step lock_p2: lock cictab_part_2 in row exclusive mode; +step cic: CREATE INDEX CONCURRENTLY ON cictab(i); +step insert: insert into cictab values (1, 1), (11, 1); +step detach1: ALTER TABLE cictab DETACH PARTITION cictab_part_1; +step commit: COMMIT; +step cic: <... completed> +step chk_content: + set enable_seqscan to off; + explain (costs off) select * from cictab where i > 0; + select * from cictab where i > 0; + +QUERY PLAN +------------------------------------------------------------ +Index Scan using cictab_part_2_i_idx on cictab_part_2 cictab + Index Cond: (i > 0) +(2 rows) + + i|j +--+- +11|0 +11|1 +(2 rows) + +step chk_content_part1: + set enable_seqscan to off; + explain (costs off) select * from cictab_part_1 where i > 0; + select * from cictab_part_1 where i > 0; + +QUERY PLAN +----------------------------------------------------- +Index Scan using cictab_part_1_i_idx on cictab_part_1 + Index Cond: (i > 0) +(2 rows) + +i|j +-+- +1|0 +1|1 +(2 rows) + diff --git a/src/test/isolation/isolation_schedule b/src/test/isolation/isolation_schedule index 143109aa4da9..765340088cde 100644 --- a/src/test/isolation/isolation_schedule +++ b/src/test/isolation/isolation_schedule @@ -115,3 +115,4 @@ test: serializable-parallel-2 test: serializable-parallel-3 test: matview-write-skew test: lock-nowait +test: partitioned-cic diff --git a/src/test/isolation/specs/partitioned-cic.spec b/src/test/isolation/specs/partitioned-cic.spec new file mode 100644 index 000000000000..95f0bb2b47a8 --- /dev/null +++ b/src/test/isolation/specs/partitioned-cic.spec @@ -0,0 +1,57 @@ +# Test the ability to drop/detach partitions while CREATE INDEX CONCURRENTLY is running. +# To achieve this, start a transaction that will pause CIC in progress by +# locking a partition in row exclusive mode, giving us a change to drop/detach another partition. +# Dropping/detaching is tested for each partition to test two scenarios: +# when the partition has already been indexed and when it's yet to be indexed. + +setup { + create table cictab(i int, j int) partition by range(i); + create table cictab_part_1 partition of cictab for values from (0) to (10); + create table cictab_part_2 partition of cictab for values from (10) to (20); + + insert into cictab values (1, 0), (11, 0); +} + +teardown { + drop table if exists cictab_part_1; + drop table if exists cictab_part_2; + drop table cictab; +} + +session s1 +setup {BEGIN;} +step lock_p1 { lock cictab_part_1 in row exclusive mode; } +step lock_p2 { lock cictab_part_2 in row exclusive mode; } +step commit { COMMIT; } + +session s2 +step cic { CREATE INDEX CONCURRENTLY ON cictab(i); } +step chk_content { + set enable_seqscan to off; + explain (costs off) select * from cictab where i > 0; + select * from cictab where i > 0; +} + +step chk_content_part1 { + set enable_seqscan to off; + explain (costs off) select * from cictab_part_1 where i > 0; + select * from cictab_part_1 where i > 0; +} + +step chk_content_part2 { + set enable_seqscan to off; + explain (costs off) select * from cictab_part_2 where i > 0; + select * from cictab_part_2 where i > 0; +} + +session s3 +step detach1 { ALTER TABLE cictab DETACH PARTITION cictab_part_1; } +step detach2 { ALTER TABLE cictab DETACH PARTITION cictab_part_2; } +step drop1 { DROP TABLE cictab_part_1; } +step drop2 { DROP TABLE cictab_part_2; } +step insert { insert into cictab values (1, 1), (11, 1); } + +permutation lock_p1 cic insert drop2 commit chk_content +permutation lock_p2 cic insert drop1 commit chk_content +permutation lock_p1 cic insert detach2 commit chk_content chk_content_part2 +permutation lock_p2 cic insert detach1 commit chk_content chk_content_part1 diff --git a/src/test/regress/expected/indexing.out b/src/test/regress/expected/indexing.out index bcf1db11d731..c6c5ae4c9ea4 100644 --- a/src/test/regress/expected/indexing.out +++ b/src/test/regress/expected/indexing.out @@ -50,11 +50,130 @@ select relname, relkind, relhassubclass, inhparent::regclass (8 rows) drop table idxpart; --- Some unsupported features +-- CIC on partitioned table create table idxpart (a int, b int, c text) partition by range (a); -create table idxpart1 partition of idxpart for values from (0) to (10); -create index concurrently on idxpart (a); -ERROR: cannot create index on partitioned table "idxpart" concurrently +create table idxpart1 partition of idxpart for values from (0) to (10) partition by range(a); +create table idxpart11 partition of idxpart1 for values from (0) to (10) partition by range(a); +create table idxpart111 partition of idxpart11 default partition by range(a); +create table idxpart1111 partition of idxpart111 default partition by range(a); +create table idxpart2 partition of idxpart for values from (10) to (20); +create table idxpart3 partition of idxpart for values from (30) to (40) partition by range(a); +create table idxpart31 partition of idxpart3 default; +insert into idxpart2 values(10),(10); -- not unique +create index concurrently on idxpart11 (a); -- partitioned and partition, with no leaves +create index concurrently on idxpart1 (a); -- partitioned and partition +create index concurrently on idxpart2 (a); -- leaf +create index concurrently on idxpart (a); -- partitioned +create unique index concurrently on idxpart (a); -- partitioned, unique failure +ERROR: could not create unique index "idxpart2_a_idx1" +DETAIL: Key (a)=(10) is duplicated. +\d idxpart + Partitioned table "public.idxpart" + Column | Type | Collation | Nullable | Default +--------+---------+-----------+----------+--------- + a | integer | | | + b | integer | | | + c | text | | | +Partition key: RANGE (a) +Indexes: + "idxpart_a_idx" btree (a) + "idxpart_a_idx1" UNIQUE, btree (a) INVALID +Number of partitions: 3 (Use \d+ to list them.) + +\d idxpart1 + Partitioned table "public.idxpart1" + Column | Type | Collation | Nullable | Default +--------+---------+-----------+----------+--------- + a | integer | | | + b | integer | | | + c | text | | | +Partition of: idxpart FOR VALUES FROM (0) TO (10) +Partition key: RANGE (a) +Indexes: + "idxpart1_a_idx" btree (a) + "idxpart1_a_idx1" UNIQUE, btree (a) INVALID +Number of partitions: 1 (Use \d+ to list them.) + +\d idxpart11 + Partitioned table "public.idxpart11" + Column | Type | Collation | Nullable | Default +--------+---------+-----------+----------+--------- + a | integer | | | + b | integer | | | + c | text | | | +Partition of: idxpart1 FOR VALUES FROM (0) TO (10) +Partition key: RANGE (a) +Indexes: + "idxpart11_a_idx" btree (a) + "idxpart11_a_idx1" UNIQUE, btree (a) INVALID +Number of partitions: 1 (Use \d+ to list them.) + +\d idxpart111 + Partitioned table "public.idxpart111" + Column | Type | Collation | Nullable | Default +--------+---------+-----------+----------+--------- + a | integer | | | + b | integer | | | + c | text | | | +Partition of: idxpart11 DEFAULT +Partition key: RANGE (a) +Indexes: + "idxpart111_a_idx" btree (a) + "idxpart111_a_idx1" UNIQUE, btree (a) INVALID +Number of partitions: 1 (Use \d+ to list them.) + +\d idxpart1111 + Partitioned table "public.idxpart1111" + Column | Type | Collation | Nullable | Default +--------+---------+-----------+----------+--------- + a | integer | | | + b | integer | | | + c | text | | | +Partition of: idxpart111 DEFAULT +Partition key: RANGE (a) +Indexes: + "idxpart1111_a_idx" btree (a) + "idxpart1111_a_idx1" UNIQUE, btree (a) INVALID +Number of partitions: 0 + +\d idxpart2 + Table "public.idxpart2" + Column | Type | Collation | Nullable | Default +--------+---------+-----------+----------+--------- + a | integer | | | + b | integer | | | + c | text | | | +Partition of: idxpart FOR VALUES FROM (10) TO (20) +Indexes: + "idxpart2_a_idx" btree (a) + "idxpart2_a_idx1" UNIQUE, btree (a) INVALID + +\d idxpart3 + Partitioned table "public.idxpart3" + Column | Type | Collation | Nullable | Default +--------+---------+-----------+----------+--------- + a | integer | | | + b | integer | | | + c | text | | | +Partition of: idxpart FOR VALUES FROM (30) TO (40) +Partition key: RANGE (a) +Indexes: + "idxpart3_a_idx" btree (a) + "idxpart3_a_idx1" UNIQUE, btree (a) INVALID +Number of partitions: 1 (Use \d+ to list them.) + +\d idxpart31 + Table "public.idxpart31" + Column | Type | Collation | Nullable | Default +--------+---------+-----------+----------+--------- + a | integer | | | + b | integer | | | + c | text | | | +Partition of: idxpart3 DEFAULT +Indexes: + "idxpart31_a_idx" btree (a) + "idxpart31_a_idx1" UNIQUE, btree (a) INVALID + drop table idxpart; -- Verify bugfix with query on indexed partitioned table with no partitions -- https://postgr.es/m/20180124162006.pmapfiznhgngwtjf@alvherre.pgsql diff --git a/src/test/regress/sql/indexing.sql b/src/test/regress/sql/indexing.sql index b5cb01c2d709..7a3fe004b644 100644 --- a/src/test/regress/sql/indexing.sql +++ b/src/test/regress/sql/indexing.sql @@ -29,10 +29,30 @@ select relname, relkind, relhassubclass, inhparent::regclass where relname like 'idxpart%' order by relname; drop table idxpart; --- Some unsupported features +-- CIC on partitioned table create table idxpart (a int, b int, c text) partition by range (a); -create table idxpart1 partition of idxpart for values from (0) to (10); -create index concurrently on idxpart (a); +create table idxpart1 partition of idxpart for values from (0) to (10) partition by range(a); +create table idxpart11 partition of idxpart1 for values from (0) to (10) partition by range(a); +create table idxpart111 partition of idxpart11 default partition by range(a); +create table idxpart1111 partition of idxpart111 default partition by range(a); +create table idxpart2 partition of idxpart for values from (10) to (20); +create table idxpart3 partition of idxpart for values from (30) to (40) partition by range(a); +create table idxpart31 partition of idxpart3 default; + +insert into idxpart2 values(10),(10); -- not unique +create index concurrently on idxpart11 (a); -- partitioned and partition, with no leaves +create index concurrently on idxpart1 (a); -- partitioned and partition +create index concurrently on idxpart2 (a); -- leaf +create index concurrently on idxpart (a); -- partitioned +create unique index concurrently on idxpart (a); -- partitioned, unique failure +\d idxpart +\d idxpart1 +\d idxpart11 +\d idxpart111 +\d idxpart1111 +\d idxpart2 +\d idxpart3 +\d idxpart31 drop table idxpart; -- Verify bugfix with query on indexed partitioned table with no partitions