Alvaro Herrera wrote:
> I'm now working on the ability to build unique indexes (and unique
> constraints) on top of this.
So I think there's not a lot of additional code required to support
unique indexes with the restrictions mentioned; proof-of-concept (with
several holes still) attached.
As before, this is not finished, as there a few things that are wrong
(such as generateClonedIndexStmt taking a RangeVar), and others that I
don't understand (such as why is rd_partkey NULL for partitioned
partitions when DefineIndex cascades to them and the columns are
checked).
I noticed that RelationBuildPartitionKey is generating a partition key
in a temp context, then creating a private context and copying the key
into that. That seems leftover from some previous iteration of some
other patch; I think it's pretty reasonable to create the new context
right from the start and allocate the key there directly instead. Then
there's no need for copy_partition_key at all.
Anyway, here is a preliminary submission before I close shop for the
week.
--
Álvaro Herrera https://www.2ndQuadrant.com/
PostgreSQL Development, 24x7 Support, Remote DBA, Training & Services
>From 37e683e352df5f3e6c110d94881abe888e36953e Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvhe...@alvh.no-ip.org>
Date: Mon, 16 Oct 2017 12:01:12 +0200
Subject: [PATCH v2 1/7] Tweak index_create/index_constraint_create APIs
I was annoyed by index_create and index_constraint_create respective
APIs. It's too easy to get confused when adding a new behavioral flag
given the large number of boolean flags they already have. Turning them
into a flags bitmask makes that code easier to read, as in the attached
patch.
I split the flags in two -- one set for index_create directly and
another related to constraints. index_create() itself receives both,
and then passes down the constraint one to index_constraint_create. It
is shorter in LOC terms to create a single set mixing all the values,
but it seemed to make more sense this way. Also, I chose not to turn
the booleans 'allow_sytem_table_mods' and 'is_internal' into flag bits
because of the different way they interact with this code.
---
src/backend/catalog/index.c | 101 +++++++++++++++++++--------------------
src/backend/catalog/toasting.c | 3 +-
src/backend/commands/indexcmds.c | 33 +++++++++----
src/backend/commands/tablecmds.c | 13 +++--
src/include/catalog/index.h | 29 ++++++-----
5 files changed, 100 insertions(+), 79 deletions(-)
diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index c7b2f031f0..17faeffada 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -680,19 +680,25 @@ UpdateIndexRelation(Oid indexoid,
* classObjectId: array of index opclass OIDs, one per index column
* coloptions: array of per-index-column indoption settings
* reloptions: AM-specific options
- * isprimary: index is a PRIMARY KEY
- * isconstraint: index is owned by PRIMARY KEY, UNIQUE, or EXCLUSION constraint
- * deferrable: constraint is DEFERRABLE
- * initdeferred: constraint is INITIALLY DEFERRED
+ * flags: bitmask that can include any combination of these bits:
+ * INDEX_CREATE_IS_PRIMARY
+ * the index is a primary key
+ * INDEX_CREATE_ADD_CONSTRAINT:
+ * invoke index_constraint_create also
+ * INDEX_CREATE_SKIP_BUILD:
+ * skip the index_build() step for the moment; caller must
do it
+ * later (typically via reindex_index())
+ * INDEX_CREATE_CONCURRENT:
+ * do not lock the table against writers. The index will
be
+ * marked "invalid" and the caller must take additional
steps
+ * to fix it up.
+ * INDEX_CREATE_IF_NOT_EXISTS:
+ * do not throw an error if a relation with the same name
+ * already exists.
+ * constr_flags: flags passed to index_constraint_create
+ * (only if INDEX_CREATE_ADD_CONSTRAINT is set)
* allow_system_table_mods: allow table to be a system catalog
- * skip_build: true to skip the index_build() step for the moment; caller
- * must do it later (typically via reindex_index())
- * concurrent: if true, do not lock the table against writers. The index
- * will be marked "invalid" and the caller must take additional
steps
- * to fix it up.
* is_internal: if true, post creation hook for new index
- * if_not_exists: if true, do not throw an error if a relation with
- * the same name already exists.
*
* Returns the OID of the created index.
*/
@@ -709,15 +715,10 @@ index_create(Relation heapRelation,
Oid *classObjectId,
int16 *coloptions,
Datum reloptions,
- bool isprimary,
- bool isconstraint,
- bool deferrable,
- bool initdeferred,
+ uint16 flags,
+ uint16 constr_flags,
bool allow_system_table_mods,
- bool skip_build,
- bool concurrent,
- bool is_internal,
- bool if_not_exists)
+ bool is_internal)
{
Oid heapRelationId = RelationGetRelid(heapRelation);
Relation pg_class;
@@ -729,6 +730,12 @@ index_create(Relation heapRelation,
Oid namespaceId;
int i;
char relpersistence;
+ bool isprimary = flags & INDEX_CREATE_IS_PRIMARY;
+ bool concurrent = flags & INDEX_CREATE_CONCURRENT;
+
+ /* constraint flags can only be set when constraint is requested */
+ Assert((constr_flags == 0) ||
+ ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0));
is_exclusion = (indexInfo->ii_ExclusionOps != NULL);
@@ -794,7 +801,7 @@ index_create(Relation heapRelation,
if (get_relname_relid(indexRelationName, namespaceId))
{
- if (if_not_exists)
+ if ((flags & INDEX_CREATE_IF_NOT_EXISTS) != 0)
{
ereport(NOTICE,
(errcode(ERRCODE_DUPLICATE_TABLE),
@@ -917,7 +924,7 @@ index_create(Relation heapRelation,
UpdateIndexRelation(indexRelationId, heapRelationId, indexInfo,
collationObjectId,
classObjectId, coloptions,
isprimary, is_exclusion,
- !deferrable,
+ (constr_flags &
INDEX_CONSTR_CREATE_DEFERRABLE) == 0,
!concurrent);
/*
@@ -943,7 +950,7 @@ index_create(Relation heapRelation,
myself.objectId = indexRelationId;
myself.objectSubId = 0;
- if (isconstraint)
+ if ((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0)
{
char constraintType;
@@ -964,11 +971,7 @@ index_create(Relation heapRelation,
indexInfo,
indexRelationName,
constraintType,
-
deferrable,
-
initdeferred,
- false,
/* already marked primary */
- false,
/* pg_index entry is OK */
- false,
/* no old dependencies */
+
constr_flags,
allow_system_table_mods,
is_internal);
}
@@ -1005,10 +1008,6 @@ index_create(Relation heapRelation,
recordDependencyOn(&myself, &referenced,
DEPENDENCY_AUTO);
}
-
- /* Non-constraint indexes can't be deferrable */
- Assert(!deferrable);
- Assert(!initdeferred);
}
/* Store dependency on collations */
@@ -1059,9 +1058,7 @@ index_create(Relation heapRelation,
else
{
/* Bootstrap mode - assert we weren't asked for constraint
support */
- Assert(!isconstraint);
- Assert(!deferrable);
- Assert(!initdeferred);
+ Assert((flags & INDEX_CREATE_ADD_CONSTRAINT) == 0);
}
/* Post creation hook for new index */
@@ -1089,15 +1086,16 @@ index_create(Relation heapRelation,
* If this is bootstrap (initdb) time, then we don't actually fill in
the
* index yet. We'll be creating more indexes and classes later, so we
* delay filling them in until just before we're done with
bootstrapping.
- * Similarly, if the caller specified skip_build then filling the index
is
- * delayed till later (ALTER TABLE can save work in some cases with
this).
- * Otherwise, we call the AM routine that constructs the index.
+ * Similarly, if the caller specified to skip the build then filling the
+ * index is delayed till later (ALTER TABLE can save work in some cases
+ * with this). Otherwise, we call the AM routine that constructs the
+ * index.
*/
if (IsBootstrapProcessingMode())
{
index_register(heapRelationId, indexRelationId, indexInfo);
}
- else if (skip_build)
+ else if ((flags & INDEX_CREATE_SKIP_BUILD) != 0)
{
/*
* Caller is responsible for filling the index later on.
However,
@@ -1137,12 +1135,13 @@ index_create(Relation heapRelation,
* constraintName: what it say (generally, should match name of index)
* constraintType: one of CONSTRAINT_PRIMARY, CONSTRAINT_UNIQUE, or
* CONSTRAINT_EXCLUSION
- * deferrable: constraint is DEFERRABLE
- * initdeferred: constraint is INITIALLY DEFERRED
- * mark_as_primary: if true, set flags to mark index as primary key
- * update_pgindex: if true, update pg_index row (else caller's done that)
- * remove_old_dependencies: if true, remove existing dependencies of index
- * on table's columns
+ * flags: bitmask that can include any combination of these bits:
+ * INDEX_CONSTR_CREATE_MARK_AS_PRIMARY: index is a PRIMARY KEY
+ * INDEX_CONSTR_CREATE_DEFERRABLE: constraint is DEFERRABLE
+ * INDEX_CONSTR_CREATE_INIT_DEFERRED: constraint is INITIALLY
DEFERRED
+ * INDEX_CONSTR_CREATE_UPDATE_INDEX: update the pg_index row
+ * INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS: remove existing
dependencies
+ * of index on table's columns
* allow_system_table_mods: allow table to be a system catalog
* is_internal: index is constructed due to internal process
*/
@@ -1152,11 +1151,7 @@ index_constraint_create(Relation heapRelation,
IndexInfo *indexInfo,
const char *constraintName,
char constraintType,
- bool deferrable,
- bool initdeferred,
- bool mark_as_primary,
- bool update_pgindex,
- bool remove_old_dependencies,
+ uint16 constr_flags,
bool allow_system_table_mods,
bool is_internal)
{
@@ -1164,6 +1159,9 @@ index_constraint_create(Relation heapRelation,
ObjectAddress myself,
referenced;
Oid conOid;
+ bool deferrable = constr_flags &
INDEX_CONSTR_CREATE_DEFERRABLE;
+ bool initdeferred = constr_flags &
INDEX_CONSTR_CREATE_INIT_DEFERRED;
+ bool mark_as_primary = constr_flags &
INDEX_CONSTR_CREATE_MARK_AS_PRIMARY;
/* constraint creation support doesn't work while bootstrapping */
Assert(!IsBootstrapProcessingMode());
@@ -1190,7 +1188,7 @@ index_constraint_create(Relation heapRelation,
* has any expressions or predicate, but we'd never be turning such an
* index into a UNIQUE or PRIMARY KEY constraint.
*/
- if (remove_old_dependencies)
+ if (constr_flags & INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS)
deleteDependencyRecordsForClass(RelationRelationId,
indexRelationId,
RelationRelationId, DEPENDENCY_AUTO);
@@ -1295,7 +1293,8 @@ index_constraint_create(Relation heapRelation,
* is a risk that concurrent readers of the table will miss seeing this
* index at all.
*/
- if (update_pgindex && (mark_as_primary || deferrable))
+ if ((constr_flags & INDEX_CONSTR_CREATE_UPDATE_INDEX) &&
+ (mark_as_primary || deferrable))
{
Relation pg_index;
HeapTuple indexTuple;
diff --git a/src/backend/catalog/toasting.c b/src/backend/catalog/toasting.c
index 6f517bbcda..539ca79ad3 100644
--- a/src/backend/catalog/toasting.c
+++ b/src/backend/catalog/toasting.c
@@ -333,8 +333,7 @@ create_toast_table(Relation rel, Oid toastOid, Oid
toastIndexOid,
BTREE_AM_OID,
rel->rd_rel->reltablespace,
collationObjectId, classObjectId, coloptions,
(Datum) 0,
- true, false, false, false,
- true, false, false, true, false);
+ INDEX_CREATE_IS_PRIMARY, 0, true, true);
heap_close(toast_rel, NoLock);
diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index 3f615b6260..92c09b06dd 100644
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -333,6 +333,8 @@ DefineIndex(Oid relationId,
Datum reloptions;
int16 *coloptions;
IndexInfo *indexInfo;
+ uint16 flags;
+ uint16 constr_flags;
int numberOfAttributes;
TransactionId limitXmin;
VirtualTransactionId *old_snapshots;
@@ -661,20 +663,35 @@ DefineIndex(Oid relationId,
Assert(!OidIsValid(stmt->oldNode) || (skip_build && !stmt->concurrent));
/*
- * Make the catalog entries for the index, including constraints. Then,
if
- * not skip_build || concurrent, actually build the index.
+ * Make the catalog entries for the index, including constraints. This
+ * step also actually builds the index, except if caller requested not
to
+ * or in concurrent mode, in which case it'll be done later.
*/
+ flags = constr_flags = 0;
+ if (stmt->isconstraint)
+ flags |= INDEX_CREATE_ADD_CONSTRAINT;
+ if (skip_build || stmt->concurrent)
+ flags |= INDEX_CREATE_SKIP_BUILD;
+ if (stmt->if_not_exists)
+ flags |= INDEX_CREATE_IF_NOT_EXISTS;
+ if (stmt->concurrent)
+ flags |= INDEX_CREATE_CONCURRENT;
+ if (stmt->primary)
+ flags |= INDEX_CREATE_IS_PRIMARY;
+
+ if (stmt->deferrable)
+ constr_flags |= INDEX_CONSTR_CREATE_DEFERRABLE;
+ if (stmt->initdeferred)
+ constr_flags |= INDEX_CONSTR_CREATE_INIT_DEFERRED;
+
indexRelationId =
index_create(rel, indexRelationName, indexRelationId,
stmt->oldNode,
indexInfo, indexColNames,
accessMethodId, tablespaceId,
collationObjectId, classObjectId,
- coloptions, reloptions, stmt->primary,
- stmt->isconstraint, stmt->deferrable,
stmt->initdeferred,
- allowSystemTableMods,
- skip_build || stmt->concurrent,
- stmt->concurrent, !check_rights,
- stmt->if_not_exists);
+ coloptions, reloptions,
+ flags, constr_flags,
+ allowSystemTableMods, !check_rights);
ObjectAddressSet(address, RelationRelationId, indexRelationId);
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 2d4dcd7556..360027a06c 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -6823,6 +6823,7 @@ ATExecAddIndexConstraint(AlteredTableInfo *tab, Relation
rel,
char *constraintName;
char constraintType;
ObjectAddress address;
+ uint16 flags;
Assert(IsA(stmt, IndexStmt));
Assert(OidIsValid(index_oid));
@@ -6867,16 +6868,18 @@ ATExecAddIndexConstraint(AlteredTableInfo *tab,
Relation rel,
constraintType = CONSTRAINT_UNIQUE;
/* Create the catalog entries for the constraint */
+ flags = INDEX_CONSTR_CREATE_UPDATE_INDEX |
+ INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS |
+ (stmt->initdeferred ? INDEX_CONSTR_CREATE_INIT_DEFERRED : 0) |
+ (stmt->deferrable ? INDEX_CONSTR_CREATE_DEFERRABLE : 0) |
+ (stmt->primary ? INDEX_CONSTR_CREATE_MARK_AS_PRIMARY : 0);
+
address = index_constraint_create(rel,
index_oid,
indexInfo,
constraintName,
constraintType,
-
stmt->deferrable,
-
stmt->initdeferred,
-
stmt->primary,
- true,
/* update pg_index */
- true,
/* remove old dependencies */
+ flags,
allowSystemTableMods,
false); /* is_internal */
diff --git a/src/include/catalog/index.h b/src/include/catalog/index.h
index 1d4ec09f8f..ab1f9ef1bd 100644
--- a/src/include/catalog/index.h
+++ b/src/include/catalog/index.h
@@ -42,6 +42,12 @@ extern void index_check_primary_key(Relation heapRel,
IndexInfo *indexInfo,
bool is_alter_table);
+#define INDEX_CREATE_IS_PRIMARY (1 << 0)
+#define INDEX_CREATE_ADD_CONSTRAINT (1 << 1)
+#define INDEX_CREATE_SKIP_BUILD (1 << 2)
+#define INDEX_CREATE_CONCURRENT (1 << 3)
+#define INDEX_CREATE_IF_NOT_EXISTS (1 << 4)
+
extern Oid index_create(Relation heapRelation,
const char *indexRelationName,
Oid indexRelationId,
@@ -54,26 +60,23 @@ extern Oid index_create(Relation heapRelation,
Oid *classObjectId,
int16 *coloptions,
Datum reloptions,
- bool isprimary,
- bool isconstraint,
- bool deferrable,
- bool initdeferred,
+ uint16 flags,
+ uint16 constr_flags,
bool allow_system_table_mods,
- bool skip_build,
- bool concurrent,
- bool is_internal,
- bool if_not_exists);
+ bool is_internal);
+
+#define INDEX_CONSTR_CREATE_MARK_AS_PRIMARY (1 << 0)
+#define INDEX_CONSTR_CREATE_DEFERRABLE (1 << 1)
+#define INDEX_CONSTR_CREATE_INIT_DEFERRED (1 << 2)
+#define INDEX_CONSTR_CREATE_UPDATE_INDEX (1 << 3)
+#define INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS (1 << 4)
extern ObjectAddress index_constraint_create(Relation heapRelation,
Oid indexRelationId,
IndexInfo *indexInfo,
const char *constraintName,
char constraintType,
- bool deferrable,
- bool initdeferred,
- bool mark_as_primary,
- bool update_pgindex,
- bool remove_old_dependencies,
+ uint16 constr_flags,
bool allow_system_table_mods,
bool is_internal);
--
2.11.0
>From c7f3cd7e9ec6ad792fed88e1adfd5873607a3657 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvhe...@alvh.no-ip.org>
Date: Fri, 6 Oct 2017 18:05:50 +0200
Subject: [PATCH v2 2/7] Allow indexes on partitioned tables
---
src/backend/access/common/reloptions.c | 1 +
src/backend/access/heap/heapam.c | 9 +-
src/backend/access/index/indexam.c | 3 +-
src/backend/bootstrap/bootparse.y | 2 +
src/backend/catalog/aclchk.c | 9 +-
src/backend/catalog/dependency.c | 3 +-
src/backend/catalog/heap.c | 1 +
src/backend/catalog/index.c | 55 ++++++++++-
src/backend/catalog/objectaddress.c | 5 +-
src/backend/catalog/pg_depend.c | 13 ++-
src/backend/catalog/toasting.c | 1 +
src/backend/commands/indexcmds.c | 176 ++++++++++++++++++++++++++++++---
src/backend/commands/tablecmds.c | 53 ++++++++--
src/backend/tcop/utility.c | 1 +
src/backend/utils/adt/amutils.c | 3 +-
src/backend/utils/cache/relcache.c | 30 ++++--
src/bin/psql/describe.c | 20 +++-
src/include/catalog/catversion.h | 2 +-
src/include/catalog/index.h | 2 +
src/include/catalog/pg_class.h | 1 +
src/include/catalog/pg_index.h | 38 +++----
src/include/commands/defrem.h | 3 +-
22 files changed, 356 insertions(+), 75 deletions(-)
diff --git a/src/backend/access/common/reloptions.c
b/src/backend/access/common/reloptions.c
index ec10762529..f2f703ffcb 100644
--- a/src/backend/access/common/reloptions.c
+++ b/src/backend/access/common/reloptions.c
@@ -983,6 +983,7 @@ extractRelOptions(HeapTuple tuple, TupleDesc tupdesc,
options = view_reloptions(datum, false);
break;
case RELKIND_INDEX:
+ case RELKIND_PARTITIONED_INDEX:
options = index_reloptions(amoptions, datum, false);
break;
case RELKIND_FOREIGN_TABLE:
diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 52dda41cc4..e228c5385c 100644
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -1293,7 +1293,8 @@ heap_open(Oid relationId, LOCKMODE lockmode)
r = relation_open(relationId, lockmode);
- if (r->rd_rel->relkind == RELKIND_INDEX)
+ if (r->rd_rel->relkind == RELKIND_INDEX ||
+ r->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("\"%s\" is an index",
@@ -1321,7 +1322,8 @@ heap_openrv(const RangeVar *relation, LOCKMODE lockmode)
r = relation_openrv(relation, lockmode);
- if (r->rd_rel->relkind == RELKIND_INDEX)
+ if (r->rd_rel->relkind == RELKIND_INDEX ||
+ r->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("\"%s\" is an index",
@@ -1353,7 +1355,8 @@ heap_openrv_extended(const RangeVar *relation, LOCKMODE
lockmode,
if (r)
{
- if (r->rd_rel->relkind == RELKIND_INDEX)
+ if (r->rd_rel->relkind == RELKIND_INDEX ||
+ r->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("\"%s\" is an index",
diff --git a/src/backend/access/index/indexam.c
b/src/backend/access/index/indexam.c
index bef4255369..84c26ad805 100644
--- a/src/backend/access/index/indexam.c
+++ b/src/backend/access/index/indexam.c
@@ -154,7 +154,8 @@ index_open(Oid relationId, LOCKMODE lockmode)
r = relation_open(relationId, lockmode);
- if (r->rd_rel->relkind != RELKIND_INDEX)
+ if (r->rd_rel->relkind != RELKIND_INDEX &&
+ r->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("\"%s\" is not an index",
diff --git a/src/backend/bootstrap/bootparse.y
b/src/backend/bootstrap/bootparse.y
index 2e1fef0350..95835ac1e7 100644
--- a/src/backend/bootstrap/bootparse.y
+++ b/src/backend/bootstrap/bootparse.y
@@ -321,6 +321,7 @@ Boot_DeclareIndexStmt:
DefineIndex(relationId,
stmt,
$4,
+ InvalidOid,
false,
false,
false,
@@ -365,6 +366,7 @@ Boot_DeclareUniqueIndexStmt:
DefineIndex(relationId,
stmt,
$5,
+ InvalidOid,
false,
false,
false,
diff --git a/src/backend/catalog/aclchk.c b/src/backend/catalog/aclchk.c
index ccde66a7dd..89e95ace37 100644
--- a/src/backend/catalog/aclchk.c
+++ b/src/backend/catalog/aclchk.c
@@ -1766,7 +1766,8 @@ ExecGrant_Relation(InternalGrant *istmt)
pg_class_tuple = (Form_pg_class) GETSTRUCT(tuple);
/* Not sensible to grant on an index */
- if (pg_class_tuple->relkind == RELKIND_INDEX)
+ if (pg_class_tuple->relkind == RELKIND_INDEX ||
+ pg_class_tuple->relkind == RELKIND_PARTITIONED_INDEX)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("\"%s\" is an index",
@@ -5347,7 +5348,8 @@ recordExtObjInitPriv(Oid objoid, Oid classoid)
pg_class_tuple = (Form_pg_class) GETSTRUCT(tuple);
/* Indexes don't have permissions */
- if (pg_class_tuple->relkind == RELKIND_INDEX)
+ if (pg_class_tuple->relkind == RELKIND_INDEX ||
+ pg_class_tuple->relkind == RELKIND_PARTITIONED_INDEX)
return;
/* Composite types don't have permissions either */
@@ -5632,7 +5634,8 @@ removeExtObjInitPriv(Oid objoid, Oid classoid)
pg_class_tuple = (Form_pg_class) GETSTRUCT(tuple);
/* Indexes don't have permissions */
- if (pg_class_tuple->relkind == RELKIND_INDEX)
+ if (pg_class_tuple->relkind == RELKIND_INDEX ||
+ pg_class_tuple->relkind == RELKIND_PARTITIONED_INDEX)
return;
/* Composite types don't have permissions either */
diff --git a/src/backend/catalog/dependency.c b/src/backend/catalog/dependency.c
index 3b214e5702..6779c2a8a3 100644
--- a/src/backend/catalog/dependency.c
+++ b/src/backend/catalog/dependency.c
@@ -1109,7 +1109,8 @@ doDeletion(const ObjectAddress *object, int flags)
{
char relKind =
get_rel_relkind(object->objectId);
- if (relKind == RELKIND_INDEX)
+ if (relKind == RELKIND_INDEX ||
+ relKind == RELKIND_PARTITIONED_INDEX)
{
bool concurrent = ((flags &
PERFORM_DELETION_CONCURRENTLY) != 0);
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 05e70818e7..1dff818593 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -294,6 +294,7 @@ heap_create(const char *relname,
case RELKIND_COMPOSITE_TYPE:
case RELKIND_FOREIGN_TABLE:
case RELKIND_PARTITIONED_TABLE:
+ case RELKIND_PARTITIONED_INDEX:
create_storage = false;
/*
diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 17faeffada..8d15db0ec1 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -41,6 +41,7 @@
#include "catalog/pg_collation.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_constraint_fn.h"
+#include "catalog/pg_depend.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_tablespace.h"
@@ -670,6 +671,8 @@ UpdateIndexRelation(Oid indexoid,
* indexRelationId: normally, pass InvalidOid to let this routine
* generate an OID for the index. During bootstrap this may be
* nonzero to specify a preselected OID.
+ * parentIndexRelid: if creating an index partition, the OID of the
+ * parent index; otherwise InvalidOid.
* relFileNode: normally, pass InvalidOid to get new storage. May be
* nonzero to attach an existing valid build.
* indexInfo: same info executor uses to insert into the index
@@ -695,6 +698,8 @@ UpdateIndexRelation(Oid indexoid,
* INDEX_CREATE_IF_NOT_EXISTS:
* do not throw an error if a relation with the same name
* already exists.
+ * INDEX_CREATE_PARTITIONED:
+ * create a partitioned index (table must be partitioned)
* constr_flags: flags passed to index_constraint_create
* (only if INDEX_CREATE_ADD_CONSTRAINT is set)
* allow_system_table_mods: allow table to be a system catalog
@@ -706,6 +711,7 @@ Oid
index_create(Relation heapRelation,
const char *indexRelationName,
Oid indexRelationId,
+ Oid parentIndexRelid,
Oid relFileNode,
IndexInfo *indexInfo,
List *indexColNames,
@@ -732,11 +738,16 @@ index_create(Relation heapRelation,
char relpersistence;
bool isprimary = flags & INDEX_CREATE_IS_PRIMARY;
bool concurrent = flags & INDEX_CREATE_CONCURRENT;
+ bool partitioned = flags & INDEX_CREATE_PARTITIONED;
+ char relkind;
/* constraint flags can only be set when constraint is requested */
Assert((constr_flags == 0) ||
((flags & INDEX_CREATE_ADD_CONSTRAINT) != 0));
+ /* partitioned indexes must never be "built" by themselves */
+ Assert(!partitioned || (flags & INDEX_CREATE_SKIP_BUILD));
+ relkind = partitioned ? RELKIND_PARTITIONED_INDEX : RELKIND_INDEX;
is_exclusion = (indexInfo->ii_ExclusionOps != NULL);
pg_class = heap_open(RelationRelationId, RowExclusiveLock);
@@ -864,7 +875,7 @@ index_create(Relation heapRelation,
indexRelationId,
relFileNode,
indexTupDesc,
- RELKIND_INDEX,
+ relkind,
relpersistence,
shared_relation,
mapped_relation,
@@ -925,7 +936,7 @@ index_create(Relation heapRelation,
collationObjectId,
classObjectId, coloptions,
isprimary, is_exclusion,
(constr_flags &
INDEX_CONSTR_CREATE_DEFERRABLE) == 0,
- !concurrent);
+ !concurrent && !partitioned);
/*
* Register constraint and dependencies for the index.
@@ -1010,6 +1021,17 @@ index_create(Relation heapRelation,
}
}
+ /* Store dependency on parent index, if any */
+ if (OidIsValid(parentIndexRelid))
+ {
+ referenced.classId = RelationRelationId;
+ referenced.objectId = parentIndexRelid;
+ referenced.objectSubId = 0;
+
+ recordDependencyOn(&myself, &referenced,
DEPENDENCY_INTERNAL);
+ }
+
+
/* Store dependency on collations */
/* The default collation is pinned, so don't bother recording
it */
for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
@@ -1551,9 +1573,10 @@ index_drop(Oid indexId, bool concurrent)
}
/*
- * Schedule physical removal of the files
+ * Schedule physical removal of the files (if any)
*/
- RelationDropStorage(userIndexRelation);
+ if (userIndexRelation->rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
+ RelationDropStorage(userIndexRelation);
/*
* Close and flush the index's relcache entry, to ensure relcache
doesn't
@@ -1918,6 +1941,9 @@ index_update_stats(Relation rel,
elog(ERROR, "could not find tuple for relation %u", relid);
rd_rel = (Form_pg_class) GETSTRUCT(tuple);
+ /* Should this be a more comprehensive test? */
+ Assert(rd_rel->relkind != RELKIND_PARTITIONED_INDEX);
+
/* Apply required updates, if any, to copied tuple */
dirty = false;
@@ -3328,6 +3354,14 @@ reindex_index(Oid indexId, bool skip_constraint_checks,
char persistence,
iRel = index_open(indexId, AccessExclusiveLock);
/*
+ * The case of reindexing partitioned tables and indexes is handled
+ * differently by upper layers, so this case shouldn't arise.
+ */
+ if (iRel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
+ elog(ERROR, "unsupported relation kind for index \"%s\"",
+ RelationGetRelationName(iRel));
+
+ /*
* Don't allow reindex on temp tables of other backends ... their local
* buffer manager is not going to cope.
*/
@@ -3526,6 +3560,19 @@ reindex_relation(Oid relid, int flags, int options)
*/
rel = heap_open(relid, ShareLock);
+ /*
+ * Partitioned tables don't have indexes directly, but we want to
reindex
+ * each of the partitions; summon another routine to process the
children.
+ */
+ if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
+ {
+ heap_close(rel, NoLock);
+ elog(WARNING, "nothing got done"); /* XXX fill this in */
+ /* Here, we must obtain a list of each child relation, and
reindex
+ * each in turn */
+ return true;
+ }
+
toast_relid = rel->rd_rel->reltoastrelid;
/*
diff --git a/src/backend/catalog/objectaddress.c
b/src/backend/catalog/objectaddress.c
index c2ad7c675e..5627f7919e 100644
--- a/src/backend/catalog/objectaddress.c
+++ b/src/backend/catalog/objectaddress.c
@@ -1216,7 +1216,8 @@ get_relation_by_qualified_name(ObjectType objtype, List
*object,
switch (objtype)
{
case OBJECT_INDEX:
- if (relation->rd_rel->relkind != RELKIND_INDEX)
+ if (relation->rd_rel->relkind != RELKIND_INDEX &&
+ relation->rd_rel->relkind !=
RELKIND_PARTITIONED_INDEX)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("\"%s\" is not an
index",
@@ -3476,6 +3477,7 @@ getRelationDescription(StringInfo buffer, Oid relid)
relname);
break;
case RELKIND_INDEX:
+ case RELKIND_PARTITIONED_INDEX:
appendStringInfo(buffer, _("index %s"),
relname);
break;
@@ -3950,6 +3952,7 @@ getRelationTypeDescription(StringInfo buffer, Oid relid,
int32 objectSubId)
appendStringInfoString(buffer, "table");
break;
case RELKIND_INDEX:
+ case RELKIND_PARTITIONED_INDEX:
appendStringInfoString(buffer, "index");
break;
case RELKIND_SEQUENCE:
diff --git a/src/backend/catalog/pg_depend.c b/src/backend/catalog/pg_depend.c
index dd6ca3e8f7..1d9f24c737 100644
--- a/src/backend/catalog/pg_depend.c
+++ b/src/backend/catalog/pg_depend.c
@@ -656,14 +656,19 @@ get_constraint_index(Oid constraintId)
/*
* We assume any internal dependency of an index on the
constraint
- * must be what we are looking for. (The relkind test is just
- * paranoia; there shouldn't be any such dependencies
otherwise.)
+ * must be what we are looking for.
*/
if (deprec->classid == RelationRelationId &&
deprec->objsubid == 0 &&
- deprec->deptype == DEPENDENCY_INTERNAL &&
- get_rel_relkind(deprec->objid) == RELKIND_INDEX)
+ deprec->deptype == DEPENDENCY_INTERNAL)
{
+ char relkind =
get_rel_relkind(deprec->objid);
+
+ /* This is pure paranoia; there shouldn't be any such */
+ if (relkind != RELKIND_INDEX &&
+ relkind != RELKIND_PARTITIONED_INDEX)
+ break;
+
indexId = deprec->objid;
break;
}
diff --git a/src/backend/catalog/toasting.c b/src/backend/catalog/toasting.c
index 539ca79ad3..b1be2bee36 100644
--- a/src/backend/catalog/toasting.c
+++ b/src/backend/catalog/toasting.c
@@ -328,6 +328,7 @@ create_toast_table(Relation rel, Oid toastOid, Oid
toastIndexOid,
coloptions[1] = 0;
index_create(toast_rel, toast_idxname, toastIndexOid, InvalidOid,
+ InvalidOid,
indexInfo,
list_make2("chunk_id", "chunk_seq"),
BTREE_AM_OID,
diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index 92c09b06dd..a9a8969422 100644
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -23,7 +23,9 @@
#include "catalog/catalog.h"
#include "catalog/index.h"
#include "catalog/indexing.h"
+#include "catalog/partition.h"
#include "catalog/pg_am.h"
+#include "catalog/pg_inherits_fn.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_tablespace.h"
@@ -35,6 +37,7 @@
#include "commands/tablespace.h"
#include "mb/pg_wchar.h"
#include "miscadmin.h"
+#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "optimizer/clauses.h"
#include "optimizer/planner.h"
@@ -77,6 +80,7 @@ static char *ChooseIndexNameAddition(List *colnames);
static List *ChooseIndexColumnNames(List *indexElems);
static void RangeVarCallbackForReindexIndex(const RangeVar *relation,
Oid relId, Oid
oldRelId, void *arg);
+static void ReindexPartitionedIndex(Relation parentIdx);
/*
* CheckIndexCompatible
@@ -292,14 +296,15 @@ CheckIndexCompatible(Oid oldId,
* 'stmt': IndexStmt describing the properties of the new index.
* 'indexRelationId': normally InvalidOid, but during bootstrap can be
* nonzero to specify a preselected OID for the index.
+ * 'parentIndexId': the OID of the parent index; InvalidOid if not the child
+ * of a partitioned index.
* 'is_alter_table': this is due to an ALTER rather than a CREATE operation.
* 'check_rights': check for CREATE rights in namespace and tablespace. (This
* should be true except when ALTER is deleting/recreating an
index.)
* 'check_not_in_use': check for table not already in use in current session.
* This should be true unless caller is holding the table open, in
which
* case the caller had better have checked it earlier.
- * 'skip_build': make the catalog entries but leave the index file empty;
- * it will be filled later.
+ * 'skip_build': make the catalog entries but don't create the index files
* 'quiet': suppress the NOTICE chatter ordinarily provided for constraints.
*
* Returns the object address of the created index.
@@ -308,6 +313,7 @@ ObjectAddress
DefineIndex(Oid relationId,
IndexStmt *stmt,
Oid indexRelationId,
+ Oid parentIndexId,
bool is_alter_table,
bool check_rights,
bool check_not_in_use,
@@ -330,6 +336,7 @@ DefineIndex(Oid relationId,
IndexAmRoutine *amRoutine;
bool amcanorder;
amoptions_function amoptions;
+ bool partitioned;
Datum reloptions;
int16 *coloptions;
IndexInfo *indexInfo;
@@ -382,23 +389,58 @@ DefineIndex(Oid relationId,
{
case RELKIND_RELATION:
case RELKIND_MATVIEW:
+ case RELKIND_PARTITIONED_TABLE:
/* OK */
break;
case RELKIND_FOREIGN_TABLE:
+ /*
+ * Custom error message for FOREIGN TABLE since the
term is close
+ * to a regular table and can confuse the user.
+ */
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("cannot create index on foreign
table \"%s\"",
RelationGetRelationName(rel))));
- case RELKIND_PARTITIONED_TABLE:
- ereport(ERROR,
- (errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("cannot create index on
partitioned table \"%s\"",
-
RelationGetRelationName(rel))));
default:
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("\"%s\" is not a table or
materialized view",
RelationGetRelationName(rel))));
+ break;
+ }
+
+ /*
+ * Establish behavior for partitioned tables, and verify sanity of
+ * parameters.
+ *
+ * We do not build an actual index in this case; we only create a few
+ * catalog entries. The actual indexes are built by recursing for each
+ * partition.
+ */
+ partitioned = rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE;
+ if (partitioned)
+ {
+ if (stmt->concurrent)
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("cannot create index on
partitioned table \"%s\" concurrently",
+
RelationGetRelationName(rel))));
+ if (stmt->unique)
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("cannot create unique index on
partitioned table \"%s\"",
+
RelationGetRelationName(rel))));
+ if (stmt->excludeOpNames)
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("cannot create exclusion
constraints on partitioned table \"%s\"",
+
RelationGetRelationName(rel))));
+ if (is_alter_table)
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ /* FIXME */
+ errmsg("not sure what you're doing,
but it's not supported")));
+ /* XXX what else? */
}
/*
@@ -665,17 +707,20 @@ DefineIndex(Oid relationId,
/*
* Make the catalog entries for the index, including constraints. This
* step also actually builds the index, except if caller requested not
to
- * or in concurrent mode, in which case it'll be done later.
+ * or in concurrent mode, in which case it'll be done later, or
+ * doing a partitioned index (because those don't have storage).
*/
flags = constr_flags = 0;
if (stmt->isconstraint)
flags |= INDEX_CREATE_ADD_CONSTRAINT;
- if (skip_build || stmt->concurrent)
+ if (skip_build || stmt->concurrent || partitioned)
flags |= INDEX_CREATE_SKIP_BUILD;
if (stmt->if_not_exists)
flags |= INDEX_CREATE_IF_NOT_EXISTS;
if (stmt->concurrent)
flags |= INDEX_CREATE_CONCURRENT;
+ if (partitioned)
+ flags |= INDEX_CREATE_PARTITIONED;
if (stmt->primary)
flags |= INDEX_CREATE_IS_PRIMARY;
@@ -685,8 +730,8 @@ DefineIndex(Oid relationId,
constr_flags |= INDEX_CONSTR_CREATE_INIT_DEFERRED;
indexRelationId =
- index_create(rel, indexRelationName, indexRelationId,
stmt->oldNode,
- indexInfo, indexColNames,
+ index_create(rel, indexRelationName, indexRelationId,
parentIndexId,
+ stmt->oldNode, indexInfo,
indexColNames,
accessMethodId, tablespaceId,
collationObjectId, classObjectId,
coloptions, reloptions,
@@ -706,6 +751,79 @@ DefineIndex(Oid relationId,
CreateComments(indexRelationId, RelationRelationId, 0,
stmt->idxcomment);
+ /*
+ * For a partitioned index, recurse on each child relation executing the
+ * same command.
+ */
+ if (partitioned)
+ {
+ PartitionDesc partdesc = RelationGetPartitionDesc(rel);
+ Oid *part_oids;
+ int nparts;
+ MemoryContext oldcxt;
+
+ /*
+ * For the concurrent case, we must ensure not to lose the array
+ * of partitions we're going to work on, so copy it out of
relcache.
+ * PortalContext has right the right lifetime we need.
+ */
+ oldcxt = MemoryContextSwitchTo(PortalContext);
+
+ nparts = partdesc->nparts;
+ part_oids = palloc(sizeof(Oid) * nparts);
+ memcpy(part_oids, partdesc->oids, sizeof(Oid) * nparts);
+
+ MemoryContextSwitchTo(oldcxt);
+
+ /*
+ * FIXME maybe we can drop the lock in the parent table and keep
+ * locks in the children tables. But what if new children are
+ * added or existing children are detached? Maybe we can
+ * downgrade the lock level in the parent?
+ */
+ heap_close(rel, NoLock);
+
+ /*
+ * Now recurse, one child at a time. Note that if any child is
in
+ * turn a partitioned table, this will recursively do the right
thing.
+ * In the concurrent case, this will close the current
transaction and
+ * open a new one.
+ */
+ for (i = 0; i < nparts; i++)
+ {
+ Oid childRelid = part_oids[i];
+ Relation childrel;
+ IndexStmt *childStmt;
+
+ childrel = heap_open(childRelid, lockmode);
+
+ childStmt = copyObject(stmt);
+ childStmt->idxname = NULL;
+ childStmt->relation =
+
makeRangeVar(get_namespace_name(childrel->rd_rel->relnamespace),
+
RelationGetRelationName(childrel), -1);
+
+ heap_close(childrel, NoLock);
+
+ /*
+ * Note that the event trigger command stash will only
contain
+ * a command to create the top-level index, not each of
the
+ * individual index partitions.
+ */
+ DefineIndex(childRelid, childStmt,
+ InvalidOid,
/* no predefined OID */
+ indexRelationId, /* this
is our child */
+ false, check_rights,
check_not_in_use,
+ false, quiet);
+ }
+
+ /*
+ * Indexes on partitioned tables are not themselves built, so
we're
+ * done here.
+ */
+ return address;
+ }
+
if (!stmt->concurrent)
{
/* Close the heap and we're done, in the non-concurrent case */
@@ -1762,7 +1880,7 @@ ChooseIndexColumnNames(List *indexElems)
* ReindexIndex
* Recreate a specific index.
*/
-Oid
+void
ReindexIndex(RangeVar *indexRelation, int options)
{
Oid indOid;
@@ -1785,12 +1903,17 @@ ReindexIndex(RangeVar *indexRelation, int options)
* lock on the index.
*/
irel = index_open(indOid, NoLock);
+
+ if (irel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
+ {
+ ReindexPartitionedIndex(irel);
+ return;
+ }
+
persistence = irel->rd_rel->relpersistence;
index_close(irel, NoLock);
reindex_index(indOid, false, persistence, options);
-
- return indOid;
}
/*
@@ -1829,7 +1952,8 @@ RangeVarCallbackForReindexIndex(const RangeVar *relation,
relkind = get_rel_relkind(relId);
if (!relkind)
return;
- if (relkind != RELKIND_INDEX)
+ if (relkind != RELKIND_INDEX &&
+ relkind != RELKIND_PARTITIONED_INDEX)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("\"%s\" is not an index",
relation->relname)));
@@ -1973,6 +2097,12 @@ ReindexMultipleTables(const char *objectName,
ReindexObjectType objectKind,
/*
* Only regular tables and matviews can have indexes, so ignore
any
* other kind of relation.
+ *
+ * XXX it is tempting to also consider partitioned tables here,
but
+ * that has the problem that if the children are in the same
schema,
+ * they would be processed twice. Maybe we could have a
separate
+ * list of partitioned tables, and expand that afterwards into
relids,
+ * ignoring any duplicates.
*/
if (classtuple->relkind != RELKIND_RELATION &&
classtuple->relkind != RELKIND_MATVIEW)
@@ -2035,3 +2165,19 @@ ReindexMultipleTables(const char *objectName,
ReindexObjectType objectKind,
MemoryContextDelete(private_context);
}
+
+/*
+ * Reindex each child of a partitioned index.
+ *
+ * The parent index is given, locked in AccessExclusive mode; this routine
+ * obtains the list of children and releases the lock on parent before
+ * applying reindex on each child.
+ */
+static void
+ReindexPartitionedIndex(Relation parentIdx)
+{
+ /* FIXME fill this in */
+ elog(WARNING, "nothing got done!");
+
+ heap_close(parentIdx, AccessExclusiveLock);
+}
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 360027a06c..17cb2f05e7 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -266,6 +266,12 @@ static const struct dropmsgstrings dropmsgstringarray[] = {
gettext_noop("table \"%s\" does not exist, skipping"),
gettext_noop("\"%s\" is not a table"),
gettext_noop("Use DROP TABLE to remove a table.")},
+ {RELKIND_PARTITIONED_INDEX,
+ ERRCODE_UNDEFINED_OBJECT,
+ gettext_noop("index \"%s\" does not exist"),
+ gettext_noop("index \"%s\" does not exist, skipping"),
+ gettext_noop("\"%s\" is not an index"),
+ gettext_noop("Use DROP INDEX to remove an index.")},
{'\0', 0, NULL, NULL, NULL, NULL}
};
@@ -1179,10 +1185,13 @@ RangeVarCallbackForDropRelation(const RangeVar *rel,
Oid relOid, Oid oldRelOid,
* but RemoveRelations() can only pass one relkind for a given relation.
* It chooses RELKIND_RELATION for both regular and partitioned tables.
* That means we must be careful before giving the wrong type error when
- * the relation is RELKIND_PARTITIONED_TABLE.
+ * the relation is RELKIND_PARTITIONED_TABLE. There's an equivalent
+ * problem with indexes.
*/
if (classform->relkind == RELKIND_PARTITIONED_TABLE)
expected_relkind = RELKIND_RELATION;
+ else if (classform->relkind == RELKIND_PARTITIONED_INDEX)
+ expected_relkind = RELKIND_INDEX;
else
expected_relkind = classform->relkind;
@@ -1210,7 +1219,8 @@ RangeVarCallbackForDropRelation(const RangeVar *rel, Oid
relOid, Oid oldRelOid,
* we do it the other way around. No error if we don't find a pg_index
* entry, though --- the relation may have been dropped.
*/
- if (relkind == RELKIND_INDEX && relOid != oldRelOid)
+ if ((relkind == RELKIND_INDEX || relkind == RELKIND_PARTITIONED_INDEX)
&&
+ relOid != oldRelOid)
{
state->heapOid = IndexGetRelation(relOid, true);
if (OidIsValid(state->heapOid))
@@ -2540,6 +2550,7 @@ renameatt_check(Oid myrelid, Form_pg_class classform,
bool recursing)
relkind != RELKIND_MATVIEW &&
relkind != RELKIND_COMPOSITE_TYPE &&
relkind != RELKIND_INDEX &&
+ relkind != RELKIND_PARTITIONED_INDEX &&
relkind != RELKIND_FOREIGN_TABLE &&
relkind != RELKIND_PARTITIONED_TABLE)
ereport(ERROR,
@@ -3019,7 +3030,8 @@ RenameRelationInternal(Oid myrelid, const char
*newrelname, bool is_internal)
/*
* Also rename the associated constraint, if any.
*/
- if (targetrelation->rd_rel->relkind == RELKIND_INDEX)
+ if (targetrelation->rd_rel->relkind == RELKIND_INDEX ||
+ targetrelation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
{
Oid constraintId =
get_index_constraint(myrelid);
@@ -3073,6 +3085,7 @@ CheckTableNotInUse(Relation rel, const char *stmt)
stmt,
RelationGetRelationName(rel))));
if (rel->rd_rel->relkind != RELKIND_INDEX &&
+ rel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX &&
AfterTriggerPendingOnRel(RelationGetRelid(rel)))
ereport(ERROR,
(errcode(ERRCODE_OBJECT_IN_USE),
@@ -4740,6 +4753,7 @@ ATSimplePermissions(Relation rel, int allowed_targets)
actual_target = ATT_MATVIEW;
break;
case RELKIND_INDEX:
+ case RELKIND_PARTITIONED_INDEX:
actual_target = ATT_INDEX;
break;
case RELKIND_COMPOSITE_TYPE:
@@ -6182,6 +6196,7 @@ ATPrepSetStatistics(Relation rel, const char *colName,
int16 colNum, Node *newVa
if (rel->rd_rel->relkind != RELKIND_RELATION &&
rel->rd_rel->relkind != RELKIND_MATVIEW &&
rel->rd_rel->relkind != RELKIND_INDEX &&
+ rel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX &&
rel->rd_rel->relkind != RELKIND_FOREIGN_TABLE &&
rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
ereport(ERROR,
@@ -6193,7 +6208,9 @@ ATPrepSetStatistics(Relation rel, const char *colName,
int16 colNum, Node *newVa
* We allow referencing columns by numbers only for indexes, since
* table column numbers could contain gaps if columns are later dropped.
*/
- if (rel->rd_rel->relkind != RELKIND_INDEX && !colName)
+ if (rel->rd_rel->relkind != RELKIND_INDEX &&
+ rel->rd_rel->relkind != RELKIND_PARTITIONED_INDEX &&
+ !colName)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot refer to non-index column by
number")));
@@ -6271,7 +6288,8 @@ ATExecSetStatistics(Relation rel, const char *colName,
int16 colNum, Node *newVa
errmsg("cannot alter system column \"%s\"",
colName)));
- if (rel->rd_rel->relkind == RELKIND_INDEX &&
+ if ((rel->rd_rel->relkind == RELKIND_INDEX ||
+ rel->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
rel->rd_index->indkey.values[attnum - 1] != 0)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
@@ -6784,6 +6802,7 @@ ATExecAddIndex(AlteredTableInfo *tab, Relation rel,
address = DefineIndex(RelationGetRelid(rel),
stmt,
InvalidOid, /* no
predefined OID */
+ InvalidOid, /* no parent
index */
true, /* is_alter_table */
check_rights,
false, /*
check_not_in_use - we did it already */
@@ -9185,7 +9204,9 @@ ATExecAlterColumnType(AlteredTableInfo *tab, Relation rel,
{
char relKind =
get_rel_relkind(foundObject.objectId);
- if (relKind == RELKIND_INDEX)
+ /* XXX does this do the right thing?
Probably not */
+ if (relKind == RELKIND_INDEX ||
+ relKind ==
RELKIND_PARTITIONED_INDEX)
{
Assert(foundObject.objectSubId
== 0);
if
(!list_member_oid(tab->changedIndexOids, foundObject.objectId))
@@ -10094,6 +10115,7 @@ ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool
recursing, LOCKMODE lock
*/
if (tuple_class->relkind != RELKIND_COMPOSITE_TYPE &&
tuple_class->relkind != RELKIND_INDEX &&
+ tuple_class->relkind != RELKIND_PARTITIONED_INDEX &&
tuple_class->relkind != RELKIND_TOASTVALUE)
changeDependencyOnOwner(RelationRelationId, relationOid,
newOwnerId);
@@ -10101,7 +10123,8 @@ ATExecChangeOwner(Oid relationOid, Oid newOwnerId, bool
recursing, LOCKMODE lock
/*
* Also change the ownership of the table's row type, if it has
one
*/
- if (tuple_class->relkind != RELKIND_INDEX)
+ if (tuple_class->relkind != RELKIND_INDEX &&
+ tuple_class->relkind != RELKIND_PARTITIONED_INDEX)
AlterTypeOwnerInternal(tuple_class->reltype,
newOwnerId);
/*
@@ -10126,6 +10149,15 @@ ATExecChangeOwner(Oid relationOid, Oid newOwnerId,
bool recursing, LOCKMODE lock
list_free(index_oid_list);
}
+#if 0
+ /* For partitioned indexes, recurse to each child index */
+ if (tuple_class->relkind == RELKIND_PARTITIONED_INDEX)
+ {
+ foreach (i, child_index_oid)
+ ATExecChangeOwner(lfirst_oid(i), newOwnerId,
true, lockmode);
+ }
+#endif
+
if (tuple_class->relkind == RELKIND_RELATION ||
tuple_class->relkind == RELKIND_MATVIEW)
{
@@ -10418,6 +10450,7 @@ ATExecSetRelOptions(Relation rel, List *defList,
AlterTableType operation,
(void) view_reloptions(newOptions, true);
break;
case RELKIND_INDEX:
+ case RELKIND_PARTITIONED_INDEX:
(void) index_reloptions(rel->rd_amroutine->amoptions,
newOptions, true);
break;
default:
@@ -10830,7 +10863,8 @@ AlterTableMoveAll(AlterTableMoveAllStmt *stmt)
relForm->relkind != RELKIND_RELATION &&
relForm->relkind != RELKIND_PARTITIONED_TABLE) ||
(stmt->objtype == OBJECT_INDEX &&
- relForm->relkind != RELKIND_INDEX) ||
+ relForm->relkind != RELKIND_INDEX &&
+ relForm->relkind != RELKIND_PARTITIONED_INDEX) ||
(stmt->objtype == OBJECT_MATVIEW &&
relForm->relkind != RELKIND_MATVIEW))
continue;
@@ -13217,7 +13251,8 @@ RangeVarCallbackForAlterRelation(const RangeVar *rv,
Oid relid, Oid oldrelid,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("\"%s\" is not a composite type",
rv->relname)));
- if (reltype == OBJECT_INDEX && relkind != RELKIND_INDEX
+ if (reltype == OBJECT_INDEX && relkind != RELKIND_INDEX &&
+ relkind != RELKIND_PARTITIONED_INDEX
&& !IsA(stmt, RenameStmt))
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
diff --git a/src/backend/tcop/utility.c b/src/backend/tcop/utility.c
index 82a707af7b..a690160b55 100644
--- a/src/backend/tcop/utility.c
+++ b/src/backend/tcop/utility.c
@@ -1327,6 +1327,7 @@ ProcessUtilitySlow(ParseState *pstate,
DefineIndex(relid, /* OID
of heap relation */
stmt,
InvalidOid, /* no predefined OID */
+
InvalidOid, /* no parent index */
false,
/* is_alter_table */
true,
/* check_rights */
true,
/* check_not_in_use */
diff --git a/src/backend/utils/adt/amutils.c b/src/backend/utils/adt/amutils.c
index f53b251b30..6af53402ce 100644
--- a/src/backend/utils/adt/amutils.c
+++ b/src/backend/utils/adt/amutils.c
@@ -183,7 +183,8 @@ indexam_property(FunctionCallInfo fcinfo,
if (!HeapTupleIsValid(tuple))
PG_RETURN_NULL();
rd_rel = (Form_pg_class) GETSTRUCT(tuple);
- if (rd_rel->relkind != RELKIND_INDEX)
+ if (rd_rel->relkind != RELKIND_INDEX &&
+ rd_rel->relkind != RELKIND_PARTITIONED_INDEX)
{
ReleaseSysCache(tuple);
PG_RETURN_NULL();
diff --git a/src/backend/utils/cache/relcache.c
b/src/backend/utils/cache/relcache.c
index b8e37809b0..ec3b81cd2b 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -435,6 +435,7 @@ static void
RelationParseRelOptions(Relation relation, HeapTuple tuple)
{
bytea *options;
+ bool isindex;
relation->rd_options = NULL;
@@ -444,6 +445,7 @@ RelationParseRelOptions(Relation relation, HeapTuple tuple)
case RELKIND_RELATION:
case RELKIND_TOASTVALUE:
case RELKIND_INDEX:
+ case RELKIND_PARTITIONED_INDEX:
case RELKIND_VIEW:
case RELKIND_MATVIEW:
case RELKIND_PARTITIONED_TABLE:
@@ -457,10 +459,12 @@ RelationParseRelOptions(Relation relation, HeapTuple
tuple)
* we might not have any other for pg_class yet (consider executing this
* code for pg_class itself)
*/
+ isindex = relation->rd_rel->relkind == RELKIND_INDEX ||
+ relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX;
options = extractRelOptions(tuple,
GetPgClassDescriptor(),
-
relation->rd_rel->relkind == RELKIND_INDEX ?
-
relation->rd_amroutine->amoptions : NULL);
+ isindex ?
relation->rd_amroutine->amoptions :
+ NULL);
/*
* Copy parsed data into CacheMemoryContext. To guard against the
@@ -2095,7 +2099,8 @@ RelationIdGetRelation(Oid relationId)
* and we don't want to use the full-blown procedure
because it's
* a headache for indexes that reload itself depends on.
*/
- if (rd->rd_rel->relkind == RELKIND_INDEX)
+ if (rd->rd_rel->relkind == RELKIND_INDEX ||
+ rd->rd_rel->relkind ==
RELKIND_PARTITIONED_INDEX)
RelationReloadIndexInfo(rd);
else
RelationClearRelation(rd, true);
@@ -2209,7 +2214,8 @@ RelationReloadIndexInfo(Relation relation)
Form_pg_class relp;
/* Should be called only for invalidated indexes */
- Assert(relation->rd_rel->relkind == RELKIND_INDEX &&
+ Assert((relation->rd_rel->relkind == RELKIND_INDEX ||
+ relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
&&
!relation->rd_isvalid);
/* Ensure it's closed at smgr level */
@@ -2429,7 +2435,8 @@ RelationClearRelation(Relation relation, bool rebuild)
{
RelationInitPhysicalAddr(relation);
- if (relation->rd_rel->relkind == RELKIND_INDEX)
+ if (relation->rd_rel->relkind == RELKIND_INDEX ||
+ relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX)
{
relation->rd_isvalid = false; /* needs to be
revalidated */
if (relation->rd_refcnt > 1 && IsTransactionState())
@@ -2445,7 +2452,8 @@ RelationClearRelation(Relation relation, bool rebuild)
* re-read the pg_class row to handle possible physical relocation of
the
* index, and we check for pg_index updates too.
*/
- if (relation->rd_rel->relkind == RELKIND_INDEX &&
+ if ((relation->rd_rel->relkind == RELKIND_INDEX ||
+ relation->rd_rel->relkind == RELKIND_PARTITIONED_INDEX) &&
relation->rd_refcnt > 0 &&
relation->rd_indexcxt != NULL)
{
@@ -5503,7 +5511,10 @@ load_relcache_init_file(bool shared)
rel->rd_att->constr = constr;
}
- /* If it's an index, there's more to do */
+ /*
+ * If it's an index, there's more to do. Note we explicitly
ignore
+ * partitioned indexes here.
+ */
if (rel->rd_rel->relkind == RELKIND_INDEX)
{
MemoryContext indexcxt;
@@ -5865,7 +5876,10 @@ write_relcache_init_file(bool shared)
(rel->rd_options ? VARSIZE(rel->rd_options)
: 0),
fp);
- /* If it's an index, there's more to do */
+ /*
+ * If it's an index, there's more to do. Note we explicitly
ignore
+ * partitioned indexes here.
+ */
if (rel->rd_rel->relkind == RELKIND_INDEX)
{
/* write the pg_index tuple */
diff --git a/src/bin/psql/describe.c b/src/bin/psql/describe.c
index 638275ca2f..c22ca11a74 100644
--- a/src/bin/psql/describe.c
+++ b/src/bin/psql/describe.c
@@ -1703,7 +1703,8 @@ describeOneTableDetails(const char *schemaname,
appendPQExpBufferStr(&buf, ",\n a.attidentity");
else
appendPQExpBufferStr(&buf, ",\n ''::pg_catalog.char AS
attidentity");
- if (tableinfo.relkind == RELKIND_INDEX)
+ if (tableinfo.relkind == RELKIND_INDEX ||
+ tableinfo.relkind == RELKIND_PARTITIONED_INDEX)
appendPQExpBufferStr(&buf, ",\n
pg_catalog.pg_get_indexdef(a.attrelid, a.attnum, TRUE) AS indexdef");
else
appendPQExpBufferStr(&buf, ",\n NULL AS indexdef");
@@ -1764,6 +1765,7 @@ describeOneTableDetails(const char *schemaname,
schemaname,
relationname);
break;
case RELKIND_INDEX:
+ case RELKIND_PARTITIONED_INDEX:
if (tableinfo.relpersistence == 'u')
printfPQExpBuffer(&title, _("Unlogged index
\"%s.%s\""),
schemaname,
relationname);
@@ -1821,7 +1823,8 @@ describeOneTableDetails(const char *schemaname,
show_column_details = true;
}
- if (tableinfo.relkind == RELKIND_INDEX)
+ if (tableinfo.relkind == RELKIND_INDEX ||
+ tableinfo.relkind == RELKIND_PARTITIONED_INDEX)
headers[cols++] = gettext_noop("Definition");
if (tableinfo.relkind == RELKIND_FOREIGN_TABLE && pset.sversion >=
90200)
@@ -1832,6 +1835,7 @@ describeOneTableDetails(const char *schemaname,
headers[cols++] = gettext_noop("Storage");
if (tableinfo.relkind == RELKIND_RELATION ||
tableinfo.relkind == RELKIND_INDEX ||
+ tableinfo.relkind == RELKIND_PARTITIONED_INDEX ||
tableinfo.relkind == RELKIND_MATVIEW ||
tableinfo.relkind == RELKIND_FOREIGN_TABLE ||
tableinfo.relkind == RELKIND_PARTITIONED_TABLE)
@@ -1904,7 +1908,8 @@ describeOneTableDetails(const char *schemaname,
}
/* Expression for index column */
- if (tableinfo.relkind == RELKIND_INDEX)
+ if (tableinfo.relkind == RELKIND_INDEX ||
+ tableinfo.relkind == RELKIND_PARTITIONED_INDEX)
printTableAddCell(&cont, PQgetvalue(res, i, 7), false,
false);
/* FDW options for foreign table column, only for 9.2 or later
*/
@@ -1928,6 +1933,7 @@ describeOneTableDetails(const char *schemaname,
/* Statistics target, if the relkind supports this
feature */
if (tableinfo.relkind == RELKIND_RELATION ||
tableinfo.relkind == RELKIND_INDEX ||
+ tableinfo.relkind == RELKIND_PARTITIONED_INDEX
||
tableinfo.relkind == RELKIND_MATVIEW ||
tableinfo.relkind == RELKIND_FOREIGN_TABLE ||
tableinfo.relkind == RELKIND_PARTITIONED_TABLE)
@@ -2019,7 +2025,8 @@ describeOneTableDetails(const char *schemaname,
PQclear(result);
}
- if (tableinfo.relkind == RELKIND_INDEX)
+ if (tableinfo.relkind == RELKIND_INDEX ||
+ tableinfo.relkind == RELKIND_PARTITIONED_INDEX)
{
/* Footer information about an index */
PGresult *result;
@@ -3372,6 +3379,7 @@ listTables(const char *tabtypes, const char *pattern,
bool verbose, bool showSys
" WHEN 's' THEN '%s'"
" WHEN "
CppAsString2(RELKIND_FOREIGN_TABLE) " THEN '%s'"
" WHEN "
CppAsString2(RELKIND_PARTITIONED_TABLE) " THEN '%s'"
+ " WHEN "
CppAsString2(RELKIND_PARTITIONED_INDEX) " THEN '%s'"
" END as \"%s\",\n"
"
pg_catalog.pg_get_userbyid(c.relowner) as \"%s\"",
gettext_noop("Schema"),
@@ -3384,6 +3392,7 @@ listTables(const char *tabtypes, const char *pattern,
bool verbose, bool showSys
gettext_noop("special"),
gettext_noop("foreign table"),
gettext_noop("table"), /*
partitioned table */
+ gettext_noop("index"), /*
partitioned index */
gettext_noop("Type"),
gettext_noop("Owner"));
@@ -3429,7 +3438,8 @@ listTables(const char *tabtypes, const char *pattern,
bool verbose, bool showSys
if (showMatViews)
appendPQExpBufferStr(&buf, CppAsString2(RELKIND_MATVIEW) ",");
if (showIndexes)
- appendPQExpBufferStr(&buf, CppAsString2(RELKIND_INDEX) ",");
+ appendPQExpBufferStr(&buf, CppAsString2(RELKIND_INDEX) ","
+
CppAsString2(RELKIND_PARTITIONED_INDEX) ",");
if (showSeq)
appendPQExpBufferStr(&buf, CppAsString2(RELKIND_SEQUENCE) ",");
if (showSystem || pattern)
diff --git a/src/include/catalog/catversion.h b/src/include/catalog/catversion.h
index 9a7f5b25a3..7b39aac621 100644
--- a/src/include/catalog/catversion.h
+++ b/src/include/catalog/catversion.h
@@ -53,6 +53,6 @@
*/
/* yyyymmddN */
-#define CATALOG_VERSION_NO 201710161
+#define CATALOG_VERSION_NO 201710231
#endif
diff --git a/src/include/catalog/index.h b/src/include/catalog/index.h
index ab1f9ef1bd..b9914c5d15 100644
--- a/src/include/catalog/index.h
+++ b/src/include/catalog/index.h
@@ -47,10 +47,12 @@ extern void index_check_primary_key(Relation heapRel,
#define INDEX_CREATE_SKIP_BUILD (1 << 2)
#define INDEX_CREATE_CONCURRENT (1 << 3)
#define INDEX_CREATE_IF_NOT_EXISTS (1 << 4)
+#define INDEX_CREATE_PARTITIONED (1 << 5)
extern Oid index_create(Relation heapRelation,
const char *indexRelationName,
Oid indexRelationId,
+ Oid parentIndexRelid,
Oid relFileNode,
IndexInfo *indexInfo,
List *indexColNames,
diff --git a/src/include/catalog/pg_class.h b/src/include/catalog/pg_class.h
index b256657bda..dd8e7ea2b5 100644
--- a/src/include/catalog/pg_class.h
+++ b/src/include/catalog/pg_class.h
@@ -166,6 +166,7 @@ DESCR("");
#define RELKIND_COMPOSITE_TYPE 'c' /* composite type */
#define RELKIND_FOREIGN_TABLE 'f' /* foreign table */
#define RELKIND_PARTITIONED_TABLE 'p' /* partitioned table */
+#define RELKIND_PARTITIONED_INDEX 'I' /* partitioned index */
#define RELPERSISTENCE_PERMANENT 'p' /* regular table */
#define RELPERSISTENCE_UNLOGGED 'u' /* unlogged
permanent table */
diff --git a/src/include/catalog/pg_index.h b/src/include/catalog/pg_index.h
index 8505c3be5f..e7afb0b921 100644
--- a/src/include/catalog/pg_index.h
+++ b/src/include/catalog/pg_index.h
@@ -32,6 +32,7 @@ CATALOG(pg_index,2610) BKI_WITHOUT_OIDS BKI_SCHEMA_MACRO
{
Oid indexrelid; /* OID of the index */
Oid indrelid; /* OID of the relation
it indexes */
+ Oid indparentidx; /* OID of parent index, 0 if
not partitioned */
int16 indnatts; /* number of columns in index */
bool indisunique; /* is this a unique index? */
bool indisprimary; /* is this index for primary key? */
@@ -70,26 +71,27 @@ typedef FormData_pg_index *Form_pg_index;
* compiler constants for pg_index
* ----------------
*/
-#define Natts_pg_index 19
+#define Natts_pg_index 20
#define Anum_pg_index_indexrelid 1
#define Anum_pg_index_indrelid 2
-#define Anum_pg_index_indnatts 3
-#define Anum_pg_index_indisunique 4
-#define Anum_pg_index_indisprimary 5
-#define Anum_pg_index_indisexclusion 6
-#define Anum_pg_index_indimmediate 7
-#define Anum_pg_index_indisclustered 8
-#define Anum_pg_index_indisvalid 9
-#define Anum_pg_index_indcheckxmin 10
-#define Anum_pg_index_indisready 11
-#define Anum_pg_index_indislive 12
-#define Anum_pg_index_indisreplident 13
-#define Anum_pg_index_indkey 14
-#define Anum_pg_index_indcollation 15
-#define Anum_pg_index_indclass 16
-#define Anum_pg_index_indoption 17
-#define Anum_pg_index_indexprs 18
-#define Anum_pg_index_indpred 19
+#define Anum_pg_index_indparentidx 3
+#define Anum_pg_index_indnatts 4
+#define Anum_pg_index_indisunique 5
+#define Anum_pg_index_indisprimary 6
+#define Anum_pg_index_indisexclusion 7
+#define Anum_pg_index_indimmediate 8
+#define Anum_pg_index_indisclustered 9
+#define Anum_pg_index_indisvalid 10
+#define Anum_pg_index_indcheckxmin 11
+#define Anum_pg_index_indisready 12
+#define Anum_pg_index_indislive 13
+#define Anum_pg_index_indisreplident 14
+#define Anum_pg_index_indkey 15
+#define Anum_pg_index_indcollation 16
+#define Anum_pg_index_indclass 17
+#define Anum_pg_index_indoption 18
+#define Anum_pg_index_indexprs 19
+#define Anum_pg_index_indpred 20
/*
* Index AMs that support ordered scans must support these two indoption
diff --git a/src/include/commands/defrem.h b/src/include/commands/defrem.h
index f7bb4a54f7..1231735b2c 100644
--- a/src/include/commands/defrem.h
+++ b/src/include/commands/defrem.h
@@ -25,12 +25,13 @@ extern void RemoveObjects(DropStmt *stmt);
extern ObjectAddress DefineIndex(Oid relationId,
IndexStmt *stmt,
Oid indexRelationId,
+ Oid parentIndexId,
bool is_alter_table,
bool check_rights,
bool check_not_in_use,
bool skip_build,
bool quiet);
-extern Oid ReindexIndex(RangeVar *indexRelation, int options);
+extern void ReindexIndex(RangeVar *indexRelation, int options);
extern Oid ReindexTable(RangeVar *relation, int options);
extern void ReindexMultipleTables(const char *objectName, ReindexObjectType
objectKind,
int options);
--
2.11.0
>From efe608b1f8a57b20436f925244bbd68c0442a997 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvhe...@alvh.no-ip.org>
Date: Mon, 23 Oct 2017 10:18:38 +0200
Subject: [PATCH v2 3/7] export generateClonedIndexStmt
---
src/backend/parser/parse_utilcmd.c | 11 ++++-------
src/include/parser/parse_utilcmd.h | 3 +++
2 files changed, 7 insertions(+), 7 deletions(-)
diff --git a/src/backend/parser/parse_utilcmd.c
b/src/backend/parser/parse_utilcmd.c
index 27e568fc62..1c25fe74c9 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -117,9 +117,6 @@ static void transformTableLikeClause(CreateStmtContext *cxt,
TableLikeClause
*table_like_clause);
static void transformOfType(CreateStmtContext *cxt,
TypeName *ofTypename);
-static IndexStmt *generateClonedIndexStmt(CreateStmtContext *cxt,
- Relation source_idx,
- const AttrNumber *attmap, int
attmap_length);
static List *get_collation(Oid collation, Oid actual_datatype);
static List *get_opclass(Oid opclass, Oid actual_datatype);
static void transformIndexConstraints(CreateStmtContext *cxt);
@@ -1173,7 +1170,7 @@ transformTableLikeClause(CreateStmtContext *cxt,
TableLikeClause *table_like_cla
parent_index = index_open(parent_index_oid,
AccessShareLock);
/* Build CREATE INDEX statement to recreate the
parent_index */
- index_stmt = generateClonedIndexStmt(cxt, parent_index,
+ index_stmt = generateClonedIndexStmt(cxt->relation,
parent_index,
attmap, tupleDesc->natts);
/* Copy comment on index, if requested */
@@ -1253,8 +1250,8 @@ transformOfType(CreateStmtContext *cxt, TypeName
*ofTypename)
* Generate an IndexStmt node using information from an already existing index
* "source_idx". Attribute numbers should be adjusted according to attmap.
*/
-static IndexStmt *
-generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
+IndexStmt *
+generateClonedIndexStmt(RangeVar *heapRel, Relation source_idx,
const AttrNumber *attmap, int
attmap_length)
{
Oid source_relid = RelationGetRelid(source_idx);
@@ -1310,7 +1307,7 @@ generateClonedIndexStmt(CreateStmtContext *cxt, Relation
source_idx,
/* Begin building the IndexStmt */
index = makeNode(IndexStmt);
- index->relation = cxt->relation;
+ index->relation = heapRel;
index->accessMethod = pstrdup(NameStr(amrec->amname));
if (OidIsValid(idxrelrec->reltablespace))
index->tableSpace =
get_tablespace_name(idxrelrec->reltablespace);
diff --git a/src/include/parser/parse_utilcmd.h
b/src/include/parser/parse_utilcmd.h
index e749432ef0..407f8a5abb 100644
--- a/src/include/parser/parse_utilcmd.h
+++ b/src/include/parser/parse_utilcmd.h
@@ -27,5 +27,8 @@ extern void transformRuleStmt(RuleStmt *stmt, const char
*queryString,
extern List *transformCreateSchemaStmt(CreateSchemaStmt *stmt);
extern PartitionBoundSpec *transformPartitionBound(ParseState *pstate,
Relation parent,
PartitionBoundSpec *spec);
+extern IndexStmt *generateClonedIndexStmt(RangeVar *heapRel,
+ Relation source_idx,
+ const AttrNumber *attmap, int
attmap_length);
#endif /* PARSE_UTILCMD_H */
--
2.11.0
>From db7c60ed2647d566be9057d161a95ef8d2270dad Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvhe...@alvh.no-ip.org>
Date: Wed, 18 Oct 2017 19:49:15 +0200
Subject: [PATCH v2 4/7] Match/create indexes during ATTACH PARTITION
---
src/backend/catalog/index.c | 45 ++++++++++++++++++-
src/backend/commands/indexcmds.c | 25 +++++++++++
src/backend/commands/tablecmds.c | 97 ++++++++++++++++++++++++++++++++++++++++
src/include/catalog/index.h | 4 ++
4 files changed, 170 insertions(+), 1 deletion(-)
diff --git a/src/backend/catalog/index.c b/src/backend/catalog/index.c
index 8d15db0ec1..8588b470b7 100644
--- a/src/backend/catalog/index.c
+++ b/src/backend/catalog/index.c
@@ -99,6 +99,7 @@ static void InitializeAttributeOids(Relation indexRelation,
int numatts, Oid indexoid);
static void AppendAttributeTuples(Relation indexRelation, int numatts);
static void UpdateIndexRelation(Oid indexoid, Oid heapoid,
+ Oid parentIndexId,
IndexInfo *indexInfo,
Oid *collationOids,
Oid *classOids,
@@ -552,6 +553,7 @@ AppendAttributeTuples(Relation indexRelation, int numatts)
static void
UpdateIndexRelation(Oid indexoid,
Oid heapoid,
+ Oid parentIndexOid,
IndexInfo *indexInfo,
Oid *collationOids,
Oid *classOids,
@@ -625,6 +627,7 @@ UpdateIndexRelation(Oid indexoid,
values[Anum_pg_index_indexrelid - 1] = ObjectIdGetDatum(indexoid);
values[Anum_pg_index_indrelid - 1] = ObjectIdGetDatum(heapoid);
+ values[Anum_pg_index_indparentidx - 1 ] =
ObjectIdGetDatum(parentIndexOid);
values[Anum_pg_index_indnatts - 1] =
Int16GetDatum(indexInfo->ii_NumIndexAttrs);
values[Anum_pg_index_indisunique - 1] =
BoolGetDatum(indexInfo->ii_Unique);
values[Anum_pg_index_indisprimary - 1] = BoolGetDatum(primary);
@@ -932,7 +935,8 @@ index_create(Relation heapRelation,
* (Or, could define a rule to maintain the predicate) --Nels,
Feb '92
* ----------------
*/
- UpdateIndexRelation(indexRelationId, heapRelationId, indexInfo,
+ UpdateIndexRelation(indexRelationId, heapRelationId, parentIndexRelid,
+ indexInfo,
collationObjectId,
classObjectId, coloptions,
isprimary, is_exclusion,
(constr_flags &
INDEX_CONSTR_CREATE_DEFERRABLE) == 0,
@@ -1719,6 +1723,45 @@ BuildIndexInfo(Relation index)
return ii;
}
+/*
+ * Compare two IndexInfos, and return true if they are similar enough that an
+ * index built with one can pass as an index built with the other. If an
+ * attmap is given, the indexes are from tables where the columns might be in
+ * different physical locations, so use the map to match the column by name.
+ */
+bool
+CompareIndexInfo(IndexInfo *info1, IndexInfo *info2, AttrNumber *attmap)
+{
+ int i;
+
+ if (info1->ii_NumIndexAttrs != info2->ii_NumIndexAttrs)
+ return false;
+
+ for (i = 0; i < info1->ii_NumIndexAttrs; i++)
+ {
+ /* XXX use attmap here */
+ if (info1->ii_KeyAttrNumbers[i] != info2->ii_KeyAttrNumbers[i])
+ return false;
+ }
+
+ /* Expression indexes are currently not considered equal. Someday ...
*/
+ if (info1->ii_Expressions != NIL || info2->ii_Expressions != NIL)
+ return false;
+
+ /* Can this be relaxed? */
+ if (!equal(info1->ii_Predicate, info2->ii_Predicate))
+ return false;
+
+ /* Probably this can be relaxed someday */
+ if (info1->ii_ExclusionOps != NULL || info2->ii_ExclusionOps != NULL)
+ return false;
+
+ if (info1->ii_Unique != info2->ii_Unique)
+ return false;
+
+ return true;
+}
+
/* ----------------
* BuildSpeculativeIndexInfo
* Add extra state to IndexInfo record
diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index a9a8969422..b22ad68c48 100644
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -2181,3 +2181,28 @@ ReindexPartitionedIndex(Relation parentIdx)
heap_close(parentIdx, AccessExclusiveLock);
}
+
+/*
+ * Update the pg_index tuple corresponding to the given index on a partition
+ * to indicate that the given index OID is now its parent partitioned index.
+ */
+void
+indexSetParentIndex(Relation idx, Oid parentOid)
+{
+ Relation pgindex;
+ HeapTuple indTup;
+ Form_pg_index indForm;
+
+ /* Make sure this is an index */
+ Assert(idx->rd_rel->relkind == RELKIND_INDEX ||
+ idx->rd_rel->relkind == RELKIND_PARTITIONED_INDEX);
+
+ pgindex = heap_open(IndexRelationId, RowExclusiveLock);
+ indTup = idx->rd_indextuple;
+ indForm = (Form_pg_index) GETSTRUCT(indTup);
+ indForm->indparentidx = parentOid;
+
+ CatalogTupleUpdate(pgindex, &(indTup->t_self), indTup);
+
+ heap_close(pgindex, RowExclusiveLock);
+}
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 17cb2f05e7..6ffe98d10f 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -13953,6 +13953,103 @@ ATExecAttachPartition(List **wqueue, Relation rel,
PartitionCmd *cmd)
StorePartitionBound(attachrel, rel, cmd->bound);
/*
+ * Ensure a correct set of indexes in the partition.
+ * XXX probably this should be a new function.
+ */
+ {
+ AttrNumber *attmap = NULL;
+ List *idxes;
+ List *attachRelIdxs;
+ Relation *attachrelIdxRels;
+ IndexInfo **attachInfos;
+ int i;
+ ListCell *cell;
+
+ idxes = RelationGetIndexList(rel);
+ attachRelIdxs = RelationGetIndexList(attachrel);
+ attachrelIdxRels = palloc(sizeof(Relation) *
list_length(attachRelIdxs));
+ attachInfos = palloc(sizeof(IndexInfo *) *
list_length(attachRelIdxs));
+
+ i = 0;
+ foreach(cell, attachRelIdxs)
+ {
+ Oid cldIdxId = lfirst_oid(cell);
+
+ attachrelIdxRels[i] = index_open(cldIdxId,
AccessShareLock);
+ attachInfos[i] = BuildIndexInfo(attachrelIdxRels[i]);
+ i++;
+ }
+
+ /*
+ * For each index on the partitioned table, find a match in the
table
+ * being attached as partition; if one is not found, create one.
+ */
+ foreach(cell, idxes)
+ {
+ Oid idx = lfirst_oid(cell);
+ Relation idxRel = index_open(idx,
AccessShareLock);
+ IndexInfo *info;
+ bool found = false;
+
+ if (idxRel->rd_rel->relkind !=
RELKIND_PARTITIONED_INDEX)
+ {
+ index_close(idxRel, AccessShareLock);
+ continue;
+ }
+ info = BuildIndexInfo(idxRel);
+ if (attmap == NULL)
+ attmap =
+
convert_tuples_by_name_map(RelationGetDescr(attachrel),
+
RelationGetDescr(rel),
+
gettext_noop("could not convert row type"));
+
+ for (i = 0; i < list_length(attachRelIdxs); i++)
+ {
+ if (CompareIndexInfo(info, attachInfos[i],
attmap))
+ {
+ /* bingo. */
+
indexSetParentIndex(attachrelIdxRels[i], idx);
+ found = true;
+ }
+ }
+ if (!found)
+ {
+ RangeVar *heap_rv;
+ IndexStmt *stmt;
+
+ heap_rv =
makeRangeVar(get_namespace_name(RelationGetNamespace(attachrel)),
+
RelationGetRelationName(attachrel),
+ -1);
+ stmt = generateClonedIndexStmt(heap_rv, idxRel,
attmap,
+
RelationGetDescr(rel)->natts);
+ /* XXX emit a DDL event here */
+ DefineIndex(RelationGetRelid(attachrel),
+ stmt,
+ InvalidOid,
+
RelationGetRelid(idxRel),
+ false, false, false,
false, false);
+ }
+
+ index_close(idxRel, AccessShareLock);
+ }
+
+ /* Clean up. */
+ if (attmap)
+ pfree(attmap);
+
+ for (i = 0; i < list_length(attachRelIdxs); i++)
+ {
+ pfree(attachInfos[i]);
+ index_close(attachrelIdxRels[i], AccessShareLock);
+ }
+
+ if (idxes)
+ pfree(idxes);
+ if (attachRelIdxs)
+ pfree(attachRelIdxs);
+ }
+
+ /*
* Generate partition constraint from the partition bound specification.
* If the parent itself is a partition, make sure to include its
* constraint as well.
diff --git a/src/include/catalog/index.h b/src/include/catalog/index.h
index b9914c5d15..8438ffe4ce 100644
--- a/src/include/catalog/index.h
+++ b/src/include/catalog/index.h
@@ -86,6 +86,8 @@ extern void index_drop(Oid indexId, bool concurrent);
extern IndexInfo *BuildIndexInfo(Relation index);
+extern bool CompareIndexInfo(IndexInfo *info1, IndexInfo *info2, AttrNumber
*attmap);
+
extern void BuildSpeculativeIndexInfo(Relation index, IndexInfo *ii);
extern void FormIndexDatum(IndexInfo *indexInfo,
@@ -136,4 +138,6 @@ extern bool ReindexIsProcessingHeap(Oid heapOid);
extern bool ReindexIsProcessingIndex(Oid indexOid);
extern Oid IndexGetRelation(Oid indexId, bool missing_ok);
+extern void indexSetParentIndex(Relation idx, Oid parentOid);
+
#endif /* INDEX_H */
--
2.11.0
>From 84903a65f3bb2eb7b9c1a7fa96fc73766b142686 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvhe...@alvh.no-ip.org>
Date: Mon, 23 Oct 2017 12:42:34 +0200
Subject: [PATCH v2 5/7] add regression test
---
src/test/regress/expected/indexing.out | 204 +++++++++++++++++++++++++++++++++
src/test/regress/parallel_schedule | 2 +-
src/test/regress/serial_schedule | 1 +
src/test/regress/sql/indexing.sql | 81 +++++++++++++
4 files changed, 287 insertions(+), 1 deletion(-)
create mode 100644 src/test/regress/expected/indexing.out
create mode 100644 src/test/regress/sql/indexing.sql
diff --git a/src/test/regress/expected/indexing.out
b/src/test/regress/expected/indexing.out
new file mode 100644
index 0000000000..a0615fa3e6
--- /dev/null
+++ b/src/test/regress/expected/indexing.out
@@ -0,0 +1,204 @@
+-- Creating an index on a partitioned table makes the partitions
+-- automatically get the index
+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 table idxpart2 partition of idxpart for values from (10) to (100)
+ partition by range (b);
+create table idxpart21 partition of idxpart2 for values from (0) to (100);
+create index on idxpart (a);
+select relname, relkind, indparentidx::regclass
+ from pg_class left join pg_index on (indexrelid = oid)
+ where relname like 'idxpart%' order by relname;
+ relname | relkind | indparentidx
+-----------------+---------+----------------
+ idxpart | p |
+ idxpart1 | r |
+ idxpart1_a_idx | i | idxpart_a_idx
+ idxpart2 | p |
+ idxpart21 | r |
+ idxpart21_a_idx | i | idxpart2_a_idx
+ idxpart2_a_idx | I | idxpart_a_idx
+ idxpart_a_idx | I | -
+(8 rows)
+
+drop table idxpart;
+-- Some unsupported cases
+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 unique index on idxpart (a);
+ERROR: cannot create unique index on partitioned table "idxpart"
+create index concurrently on idxpart (a);
+ERROR: cannot create index on partitioned table "idxpart" concurrently
+drop table idxpart;
+-- If a table without index is attached as partition to a table with
+-- an index, the index is automatically created
+create table idxpart (a int, b int, c text) partition by range (a);
+create index idxparti on idxpart (a);
+create index idxparti2 on idxpart (b, c);
+create table idxpart1 (like idxpart);
+\d idxpart1
+ Table "public.idxpart1"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | |
+ b | integer | | |
+ c | text | | |
+
+alter table idxpart attach partition idxpart1 for values from (0) to (10);
+\d idxpart1
+ Table "public.idxpart1"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | |
+ b | integer | | |
+ c | text | | |
+Partition of: idxpart FOR VALUES FROM (0) TO (10)
+Indexes:
+ "idxpart1_a_idx" btree (a)
+ "idxpart1_b_c_idx" btree (b, c)
+
+drop table idxpart;
+-- Opposite case: the attached table already has the indexes, so duplicate
+-- copies should not be created
+create table idxpart (a int, b int, c text) partition by range (a);
+create index idxparti on idxpart (a);
+create index idxparti2 on idxpart (b, c);
+create table idxpart1 (like idxpart including indexes);
+\d idxpart1
+ Table "public.idxpart1"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | |
+ b | integer | | |
+ c | text | | |
+Indexes:
+ "idxpart1_a_idx" btree (a)
+ "idxpart1_b_c_idx" btree (b, c)
+
+select relname, relkind, indparentidx::regclass
+ from pg_class left join pg_index on (indexrelid = oid)
+ where relname like 'idxpart%' order by relname;
+ relname | relkind | indparentidx
+------------------+---------+--------------
+ idxpart | p |
+ idxpart1 | r |
+ idxpart1_a_idx | i | -
+ idxpart1_b_c_idx | i | -
+ idxparti | I | -
+ idxparti2 | I | -
+(6 rows)
+
+alter table idxpart attach partition idxpart1 for values from (0) to (10);
+\d idxpart1
+ Table "public.idxpart1"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | |
+ b | integer | | |
+ c | text | | |
+Partition of: idxpart FOR VALUES FROM (0) TO (10)
+Indexes:
+ "idxpart1_a_idx" btree (a)
+ "idxpart1_b_c_idx" btree (b, c)
+
+select relname, relkind, indparentidx::regclass
+ from pg_class left join pg_index on (indexrelid = oid)
+ where relname like 'idxpart%' order by relname;
+ relname | relkind | indparentidx
+------------------+---------+--------------
+ idxpart | p |
+ idxpart1 | r |
+ idxpart1_a_idx | i | idxparti
+ idxpart1_b_c_idx | i | idxparti2
+ idxparti | I | -
+ idxparti2 | I | -
+(6 rows)
+
+drop table idxpart;
+-- Make sure the partition columns are mapped correctly
+create table idxpart (a int, b int, c text) partition by range (a);
+create index idxparti on idxpart (a);
+create index idxparti2 on idxpart (c, b);
+create table idxpart1 (c text, a int, b int);
+alter table idxpart attach partition idxpart1 for values from (0) to (10);
+\d idxpart1
+ Table "public.idxpart1"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ c | text | | |
+ a | integer | | |
+ b | integer | | |
+Partition of: idxpart FOR VALUES FROM (0) TO (10)
+Indexes:
+ "idxpart1_a_idx" btree (a)
+ "idxpart1_c_b_idx" btree (c, b)
+
+drop table idxpart;
+-- Make sure things work if either table has dropped columns
+create table idxpart (a int, b int, c int, d int) partition by range (a);
+alter table idxpart drop column c;
+create index idxparti on idxpart (a);
+create index idxparti2 on idxpart (b, d);
+create table idxpart1 (like idxpart);
+alter table idxpart attach partition idxpart1 for values from (0) to (10);
+\d idxpart1
+ Table "public.idxpart1"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | |
+ b | integer | | |
+ d | integer | | |
+Partition of: idxpart FOR VALUES FROM (0) TO (10)
+Indexes:
+ "idxpart1_a_idx" btree (a)
+ "idxpart1_b_d_idx" btree (b, d)
+
+select attrelid::regclass, attname, attnum from pg_attribute
+ where attrelid in ('idxpart'::regclass, 'idxpart1'::regclass) and attnum > 0
+ order by attrelid::regclass, attnum;
+ attrelid | attname | attnum
+----------+------------------------------+--------
+ idxpart | a | 1
+ idxpart | b | 2
+ idxpart | ........pg.dropped.3........ | 3
+ idxpart | d | 4
+ idxpart1 | a | 1
+ idxpart1 | b | 2
+ idxpart1 | d | 3
+(7 rows)
+
+drop table idxpart;
+create table idxpart (a int, b int, c int) partition by range (a);
+create table idxpart1 (zz int, like idxpart, aa int);
+alter table idxpart1 drop column zz, drop column aa;
+create index idxparti on idxpart (a);
+create index idxparti2 on idxpart (b, c);
+alter table idxpart attach partition idxpart1 for values from (0) to (10);
+\d idxpart1
+ Table "public.idxpart1"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | |
+ b | integer | | |
+ c | integer | | |
+Partition of: idxpart FOR VALUES FROM (0) TO (10)
+Indexes:
+ "idxpart1_a_idx" btree (a)
+ "idxpart1_b_c_idx" btree (b, c)
+
+select attrelid::regclass, attname, attnum from pg_attribute
+ where attrelid in ('idxpart'::regclass, 'idxpart1'::regclass) and attnum > 0
+ order by attrelid::regclass, attnum;
+ attrelid | attname | attnum
+----------+------------------------------+--------
+ idxpart | a | 1
+ idxpart | b | 2
+ idxpart | c | 3
+ idxpart1 | ........pg.dropped.1........ | 1
+ idxpart1 | a | 2
+ idxpart1 | b | 3
+ idxpart1 | c | 4
+ idxpart1 | ........pg.dropped.5........ | 5
+(8 rows)
+
+drop table idxpart;
diff --git a/src/test/regress/parallel_schedule
b/src/test/regress/parallel_schedule
index aa5e6af621..591e7da337 100644
--- a/src/test/regress/parallel_schedule
+++ b/src/test/regress/parallel_schedule
@@ -116,7 +116,7 @@ test: plancache limit plpgsql copy2 temp domain rangefuncs
prepare without_oid c
# ----------
# Another group of parallel tests
# ----------
-test: identity partition_join reloptions
+test: identity partition_join reloptions indexing
# event triggers cannot run concurrently with any test that runs DDL
test: event_trigger
diff --git a/src/test/regress/serial_schedule b/src/test/regress/serial_schedule
index 3866314a92..d5b5ec8472 100644
--- a/src/test/regress/serial_schedule
+++ b/src/test/regress/serial_schedule
@@ -181,5 +181,6 @@ test: xml
test: identity
test: partition_join
test: reloptions
+test: indexing
test: event_trigger
test: stats
diff --git a/src/test/regress/sql/indexing.sql
b/src/test/regress/sql/indexing.sql
new file mode 100644
index 0000000000..944b850099
--- /dev/null
+++ b/src/test/regress/sql/indexing.sql
@@ -0,0 +1,81 @@
+-- Creating an index on a partitioned table makes the partitions
+-- automatically get the index
+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 table idxpart2 partition of idxpart for values from (10) to (100)
+ partition by range (b);
+create table idxpart21 partition of idxpart2 for values from (0) to (100);
+create index on idxpart (a);
+select relname, relkind, indparentidx::regclass
+ from pg_class left join pg_index on (indexrelid = oid)
+ where relname like 'idxpart%' order by relname;
+drop table idxpart;
+
+-- Some unsupported cases
+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 unique index on idxpart (a);
+create index concurrently on idxpart (a);
+drop table idxpart;
+
+-- If a table without index is attached as partition to a table with
+-- an index, the index is automatically created
+create table idxpart (a int, b int, c text) partition by range (a);
+create index idxparti on idxpart (a);
+create index idxparti2 on idxpart (b, c);
+create table idxpart1 (like idxpart);
+\d idxpart1
+alter table idxpart attach partition idxpart1 for values from (0) to (10);
+\d idxpart1
+drop table idxpart;
+
+-- Opposite case: the attached table already has the indexes, so duplicate
+-- copies should not be created
+create table idxpart (a int, b int, c text) partition by range (a);
+create index idxparti on idxpart (a);
+create index idxparti2 on idxpart (b, c);
+create table idxpart1 (like idxpart including indexes);
+\d idxpart1
+select relname, relkind, indparentidx::regclass
+ from pg_class left join pg_index on (indexrelid = oid)
+ where relname like 'idxpart%' order by relname;
+alter table idxpart attach partition idxpart1 for values from (0) to (10);
+\d idxpart1
+select relname, relkind, indparentidx::regclass
+ from pg_class left join pg_index on (indexrelid = oid)
+ where relname like 'idxpart%' order by relname;
+drop table idxpart;
+
+-- Make sure the partition columns are mapped correctly
+create table idxpart (a int, b int, c text) partition by range (a);
+create index idxparti on idxpart (a);
+create index idxparti2 on idxpart (c, b);
+create table idxpart1 (c text, a int, b int);
+alter table idxpart attach partition idxpart1 for values from (0) to (10);
+\d idxpart1
+drop table idxpart;
+
+-- Make sure things work if either table has dropped columns
+create table idxpart (a int, b int, c int, d int) partition by range (a);
+alter table idxpart drop column c;
+create index idxparti on idxpart (a);
+create index idxparti2 on idxpart (b, d);
+create table idxpart1 (like idxpart);
+alter table idxpart attach partition idxpart1 for values from (0) to (10);
+\d idxpart1
+select attrelid::regclass, attname, attnum from pg_attribute
+ where attrelid in ('idxpart'::regclass, 'idxpart1'::regclass) and attnum > 0
+ order by attrelid::regclass, attnum;
+drop table idxpart;
+
+create table idxpart (a int, b int, c int) partition by range (a);
+create table idxpart1 (zz int, like idxpart, aa int);
+alter table idxpart1 drop column zz, drop column aa;
+create index idxparti on idxpart (a);
+create index idxparti2 on idxpart (b, c);
+alter table idxpart attach partition idxpart1 for values from (0) to (10);
+\d idxpart1
+select attrelid::regclass, attname, attnum from pg_attribute
+ where attrelid in ('idxpart'::regclass, 'idxpart1'::regclass) and attnum > 0
+ order by attrelid::regclass, attnum;
+drop table idxpart;
--
2.11.0
>From 425bf3b066825fbcf258bfaf5c0d079d12f18ff8 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvhe...@alvh.no-ip.org>
Date: Thu, 26 Oct 2017 11:15:39 +0200
Subject: [PATCH v2 6/7] Get rid of copy_partition_key
Instead, allocate the objects in the correct context right from the
start.
---
src/backend/utils/cache/relcache.c | 77 ++++++++------------------------------
1 file changed, 16 insertions(+), 61 deletions(-)
diff --git a/src/backend/utils/cache/relcache.c
b/src/backend/utils/cache/relcache.c
index ec3b81cd2b..8b5ca749fd 100644
--- a/src/backend/utils/cache/relcache.c
+++ b/src/backend/utils/cache/relcache.c
@@ -266,7 +266,6 @@ static Relation AllocateRelationDesc(Form_pg_class relp);
static void RelationParseRelOptions(Relation relation, HeapTuple tuple);
static void RelationBuildTupleDesc(Relation relation);
static void RelationBuildPartitionKey(Relation relation);
-static PartitionKey copy_partition_key(PartitionKey fromkey);
static Relation RelationBuildDesc(Oid targetRelId, bool insertIt);
static void RelationInitPhysicalAddr(Relation relation);
static void load_critical_index(Oid indexoid, Oid heapoid);
@@ -853,6 +852,11 @@ RelationBuildPartitionKey(Relation relation)
if (!HeapTupleIsValid(tuple))
return;
+ partkeycxt = AllocSetContextCreate(CacheMemoryContext,
+
RelationGetRelationName(relation),
+
ALLOCSET_SMALL_SIZES);
+ oldcxt = MemoryContextSwitchTo(partkeycxt);
+
key = (PartitionKey) palloc0(sizeof(PartitionKeyData));
/* Fixed-length attributes */
@@ -860,6 +864,8 @@ RelationBuildPartitionKey(Relation relation)
key->strategy = form->partstrat;
key->partnatts = form->partnatts;
+ PG_TRY();
+ {
/*
* We can rely on the first variable-length attribute being mapped to
the
* relevant field of the catalog's C struct, because all previous
@@ -983,72 +989,21 @@ RelationBuildPartitionKey(Relation relation)
}
ReleaseSysCache(tuple);
+ }
+ PG_CATCH();
+ {
+ MemoryContextDelete(partkeycxt);
+ PG_RE_THROW();
+ }
+ PG_END_TRY();
- /* Success --- now copy to the cache memory */
- partkeycxt = AllocSetContextCreate(CacheMemoryContext,
-
RelationGetRelationName(relation),
-
ALLOCSET_SMALL_SIZES);
+ /* Success --- make the relcache point to the newly constructed key */
relation->rd_partkeycxt = partkeycxt;
- oldcxt = MemoryContextSwitchTo(relation->rd_partkeycxt);
- relation->rd_partkey = copy_partition_key(key);
+ relation->rd_partkey = key;
MemoryContextSwitchTo(oldcxt);
}
/*
- * copy_partition_key
- *
- * The copy is allocated in the current memory context.
- */
-static PartitionKey
-copy_partition_key(PartitionKey fromkey)
-{
- PartitionKey newkey;
- int n;
-
- newkey = (PartitionKey) palloc(sizeof(PartitionKeyData));
-
- newkey->strategy = fromkey->strategy;
- newkey->partnatts = n = fromkey->partnatts;
-
- newkey->partattrs = (AttrNumber *) palloc(n * sizeof(AttrNumber));
- memcpy(newkey->partattrs, fromkey->partattrs, n * sizeof(AttrNumber));
-
- newkey->partexprs = copyObject(fromkey->partexprs);
-
- newkey->partopfamily = (Oid *) palloc(n * sizeof(Oid));
- memcpy(newkey->partopfamily, fromkey->partopfamily, n * sizeof(Oid));
-
- newkey->partopcintype = (Oid *) palloc(n * sizeof(Oid));
- memcpy(newkey->partopcintype, fromkey->partopcintype, n * sizeof(Oid));
-
- newkey->partsupfunc = (FmgrInfo *) palloc(n * sizeof(FmgrInfo));
- memcpy(newkey->partsupfunc, fromkey->partsupfunc, n * sizeof(FmgrInfo));
-
- newkey->partcollation = (Oid *) palloc(n * sizeof(Oid));
- memcpy(newkey->partcollation, fromkey->partcollation, n * sizeof(Oid));
-
- newkey->parttypid = (Oid *) palloc(n * sizeof(Oid));
- memcpy(newkey->parttypid, fromkey->parttypid, n * sizeof(Oid));
-
- newkey->parttypmod = (int32 *) palloc(n * sizeof(int32));
- memcpy(newkey->parttypmod, fromkey->parttypmod, n * sizeof(int32));
-
- newkey->parttyplen = (int16 *) palloc(n * sizeof(int16));
- memcpy(newkey->parttyplen, fromkey->parttyplen, n * sizeof(int16));
-
- newkey->parttypbyval = (bool *) palloc(n * sizeof(bool));
- memcpy(newkey->parttypbyval, fromkey->parttypbyval, n * sizeof(bool));
-
- newkey->parttypalign = (char *) palloc(n * sizeof(bool));
- memcpy(newkey->parttypalign, fromkey->parttypalign, n * sizeof(char));
-
- newkey->parttypcoll = (Oid *) palloc(n * sizeof(Oid));
- memcpy(newkey->parttypcoll, fromkey->parttypcoll, n * sizeof(Oid));
-
- return newkey;
-}
-
-/*
* equalRuleLocks
*
* Determine whether two RuleLocks are equivalent
--
2.11.0
>From e7d5dfe455bd8fc98ffa94f6ed560d878d2d1584 Mon Sep 17 00:00:00 2001
From: Alvaro Herrera <alvhe...@alvh.no-ip.org>
Date: Thu, 26 Oct 2017 19:40:03 +0200
Subject: [PATCH v2 7/7] allow indexes on partitioned tables to be unique
---
src/backend/commands/indexcmds.c | 75 +++++++++++++---
src/backend/commands/tablecmds.c | 48 ++++++++++
src/backend/parser/parse_utilcmd.c | 24 -----
src/test/regress/expected/alter_table.out | 8 --
src/test/regress/expected/create_table.out | 12 ---
src/test/regress/expected/indexing.out | 135 ++++++++++++++++++++++++++++-
src/test/regress/sql/alter_table.sql | 2 -
src/test/regress/sql/create_table.sql | 8 --
src/test/regress/sql/indexing.sql | 73 +++++++++++++++-
9 files changed, 318 insertions(+), 67 deletions(-)
diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index b22ad68c48..90eb0a013d 100644
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -425,21 +425,11 @@ DefineIndex(Oid relationId,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot create index on
partitioned table \"%s\" concurrently",
RelationGetRelationName(rel))));
- if (stmt->unique)
- ereport(ERROR,
- (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot create unique index on
partitioned table \"%s\"",
-
RelationGetRelationName(rel))));
if (stmt->excludeOpNames)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot create exclusion
constraints on partitioned table \"%s\"",
RelationGetRelationName(rel))));
- if (is_alter_table)
- ereport(ERROR,
- (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- /* FIXME */
- errmsg("not sure what you're doing,
but it's not supported")));
/* XXX what else? */
}
@@ -637,6 +627,71 @@ DefineIndex(Oid relationId,
index_check_primary_key(rel, indexInfo, is_alter_table);
/*
+ * If this table is partitioned and we're creating a unique index or a
+ * primary key, make sure that the indexed columns are part of the
+ * partition key. Otherwise it would be possible to violate uniqueness
by
+ * putting values that ought to be unique in different partitions.
+ *
+ * We could lift this limitation if we had global indexes, but those
have
+ * their own problems, so this is a useful feature combination.
+ *
+ * XXX in some cases rel->rd_partkey is NULL, which caused this code to
+ * crash. In what cases can that happen?
+ */
+ if (partitioned && (stmt->unique || stmt->primary) &&
+ (rel->rd_partkey != NULL))
+ {
+ int i;
+ PartitionKey key = rel->rd_partkey;
+
+ /*
+ * A partitioned table can have unique indexes, as long as all
the
+ * columns in the unique key appear in the partition key.
Because
+ * partitions are non-overlapping, this guarantees that there
is a
+ * single partition that can contain any given key, and thus the
+ * uniqueness is guaranteed globally.
+ */
+
+ for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
+ {
+ bool found;
+ int j;
+
+ /*
+ * Expression indexes are not supported yet. We can
probably use
+ * pull_varattnos() on the expression, and verify that
all the
+ * vars mentioned correspond to columns of the
partition key.
+ */
+ if (indexInfo->ii_KeyAttrNumbers[i] == 0)
+ ereport(ERROR,
+
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("UNIQUE indexes
containing expressions are not supported")));
+
+ found = false;
+ for (j = 0; j < key->partnatts; j++)
+ {
+ if (indexInfo->ii_KeyAttrNumbers[i] ==
key->partattrs[j])
+ {
+ found = true;
+ break; /* all good */
+ }
+ }
+ if (!found)
+ {
+ char *attname;
+
+ attname =
NameStr(TupleDescAttr(RelationGetDescr(rel),
+
indexInfo->ii_KeyAttrNumbers[i] - 1)->attname);
+ ereport(ERROR,
+
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("UNIQUE index on table
\"%s\" contains column \"%s\" which is not part of the partition key",
+
RelationGetRelationName(rel), attname)));
+ }
+ }
+ }
+
+
+ /*
* We disallow indexes on system columns other than OID. They would not
* necessarily get updated correctly, and they don't seem useful anyway.
*/
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 6ffe98d10f..67df56aa2d 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -906,6 +906,54 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
}
/*
+ * Now that the partition spec is installed, we can create any indexes
+ * from the partitioned table into the partitions. We can't do it
+ * earlier, because if this is a partition which in turn is partitioned,
+ * DefineIndex would not be able to recurse correctly into children to
+ * apply indexes from the parent table.
+ */
+ if (stmt->partbound)
+ {
+ Oid parentId = linitial_oid(inheritOids);
+ Relation parent;
+ List *idxlist;
+ ListCell *cell;
+
+ /* Already have strong enough lock on the parent */
+ parent = heap_open(parentId, NoLock);
+ idxlist = RelationGetIndexList(parent);
+
+ /*
+ * For each index in the parent table, create one in the
partition
+ */
+ foreach(cell, idxlist)
+ {
+ Relation idxRel = index_open(lfirst_oid(cell),
AccessShareLock);
+ AttrNumber *attmap;
+ RangeVar *heap_rv;
+ IndexStmt *idxstmt;
+
+ attmap =
convert_tuples_by_name_map(RelationGetDescr(rel),
+
RelationGetDescr(parent),
+
gettext_noop("could not convert row type"));
+ heap_rv =
makeRangeVar(get_namespace_name(RelationGetNamespace(rel)),
+ relname, -1);
+ idxstmt = generateClonedIndexStmt(heap_rv, idxRel,
attmap,
+
RelationGetDescr(rel)->natts);
+ DefineIndex(RelationGetRelid(rel),
+ idxstmt,
+ InvalidOid,
+ RelationGetRelid(idxRel),
+ false, false, false, false,
false);
+
+ index_close(idxRel, AccessShareLock);
+ }
+
+ list_free(idxlist);
+ heap_close(parent, NoLock);
+ }
+
+ /*
* Now add any newly specified column default values and CHECK
constraints
* to the new relation. These are passed to us in the form of raw
* parsetrees; we need to transform them to executable expression trees
diff --git a/src/backend/parser/parse_utilcmd.c
b/src/backend/parser/parse_utilcmd.c
index 1c25fe74c9..b691a80805 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -692,12 +692,6 @@ transformColumnDefinition(CreateStmtContext *cxt,
ColumnDef *column)
errmsg("primary key
constraints are not supported on foreign tables"),
parser_errposition(cxt->pstate,
constraint->location)));
- if (cxt->ispartitioned)
- ereport(ERROR,
-
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("primary key
constraints are not supported on partitioned tables"),
-
parser_errposition(cxt->pstate,
-
constraint->location)));
/* FALL THRU */
case CONSTR_UNIQUE:
@@ -707,12 +701,6 @@ transformColumnDefinition(CreateStmtContext *cxt,
ColumnDef *column)
errmsg("unique
constraints are not supported on foreign tables"),
parser_errposition(cxt->pstate,
constraint->location)));
- if (cxt->ispartitioned)
- ereport(ERROR,
-
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("unique
constraints are not supported on partitioned tables"),
-
parser_errposition(cxt->pstate,
-
constraint->location)));
if (constraint->keys == NIL)
constraint->keys =
list_make1(makeString(column->colname));
cxt->ixconstraints =
lappend(cxt->ixconstraints, constraint);
@@ -809,12 +797,6 @@ transformTableConstraint(CreateStmtContext *cxt,
Constraint *constraint)
errmsg("primary key
constraints are not supported on foreign tables"),
parser_errposition(cxt->pstate,
constraint->location)));
- if (cxt->ispartitioned)
- ereport(ERROR,
-
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("primary key
constraints are not supported on partitioned tables"),
- parser_errposition(cxt->pstate,
-
constraint->location)));
cxt->ixconstraints = lappend(cxt->ixconstraints,
constraint);
break;
@@ -825,12 +807,6 @@ transformTableConstraint(CreateStmtContext *cxt,
Constraint *constraint)
errmsg("unique constraints are
not supported on foreign tables"),
parser_errposition(cxt->pstate,
constraint->location)));
- if (cxt->ispartitioned)
- ereport(ERROR,
-
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("unique constraints are
not supported on partitioned tables"),
- parser_errposition(cxt->pstate,
-
constraint->location)));
cxt->ixconstraints = lappend(cxt->ixconstraints,
constraint);
break;
diff --git a/src/test/regress/expected/alter_table.out
b/src/test/regress/expected/alter_table.out
index 838588757a..f8ef55bb86 100644
--- a/src/test/regress/expected/alter_table.out
+++ b/src/test/regress/expected/alter_table.out
@@ -3127,14 +3127,6 @@ CREATE TABLE partitioned (
a int,
b int
) PARTITION BY RANGE (a, (a+b+1));
-ALTER TABLE partitioned ADD UNIQUE (a);
-ERROR: unique constraints are not supported on partitioned tables
-LINE 1: ALTER TABLE partitioned ADD UNIQUE (a);
- ^
-ALTER TABLE partitioned ADD PRIMARY KEY (a);
-ERROR: primary key constraints are not supported on partitioned tables
-LINE 1: ALTER TABLE partitioned ADD PRIMARY KEY (a);
- ^
ALTER TABLE partitioned ADD FOREIGN KEY (a) REFERENCES blah;
ERROR: foreign key constraints are not supported on partitioned tables
LINE 1: ALTER TABLE partitioned ADD FOREIGN KEY (a) REFERENCES blah;
diff --git a/src/test/regress/expected/create_table.out
b/src/test/regress/expected/create_table.out
index 60ab28a96a..ed4148f94c 100644
--- a/src/test/regress/expected/create_table.out
+++ b/src/test/regress/expected/create_table.out
@@ -276,12 +276,6 @@ CREATE TABLE partitioned (
) PARTITION BY LIST (a1, a2); -- fail
ERROR: cannot use "list" partition strategy with more than one column
-- unsupported constraint type for partitioned tables
-CREATE TABLE partitioned (
- a int PRIMARY KEY
-) PARTITION BY RANGE (a);
-ERROR: primary key constraints are not supported on partitioned tables
-LINE 2: a int PRIMARY KEY
- ^
CREATE TABLE pkrel (
a int PRIMARY KEY
);
@@ -293,12 +287,6 @@ LINE 2: a int REFERENCES pkrel(a)
^
DROP TABLE pkrel;
CREATE TABLE partitioned (
- a int UNIQUE
-) PARTITION BY RANGE (a);
-ERROR: unique constraints are not supported on partitioned tables
-LINE 2: a int UNIQUE
- ^
-CREATE TABLE partitioned (
a int,
EXCLUDE USING gist (a WITH &&)
) PARTITION BY RANGE (a);
diff --git a/src/test/regress/expected/indexing.out
b/src/test/regress/expected/indexing.out
index a0615fa3e6..4269e64937 100644
--- a/src/test/regress/expected/indexing.out
+++ b/src/test/regress/expected/indexing.out
@@ -25,8 +25,6 @@ drop table idxpart;
-- Some unsupported cases
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 unique index on idxpart (a);
-ERROR: cannot create unique index on partitioned table "idxpart"
create index concurrently on idxpart (a);
ERROR: cannot create index on partitioned table "idxpart" concurrently
drop table idxpart;
@@ -202,3 +200,136 @@ select attrelid::regclass, attname, attnum from
pg_attribute
(8 rows)
drop table idxpart;
+--
+-- Constraint-related indexes
+--
+-- Verify that it works to add primary key / unique to partitioned tables
+create table idxpart (a int primary key, b int) partition by range (b);
+ERROR: UNIQUE index on table "idxpart" contains column "a" which is not part
of the partition key
+create table idxpart (a int primary key, b int) partition by range (a);
+\d idxpart
+ Table "public.idxpart"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | not null |
+ b | integer | | |
+Partition key: RANGE (a)
+Indexes:
+ "idxpart_pkey" PRIMARY KEY, btree (a) INVALID
+
+drop table idxpart;
+create table idxpart (a int unique, b int) partition by range (a);
+\d idxpart
+ Table "public.idxpart"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | |
+ b | integer | | |
+Partition key: RANGE (a)
+Indexes:
+ "idxpart_a_key" UNIQUE CONSTRAINT, btree (a) INVALID
+
+drop table idxpart;
+-- but not other types of index-based constraints
+create table idxpart (a int, exclude (a with = )) partition by range (a);
+ERROR: exclusion constraints are not supported on partitioned tables
+LINE 1: create table idxpart (a int, exclude (a with = )) partition ...
+ ^
+-- It works to add primary keys after the partitioned table is created
+create table idxpart (a int, b int) partition by range (a);
+alter table idxpart add primary key (a);
+\d idxpart
+ Table "public.idxpart"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | not null |
+ b | integer | | |
+Partition key: RANGE (a)
+Indexes:
+ "idxpart_pkey" PRIMARY KEY, btree (a) INVALID
+
+drop table idxpart;
+-- It works to add unique constraints after the partitioned table is created
+create table idxpart (a int, b int) partition by range (a);
+alter table idxpart add unique (a);
+\d idxpart
+ Table "public.idxpart"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | |
+ b | integer | | |
+Partition key: RANGE (a)
+Indexes:
+ "idxpart_a_key" UNIQUE CONSTRAINT, btree (a) INVALID
+
+drop table idxpart;
+-- Exclusion constraints cannot be added
+create table idxpart (a int, b int) partition by range (a);
+alter table idxpart add exclude (a with =);
+ERROR: exclusion constraints are not supported on partitioned tables
+LINE 1: alter table idxpart add exclude (a with =);
+ ^
+drop table idxpart;
+-- It is an error to add a constraint to columns that are not in the partition
+-- key.
+create table idxpart (a int, b int, primary key (a, b)) partition by range (a);
+ERROR: UNIQUE index on table "idxpart" contains column "b" which is not part
of the partition key
+create table idxpart (a int, b int, primary key (a, b)) partition by range (b);
+ERROR: UNIQUE index on table "idxpart" contains column "a" which is not part
of the partition key
+create table idxpart (a int, b int, unique (a, b)) partition by range (a);
+ERROR: UNIQUE index on table "idxpart" contains column "b" which is not part
of the partition key
+create table idxpart (a int, b int, unique (a, b)) partition by range (b);
+ERROR: UNIQUE index on table "idxpart" contains column "a" which is not part
of the partition key
+-- but using a partial set of columns is okay
+create table idxpart (a int, b int, c int primary key) partition by range (b);
+ERROR: UNIQUE index on table "idxpart" contains column "c" which is not part
of the partition key
+drop table idxpart;
+ERROR: table "idxpart" does not exist
+create table idxpart (a int, b int, primary key (a)) partition by range (a, b);
+drop table idxpart;
+create table idxpart (a int, b int, primary key (b)) partition by range (a, b);
+drop table idxpart;
+create table idxpart (a int, b int, c int unique) partition by range (b);
+ERROR: UNIQUE index on table "idxpart" contains column "c" which is not part
of the partition key
+drop table idxpart;
+ERROR: table "idxpart" does not exist
+create table idxpart (a int, b int, unique (a)) partition by range (a, b);
+drop table idxpart;
+create table idxpart (a int, b int, unique (b)) partition by range (a, b);
+drop table idxpart;
+-- When (sub)partitions are created, they also contain the constraint
+create table idxpart (a int, b int, primary key (a, b)) partition by range (a,
b);
+create table idxpart1 partition of idxpart for values from (1, 1) to (10, 10);
+create table idxpart2 partition of idxpart for values from (10, 10) to (20, 20)
+ partition by range (b);
+create table idxpart21 partition of idxpart2 for values from (10) to (15);
+create table idxpart22 partition of idxpart2 for values from (15) to (20);
+create table idxpart3 (b int not null, a int not null);
+alter table idxpart attach partition idxpart3 for values from (20, 20) to (30,
30);
+select conname, contype, conrelid::regclass, conindid::regclass, conkey
+ from pg_constraint where conrelid::regclass::text like 'idxpart%'
+ order by conname;
+ conname | contype | conrelid | conindid | conkey
+----------------+---------+-----------+----------------+--------
+ idxpart1_pkey | p | idxpart1 | idxpart1_pkey | {1,2}
+ idxpart21_pkey | p | idxpart21 | idxpart21_pkey | {1,2}
+ idxpart22_pkey | p | idxpart22 | idxpart22_pkey | {1,2}
+ idxpart2_pkey | p | idxpart2 | idxpart2_pkey | {1,2}
+ idxpart3_pkey | p | idxpart3 | idxpart3_pkey | {2,1}
+ idxpart_pkey | p | idxpart | idxpart_pkey | {1,2}
+(6 rows)
+
+drop table idxpart;
+create table idxpart (a int primary key, b int) partition by range (a);
+create table idxpart1 partition of idxpart for values from (1) to (10);
+\d idxpart1
+ Table "public.idxpart1"
+ Column | Type | Collation | Nullable | Default
+--------+---------+-----------+----------+---------
+ a | integer | | not null |
+ b | integer | | |
+Partition of: idxpart FOR VALUES FROM (1) TO (10)
+Indexes:
+ "idxpart1_pkey" PRIMARY KEY, btree (a)
+
+drop table idxpart;
diff --git a/src/test/regress/sql/alter_table.sql
b/src/test/regress/sql/alter_table.sql
index 2ef9541a8c..6c33daa922 100644
--- a/src/test/regress/sql/alter_table.sql
+++ b/src/test/regress/sql/alter_table.sql
@@ -1972,8 +1972,6 @@ CREATE TABLE partitioned (
a int,
b int
) PARTITION BY RANGE (a, (a+b+1));
-ALTER TABLE partitioned ADD UNIQUE (a);
-ALTER TABLE partitioned ADD PRIMARY KEY (a);
ALTER TABLE partitioned ADD FOREIGN KEY (a) REFERENCES blah;
ALTER TABLE partitioned ADD EXCLUDE USING gist (a WITH &&);
diff --git a/src/test/regress/sql/create_table.sql
b/src/test/regress/sql/create_table.sql
index df6a6d7326..a1d1368d3b 100644
--- a/src/test/regress/sql/create_table.sql
+++ b/src/test/regress/sql/create_table.sql
@@ -294,10 +294,6 @@ CREATE TABLE partitioned (
) PARTITION BY LIST (a1, a2); -- fail
-- unsupported constraint type for partitioned tables
-CREATE TABLE partitioned (
- a int PRIMARY KEY
-) PARTITION BY RANGE (a);
-
CREATE TABLE pkrel (
a int PRIMARY KEY
);
@@ -307,10 +303,6 @@ CREATE TABLE partitioned (
DROP TABLE pkrel;
CREATE TABLE partitioned (
- a int UNIQUE
-) PARTITION BY RANGE (a);
-
-CREATE TABLE partitioned (
a int,
EXCLUDE USING gist (a WITH &&)
) PARTITION BY RANGE (a);
diff --git a/src/test/regress/sql/indexing.sql
b/src/test/regress/sql/indexing.sql
index 944b850099..face50022c 100644
--- a/src/test/regress/sql/indexing.sql
+++ b/src/test/regress/sql/indexing.sql
@@ -14,7 +14,6 @@ drop table idxpart;
-- Some unsupported cases
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 unique index on idxpart (a);
create index concurrently on idxpart (a);
drop table idxpart;
@@ -79,3 +78,75 @@ select attrelid::regclass, attname, attnum from pg_attribute
where attrelid in ('idxpart'::regclass, 'idxpart1'::regclass) and attnum > 0
order by attrelid::regclass, attnum;
drop table idxpart;
+
+
+--
+-- Constraint-related indexes
+--
+
+-- Verify that it works to add primary key / unique to partitioned tables
+create table idxpart (a int primary key, b int) partition by range (b);
+create table idxpart (a int primary key, b int) partition by range (a);
+\d idxpart
+drop table idxpart;
+create table idxpart (a int unique, b int) partition by range (a);
+\d idxpart
+drop table idxpart;
+-- but not other types of index-based constraints
+create table idxpart (a int, exclude (a with = )) partition by range (a);
+
+-- It works to add primary keys after the partitioned table is created
+create table idxpart (a int, b int) partition by range (a);
+alter table idxpart add primary key (a);
+\d idxpart
+drop table idxpart;
+
+-- It works to add unique constraints after the partitioned table is created
+create table idxpart (a int, b int) partition by range (a);
+alter table idxpart add unique (a);
+\d idxpart
+drop table idxpart;
+
+-- Exclusion constraints cannot be added
+create table idxpart (a int, b int) partition by range (a);
+alter table idxpart add exclude (a with =);
+drop table idxpart;
+
+-- It is an error to add a constraint to columns that are not in the partition
+-- key.
+create table idxpart (a int, b int, primary key (a, b)) partition by range (a);
+create table idxpart (a int, b int, primary key (a, b)) partition by range (b);
+create table idxpart (a int, b int, unique (a, b)) partition by range (a);
+create table idxpart (a int, b int, unique (a, b)) partition by range (b);
+-- but using a partial set of columns is okay
+create table idxpart (a int, b int, c int primary key) partition by range (b);
+drop table idxpart;
+create table idxpart (a int, b int, primary key (a)) partition by range (a, b);
+drop table idxpart;
+create table idxpart (a int, b int, primary key (b)) partition by range (a, b);
+drop table idxpart;
+create table idxpart (a int, b int, c int unique) partition by range (b);
+drop table idxpart;
+create table idxpart (a int, b int, unique (a)) partition by range (a, b);
+drop table idxpart;
+create table idxpart (a int, b int, unique (b)) partition by range (a, b);
+drop table idxpart;
+
+-- When (sub)partitions are created, they also contain the constraint
+create table idxpart (a int, b int, primary key (a, b)) partition by range (a,
b);
+create table idxpart1 partition of idxpart for values from (1, 1) to (10, 10);
+create table idxpart2 partition of idxpart for values from (10, 10) to (20, 20)
+ partition by range (b);
+create table idxpart21 partition of idxpart2 for values from (10) to (15);
+create table idxpart22 partition of idxpart2 for values from (15) to (20);
+create table idxpart3 (b int not null, a int not null);
+alter table idxpart attach partition idxpart3 for values from (20, 20) to (30,
30);
+select conname, contype, conrelid::regclass, conindid::regclass, conkey
+ from pg_constraint where conrelid::regclass::text like 'idxpart%'
+ order by conname;
+drop table idxpart;
+
+create table idxpart (a int primary key, b int) partition by range (a);
+create table idxpart1 partition of idxpart for values from (1) to (10);
+\d idxpart1
+drop table idxpart;
--
2.11.0
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
