aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/backend/catalog/heap.c4
-rw-r--r--src/backend/catalog/partition.c4
-rw-r--r--src/backend/commands/copy.c72
-rw-r--r--src/backend/commands/tablecmds.c238
-rw-r--r--src/backend/executor/nodeModifyTable.c22
-rw-r--r--src/include/catalog/pg_partitioned_table.h32
6 files changed, 187 insertions, 185 deletions
diff --git a/src/backend/catalog/heap.c b/src/backend/catalog/heap.c
index 5ffea748554..c09c9f28a73 100644
--- a/src/backend/catalog/heap.c
+++ b/src/backend/catalog/heap.c
@@ -1887,6 +1887,10 @@ heap_drop_with_catalog(Oid relid)
if (parent)
{
+ /*
+ * Invalidate the parent's relcache so that the partition is no longer
+ * included in its partition descriptor.
+ */
CacheInvalidateRelcache(parent);
heap_close(parent, NoLock); /* keep the lock */
}
diff --git a/src/backend/catalog/partition.c b/src/backend/catalog/partition.c
index 219d380cde5..63d9b13db44 100644
--- a/src/backend/catalog/partition.c
+++ b/src/backend/catalog/partition.c
@@ -1492,7 +1492,7 @@ generate_partition_qual(Relation rel, bool recurse)
* Construct values[] and isnull[] arrays for the partition key
* of a tuple.
*
- * pkinfo partition key execution info
+ * pd Partition dispatch object of the partitioned table
* slot Heap tuple from which to extract partition key
* estate executor state for evaluating any partition key
* expressions (must be non-NULL)
@@ -1565,7 +1565,7 @@ FormPartitionKeyDatum(PartitionDispatch pd,
* the latter case.
*/
int
-get_partition_for_tuple(PartitionDispatch * pd,
+get_partition_for_tuple(PartitionDispatch *pd,
TupleTableSlot *slot,
EState *estate,
Oid *failed_at)
diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 270be0af18e..7a8da338f07 100644
--- a/src/backend/commands/copy.c
+++ b/src/backend/commands/copy.c
@@ -161,11 +161,11 @@ typedef struct CopyStateData
ExprState **defexprs; /* array of default att expressions */
bool volatile_defexprs; /* is any of defexprs volatile? */
List *range_table;
- PartitionDispatch *partition_dispatch_info;
- int num_dispatch;
- int num_partitions;
- ResultRelInfo *partitions;
- TupleConversionMap **partition_tupconv_maps;
+ PartitionDispatch *partition_dispatch_info;
+ int num_dispatch;
+ int num_partitions;
+ ResultRelInfo *partitions;
+ TupleConversionMap **partition_tupconv_maps;
/*
* These variables are used to reduce overhead in textual COPY FROM.
@@ -1403,31 +1403,28 @@ BeginCopy(ParseState *pstate,
errmsg("table \"%s\" does not have OIDs",
RelationGetRelationName(cstate->rel))));
- /*
- * Initialize state for CopyFrom tuple routing. Watch out for
- * any foreign partitions.
- */
+ /* Initialize state for CopyFrom tuple routing. */
if (is_from && rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
{
- PartitionDispatch *pd;
- List *leaf_parts;
- ListCell *cell;
- int i,
- num_parted,
- num_leaf_parts;
- ResultRelInfo *leaf_part_rri;
+ List *leaf_parts;
+ ListCell *cell;
+ int i,
+ num_parted;
+ ResultRelInfo *leaf_part_rri;
/* Get the tuple-routing information and lock partitions */
- pd = RelationGetPartitionDispatchInfo(rel, RowExclusiveLock,
- &num_parted, &leaf_parts);
- num_leaf_parts = list_length(leaf_parts);
- cstate->partition_dispatch_info = pd;
+ cstate->partition_dispatch_info =
+ RelationGetPartitionDispatchInfo(rel, RowExclusiveLock,
+ &num_parted,
+ &leaf_parts);
cstate->num_dispatch = num_parted;
- cstate->num_partitions = num_leaf_parts;
- cstate->partitions = (ResultRelInfo *) palloc(num_leaf_parts *
- sizeof(ResultRelInfo));
+ cstate->num_partitions = list_length(leaf_parts);
+ cstate->partitions = (ResultRelInfo *)
+ palloc(cstate->num_partitions *
+ sizeof(ResultRelInfo));
cstate->partition_tupconv_maps = (TupleConversionMap **)
- palloc0(num_leaf_parts * sizeof(TupleConversionMap *));
+ palloc0(cstate->num_partitions *
+ sizeof(TupleConversionMap *));
leaf_part_rri = cstate->partitions;
i = 0;
@@ -1438,8 +1435,8 @@ BeginCopy(ParseState *pstate,
/*
* We locked all the partitions above including the leaf
* partitions. Note that each of the relations in
- * cstate->partitions will be closed by CopyFrom() after
- * it's finished with its processing.
+ * cstate->partitions will be closed by CopyFrom() after it's
+ * finished with its processing.
*/
partrel = heap_open(lfirst_oid(cell), NoLock);
@@ -1451,8 +1448,9 @@ BeginCopy(ParseState *pstate,
InitResultRelInfo(leaf_part_rri,
partrel,
- 1, /* dummy */
- false, /* no partition constraint check */
+ 1, /* dummy */
+ false, /* no partition constraint
+ * check */
0);
/* Open partition indices */
@@ -1460,9 +1458,9 @@ BeginCopy(ParseState *pstate,
if (!equalTupleDescs(tupDesc, RelationGetDescr(partrel)))
cstate->partition_tupconv_maps[i] =
- convert_tuples_by_name(tupDesc,
- RelationGetDescr(partrel),
- gettext_noop("could not convert row type"));
+ convert_tuples_by_name(tupDesc,
+ RelationGetDescr(partrel),
+ gettext_noop("could not convert row type"));
leaf_part_rri++;
i++;
}
@@ -2486,8 +2484,8 @@ CopyFrom(CopyState cstate)
* BEFORE/INSTEAD OF triggers, or we need to evaluate volatile default
* expressions. Such triggers or expressions might query the table we're
* inserting to, and act differently if the tuples that have already been
- * processed and prepared for insertion are not there. We also can't
- * do it if the table is partitioned.
+ * processed and prepared for insertion are not there. We also can't do
+ * it if the table is partitioned.
*/
if ((resultRelInfo->ri_TrigDesc != NULL &&
(resultRelInfo->ri_TrigDesc->trig_insert_before_row ||
@@ -2572,7 +2570,7 @@ CopyFrom(CopyState cstate)
/* Determine the partition to heap_insert the tuple into */
if (cstate->partition_dispatch_info)
{
- int leaf_part_index;
+ int leaf_part_index;
TupleConversionMap *map;
/*
@@ -2584,7 +2582,7 @@ CopyFrom(CopyState cstate)
* partition, respectively.
*/
leaf_part_index = ExecFindPartition(resultRelInfo,
- cstate->partition_dispatch_info,
+ cstate->partition_dispatch_info,
slot,
estate);
Assert(leaf_part_index >= 0 &&
@@ -2601,7 +2599,7 @@ CopyFrom(CopyState cstate)
if (resultRelInfo->ri_FdwRoutine)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("cannot route inserted tuples to a foreign table")));
+ errmsg("cannot route inserted tuples to a foreign table")));
/*
* For ExecInsertIndexTuples() to work on the partition's indexes
@@ -2752,7 +2750,7 @@ CopyFrom(CopyState cstate)
/* Close all the partitioned tables, leaf partitions, and their indices */
if (cstate->partition_dispatch_info)
{
- int i;
+ int i;
/*
* Remember cstate->partition_dispatch_info[0] corresponds to the root
diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c
index 5856e729180..7a574dc50da 100644
--- a/src/backend/commands/tablecmds.c
+++ b/src/backend/commands/tablecmds.c
@@ -166,7 +166,7 @@ typedef struct AlteredTableInfo
Oid newTableSpace; /* new tablespace; 0 means no change */
bool chgPersistence; /* T if SET LOGGED/UNLOGGED is used */
char newrelpersistence; /* if above is true */
- List *partition_constraint; /* for attach partition validation */
+ List *partition_constraint; /* for attach partition validation */
/* Objects to rebuild after completing ALTER TYPE operations */
List *changedConstraintOids; /* OIDs of constraints to rebuild */
List *changedConstraintDefs; /* string definitions of same */
@@ -454,7 +454,7 @@ static void ComputePartitionAttrs(Relation rel, List *partParams, AttrNumber *pa
static void CreateInheritance(Relation child_rel, Relation parent_rel);
static void RemoveInheritance(Relation child_rel, Relation parent_rel);
static ObjectAddress ATExecAttachPartition(List **wqueue, Relation rel,
- PartitionCmd *cmd);
+ PartitionCmd *cmd);
static ObjectAddress ATExecDetachPartition(Relation rel, RangeVar *name);
@@ -630,7 +630,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
*/
localHasOids = interpretOidsOption(stmt->options,
(relkind == RELKIND_RELATION ||
- relkind == RELKIND_PARTITIONED_TABLE));
+ relkind == RELKIND_PARTITIONED_TABLE));
descriptor->tdhasoid = (localHasOids || parentOidCount > 0);
if (stmt->partbound)
@@ -791,19 +791,19 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
}
/*
- * Process the partitioning specification (if any) and store the
- * partition key information into the catalog.
+ * Process the partitioning specification (if any) and store the partition
+ * key information into the catalog.
*/
if (stmt->partspec)
{
- char strategy;
- int partnatts,
- i;
- AttrNumber partattrs[PARTITION_MAX_KEYS];
- Oid partopclass[PARTITION_MAX_KEYS];
- Oid partcollation[PARTITION_MAX_KEYS];
- List *partexprs = NIL;
- List *cmds = NIL;
+ char strategy;
+ int partnatts,
+ i;
+ AttrNumber partattrs[PARTITION_MAX_KEYS];
+ Oid partopclass[PARTITION_MAX_KEYS];
+ Oid partcollation[PARTITION_MAX_KEYS];
+ List *partexprs = NIL;
+ List *cmds = NIL;
/*
* We need to transform the raw parsetrees corresponding to partition
@@ -827,7 +827,7 @@ DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId,
for (i = 0; i < partnatts; i++)
{
AttrNumber partattno = partattrs[i];
- Form_pg_attribute attform = descriptor->attrs[partattno-1];
+ Form_pg_attribute attform = descriptor->attrs[partattno - 1];
if (partattno != 0 && !attform->attnotnull)
{
@@ -1613,8 +1613,8 @@ MergeAttributes(List *schema, List *supers, char relpersistence,
MaxHeapAttributeNumber)));
/*
- * In case of a partition, there are no new column definitions, only
- * dummy ColumnDefs created for column constraints. We merge these
+ * In case of a partition, there are no new column definitions, only dummy
+ * ColumnDefs created for column constraints. We merge them with the
* constraints inherited from the parent.
*/
if (is_partition)
@@ -1704,9 +1704,9 @@ MergeAttributes(List *schema, List *supers, char relpersistence,
* the parent's relhassubclass field, if its previous children were
* recently dropped.
*
- * If the child table is a partition, then we instead grab an exclusive
- * lock on the parent because its partition descriptor will be changed
- * by addition of the new partition.
+ * If the child table is a partition, then we instead grab an
+ * exclusive lock on the parent because its partition descriptor will
+ * be changed by addition of the new partition.
*/
if (!is_partition)
relation = heap_openrv(parent, ShareUpdateExclusiveLock);
@@ -1714,8 +1714,8 @@ MergeAttributes(List *schema, List *supers, char relpersistence,
relation = heap_openrv(parent, AccessExclusiveLock);
/*
- * We do not allow partitioned tables and partitions to participate
- * in regular inheritance.
+ * We do not allow partitioned tables and partitions to participate in
+ * regular inheritance.
*/
if (relation->rd_rel->relkind == RELKIND_PARTITIONED_TABLE &&
!is_partition)
@@ -1752,7 +1752,7 @@ MergeAttributes(List *schema, List *supers, char relpersistence,
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg(!is_partition
- ? "cannot inherit from temporary relation of another session"
+ ? "cannot inherit from temporary relation of another session"
: "cannot create as partition of temporary relation of another session")));
/*
@@ -2030,8 +2030,8 @@ MergeAttributes(List *schema, List *supers, char relpersistence,
newcollid;
/*
- * Partitions have only one parent, so conflict should never
- * occur
+ * Partitions have only one parent and have no column
+ * definitions of their own, so conflict should never occur.
*/
Assert(!is_partition);
@@ -2118,8 +2118,8 @@ MergeAttributes(List *schema, List *supers, char relpersistence,
/*
* Now that we have the column definition list for a partition, we can
- * check whether the columns referenced in column option specifications
- * actually exist. Also, we merge the options into the corresponding
+ * check whether the columns referenced in the column constraint specs
+ * actually exist. Also, we merge the constraints into the corresponding
* column definitions.
*/
if (is_partition && list_length(saved_schema) > 0)
@@ -2139,14 +2139,14 @@ MergeAttributes(List *schema, List *supers, char relpersistence,
*/
if (coldef->typeName == NULL)
ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_COLUMN),
- errmsg("column \"%s\" does not exist",
- coldef->colname)));
+ (errcode(ERRCODE_UNDEFINED_COLUMN),
+ errmsg("column \"%s\" does not exist",
+ coldef->colname)));
while (rest != NULL)
{
ColumnDef *restdef = lfirst(rest);
- ListCell *next = lnext(rest); /* need to save it in case
- * we delete it */
+ ListCell *next = lnext(rest); /* need to save it in case we
+ * delete it */
if (strcmp(coldef->colname, restdef->colname) == 0)
{
@@ -3735,7 +3735,7 @@ ATRewriteCatalogs(List **wqueue, LOCKMODE lockmode)
*/
if (((tab->relkind == RELKIND_RELATION ||
tab->relkind == RELKIND_PARTITIONED_TABLE) &&
- tab->partition_constraint == NIL) ||
+ tab->partition_constraint == NIL) ||
tab->relkind == RELKIND_MATVIEW)
AlterTableCreateToastTable(tab->relid, (Datum) 0, lockmode);
}
@@ -4326,8 +4326,8 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
{
needscan = true;
partqualstate = (List *)
- ExecPrepareExpr((Expr *) tab->partition_constraint,
- estate);
+ ExecPrepareExpr((Expr *) tab->partition_constraint,
+ estate);
}
foreach(l, tab->newvals)
@@ -4522,7 +4522,7 @@ ATRewriteTable(AlteredTableInfo *tab, Oid OIDNewHeap, LOCKMODE lockmode)
if (partqualstate && !ExecQual(partqualstate, econtext, true))
ereport(ERROR,
(errcode(ERRCODE_CHECK_VIOLATION),
- errmsg("partition constraint is violated by some row")));
+ errmsg("partition constraint is violated by some row")));
/* Write the tuple out to the new relation */
if (newrel)
@@ -5596,20 +5596,20 @@ ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode)
if (tupDesc->attrs[parent_attnum - 1]->attnotnull)
ereport(ERROR,
(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
- errmsg("column \"%s\" is marked NOT NULL in parent table",
- colName)));
+ errmsg("column \"%s\" is marked NOT NULL in parent table",
+ colName)));
heap_close(parent, AccessShareLock);
}
/*
- * If the table is a range partitioned table, check that the column
- * is not in the partition key.
+ * If the table is a range partitioned table, check that the column is not
+ * in the partition key.
*/
if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
{
- PartitionKey key = RelationGetPartitionKey(rel);
- int partnatts = get_partition_natts(key),
- i;
+ PartitionKey key = RelationGetPartitionKey(rel);
+ int partnatts = get_partition_natts(key),
+ i;
for (i = 0; i < partnatts; i++)
{
@@ -6093,11 +6093,11 @@ ATPrepDropColumn(List **wqueue, Relation rel, bool recurse, bool recursing,
static bool
is_partition_attr(Relation rel, AttrNumber attnum, bool *used_in_expr)
{
- PartitionKey key;
- int partnatts;
- List *partexprs;
- ListCell *partexprs_item;
- int i;
+ PartitionKey key;
+ int partnatts;
+ List *partexprs;
+ ListCell *partexprs_item;
+ int i;
if (rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE)
return false;
@@ -8258,9 +8258,9 @@ ATExecDropConstraint(Relation rel, const char *constrName,
}
/*
- * In case of a partitioned table, the constraint must be dropped from
- * the partitions too. There is no such thing as NO INHERIT constraints
- * in case of partitioned tables.
+ * In case of a partitioned table, the constraint must be dropped from the
+ * partitions too. There is no such thing as NO INHERIT constraints in
+ * case of partitioned tables.
*/
if (!recurse && rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
ereport(ERROR,
@@ -8432,7 +8432,7 @@ ATPrepAlterColumnType(List **wqueue,
if (!is_expr)
ereport(ERROR,
(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
- errmsg("cannot alter type of column named in partition key")));
+ errmsg("cannot alter type of column named in partition key")));
else
ereport(ERROR,
(errcode(ERRCODE_INVALID_TABLE_DEFINITION),
@@ -10704,7 +10704,8 @@ CreateInheritance(Relation child_rel, Relation parent_rel)
/*
* Check for duplicates in the list of parents, and determine the highest
* inhseqno already present; we'll use the next one for the new parent.
- * Also, if proposed child is a partition, it cannot already be inheriting.
+ * Also, if proposed child is a partition, it cannot already be
+ * inheriting.
*
* Note: we do not reject the case where the child already inherits from
* the parent indirectly; CREATE TABLE doesn't reject comparable cases.
@@ -11054,8 +11055,8 @@ MergeConstraintsIntoExisting(Relation child_rel, Relation parent_rel)
static ObjectAddress
ATExecDropInherit(Relation rel, RangeVar *parent, LOCKMODE lockmode)
{
- ObjectAddress address;
- Relation parent_rel;
+ ObjectAddress address;
+ Relation parent_rel;
if (rel->rd_rel->relispartition)
ereport(ERROR,
@@ -11154,15 +11155,15 @@ RemoveInheritance(Relation child_rel, Relation parent_rel)
if (child_is_partition)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_TABLE),
- errmsg("relation \"%s\" is not a partition of relation \"%s\"",
- RelationGetRelationName(child_rel),
- RelationGetRelationName(parent_rel))));
+ errmsg("relation \"%s\" is not a partition of relation \"%s\"",
+ RelationGetRelationName(child_rel),
+ RelationGetRelationName(parent_rel))));
else
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_TABLE),
- errmsg("relation \"%s\" is not a parent of relation \"%s\"",
- RelationGetRelationName(parent_rel),
- RelationGetRelationName(child_rel))));
+ errmsg("relation \"%s\" is not a parent of relation \"%s\"",
+ RelationGetRelationName(parent_rel),
+ RelationGetRelationName(child_rel))));
}
/*
@@ -11283,6 +11284,7 @@ RemoveInheritance(Relation child_rel, Relation parent_rel)
drop_parent_dependency(RelationGetRelid(child_rel),
RelationRelationId,
RelationGetRelid(parent_rel));
+
/*
* Post alter hook of this inherits. Since object_access_hook doesn't take
* multiple object identifiers, we relay oid of parent relation using
@@ -12735,10 +12737,10 @@ RangeVarCallbackForAlterRelation(const RangeVar *rv, Oid relid, Oid oldrelid,
static PartitionSpec *
transformPartitionSpec(Relation rel, PartitionSpec *partspec, char *strategy)
{
- PartitionSpec *newspec;
- ParseState *pstate;
- RangeTblEntry *rte;
- ListCell *l;
+ PartitionSpec *newspec;
+ ParseState *pstate;
+ RangeTblEntry *rte;
+ ListCell *l;
newspec = (PartitionSpec *) makeNode(PartitionSpec);
@@ -12768,16 +12770,16 @@ transformPartitionSpec(Relation rel, PartitionSpec *partspec, char *strategy)
/* take care of any partition expressions */
foreach(l, partspec->partParams)
{
- ListCell *lc;
- PartitionElem *pelem = (PartitionElem *) lfirst(l);
+ ListCell *lc;
+ PartitionElem *pelem = (PartitionElem *) lfirst(l);
/* Check for PARTITION BY ... (foo, foo) */
foreach(lc, newspec->partParams)
{
- PartitionElem *pparam = (PartitionElem *) lfirst(lc);
+ PartitionElem *pparam = (PartitionElem *) lfirst(lc);
if (pelem->name && pparam->name &&
- !strcmp(pelem->name, pparam->name))
+ !strcmp(pelem->name, pparam->name))
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_COLUMN),
errmsg("column \"%s\" appears more than once in partition key",
@@ -12814,29 +12816,29 @@ ComputePartitionAttrs(Relation rel, List *partParams, AttrNumber *partattrs,
attn = 0;
foreach(lc, partParams)
{
- PartitionElem *pelem = (PartitionElem *) lfirst(lc);
- Oid atttype;
- Oid attcollation;
+ PartitionElem *pelem = (PartitionElem *) lfirst(lc);
+ Oid atttype;
+ Oid attcollation;
if (pelem->name != NULL)
{
/* Simple attribute reference */
- HeapTuple atttuple;
+ HeapTuple atttuple;
Form_pg_attribute attform;
atttuple = SearchSysCacheAttName(RelationGetRelid(rel), pelem->name);
if (!HeapTupleIsValid(atttuple))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_COLUMN),
- errmsg("column \"%s\" named in partition key does not exist",
- pelem->name)));
+ errmsg("column \"%s\" named in partition key does not exist",
+ pelem->name)));
attform = (Form_pg_attribute) GETSTRUCT(atttuple);
if (attform->attnum <= 0)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_COLUMN),
- errmsg("cannot use system column \"%s\" in partition key",
- pelem->name)));
+ errmsg("cannot use system column \"%s\" in partition key",
+ pelem->name)));
partattrs[attn] = attform->attnum;
atttype = attform->atttypid;
@@ -12872,9 +12874,9 @@ ComputePartitionAttrs(Relation rel, List *partParams, AttrNumber *partattrs,
}
else
{
- Bitmapset *expr_attrs = NULL;
+ Bitmapset *expr_attrs = NULL;
- partattrs[attn] = 0; /* marks the column as expression */
+ partattrs[attn] = 0; /* marks the column as expression */
*partexprs = lappend(*partexprs, expr);
/*
@@ -12896,8 +12898,8 @@ ComputePartitionAttrs(Relation rel, List *partParams, AttrNumber *partattrs,
errmsg("functions in partition key expression must be marked IMMUTABLE")));
/*
- * While it is not exactly *wrong* for an expression to be
- * a constant value, it seems better to prevent such input.
+ * While it is not exactly *wrong* for an expression to be a
+ * constant value, it seems better to prevent such input.
*/
if (IsA(expr, Const))
ereport(ERROR,
@@ -12905,9 +12907,9 @@ ComputePartitionAttrs(Relation rel, List *partParams, AttrNumber *partattrs,
errmsg("cannot use constant expression as partition key")));
/*
- * transformPartitionSpec() should have already rejected subqueries,
- * aggregates, window functions, and SRFs, based on the EXPR_KIND_
- * for partition expressions.
+ * transformPartitionSpec() should have already rejected
+ * subqueries, aggregates, window functions, and SRFs, based
+ * on the EXPR_KIND_ for partition expressions.
*/
/* Cannot have expressions containing whole-row references */
@@ -12929,8 +12931,8 @@ ComputePartitionAttrs(Relation rel, List *partParams, AttrNumber *partattrs,
/*
* Check we have a collation iff it's a collatable type. The only
* expected failures here are (1) COLLATE applied to a noncollatable
- * type, or (2) partition expression had an unresolved collation.
- * But we might as well code this to be a complete consistency check.
+ * type, or (2) partition expression had an unresolved collation. But
+ * we might as well code this to be a complete consistency check.
*/
if (type_is_collatable(atttype))
{
@@ -12962,8 +12964,8 @@ ComputePartitionAttrs(Relation rel, List *partParams, AttrNumber *partattrs,
if (!OidIsValid(partopclass[attn]))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
- errmsg("data type %s has no default btree operator class",
- format_type_be(atttype)),
+ errmsg("data type %s has no default btree operator class",
+ format_type_be(atttype)),
errhint("You must specify a btree operator class or define a default btree operator class for the data type.")));
}
else
@@ -12984,11 +12986,11 @@ ComputePartitionAttrs(Relation rel, List *partParams, AttrNumber *partattrs,
static ObjectAddress
ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
{
- PartitionKey key = RelationGetPartitionKey(rel);
+ PartitionKey key = RelationGetPartitionKey(rel);
Relation attachRel,
catalog;
List *childrels;
- TupleConstr *attachRel_constr;
+ TupleConstr *attachRel_constr;
List *partConstraint,
*existConstraint;
SysScanDesc scan;
@@ -13053,8 +13055,8 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
heap_close(catalog, AccessShareLock);
/*
- * Prevent circularity by seeing if rel is a partition of attachRel.
- * (In particular, this disallows making a rel a partition of itself.)
+ * Prevent circularity by seeing if rel is a partition of attachRel. (In
+ * particular, this disallows making a rel a partition of itself.)
*/
childrels = find_all_inheritors(RelationGetRelid(attachRel),
AccessShareLock, NULL);
@@ -13079,30 +13081,30 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
!rel->rd_islocaltemp)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("cannot attach as partition of temporary relation of another session")));
+ errmsg("cannot attach as partition of temporary relation of another session")));
/* Ditto for the partition */
if (attachRel->rd_rel->relpersistence == RELPERSISTENCE_TEMP &&
!attachRel->rd_islocaltemp)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("cannot attach temporary relation of another session as partition")));
+ errmsg("cannot attach temporary relation of another session as partition")));
/* If parent has OIDs then child must have OIDs */
if (rel->rd_rel->relhasoids && !attachRel->rd_rel->relhasoids)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("cannot attach table \"%s\" without OIDs as partition of"
- " table \"%s\" with OIDs", RelationGetRelationName(attachRel),
- RelationGetRelationName(rel))));
+ errmsg("cannot attach table \"%s\" without OIDs as partition of"
+ " table \"%s\" with OIDs", RelationGetRelationName(attachRel),
+ RelationGetRelationName(rel))));
/* OTOH, if parent doesn't have them, do not allow in attachRel either */
if (attachRel->rd_rel->relhasoids && !rel->rd_rel->relhasoids)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("cannot attach table \"%s\" with OIDs as partition of table"
- " \"%s\" without OIDs", RelationGetRelationName(attachRel),
- RelationGetRelationName(rel))));
+ errmsg("cannot attach table \"%s\" with OIDs as partition of table"
+ " \"%s\" without OIDs", RelationGetRelationName(attachRel),
+ RelationGetRelationName(rel))));
/* Check if there are any columns in attachRel that aren't in the parent */
tupleDesc = RelationGetDescr(attachRel);
@@ -13132,8 +13134,8 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
/*
* Check that the new partition's bound is valid and does not overlap any
- * of existing partitions of the parent - note that it does not return
- * on error.
+ * of existing partitions of the parent - note that it does not return on
+ * error.
*/
check_new_partition_bound(RelationGetRelationName(attachRel), rel,
cmd->bound);
@@ -13155,8 +13157,8 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
partConstraint = list_make1(make_ands_explicit(partConstraint));
/*
- * Check if we can do away with having to scan the table being attached
- * to validate the partition constraint, by *proving* that the existing
+ * Check if we can do away with having to scan the table being attached to
+ * validate the partition constraint, by *proving* that the existing
* constraints of the table *imply* the partition predicate. We include
* the table's check constraints and NOT NULL constraints in the list of
* clauses passed to predicate_implied_by().
@@ -13243,14 +13245,14 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
skip_validate = true;
/*
- * We choose to err on the safer side, ie, give up on skipping the
- * the validation scan, if the partition key column doesn't have
- * the NOT NULL constraint and the table is to become a list partition
- * that does not accept nulls. In this case, the partition predicate
+ * We choose to err on the safer side, ie, give up on skipping the the
+ * validation scan, if the partition key column doesn't have the NOT
+ * NULL constraint and the table is to become a list partition that
+ * does not accept nulls. In this case, the partition predicate
* (partConstraint) does include an 'key IS NOT NULL' expression,
- * however, because of the way predicate_implied_by_simple_clause()
- * is designed to handle IS NOT NULL predicates in the absence of a
- * IS NOT NULL clause, we cannot rely on just the above proof.
+ * however, because of the way predicate_implied_by_simple_clause() is
+ * designed to handle IS NOT NULL predicates in the absence of a IS
+ * NOT NULL clause, we cannot rely on just the above proof.
*
* That is not an issue in case of a range partition, because if there
* were no NOT NULL constraint defined on the key columns, an error
@@ -13269,7 +13271,7 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
*/
foreach(lc, part_constr)
{
- Node *expr = lfirst(lc);
+ Node *expr = lfirst(lc);
if (IsA(expr, NullTest) &&
((NullTest *) expr)->nulltesttype == IS_NOT_NULL)
@@ -13299,8 +13301,8 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
/*
* Set up to have the table to be scanned to validate the partition
- * constraint (see partConstraint above). If it's a partitioned table,
- * we instead schdule its leaf partitions to be scanned instead.
+ * constraint (see partConstraint above). If it's a partitioned table, we
+ * instead schdule its leaf partitions to be scanned instead.
*/
if (!skip_validate)
{
@@ -13310,7 +13312,7 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
/* Take an exclusive lock on the partitions to be checked */
if (attachRel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
all_parts = find_all_inheritors(RelationGetRelid(attachRel),
- AccessExclusiveLock, NULL);
+ AccessExclusiveLock, NULL);
else
all_parts = list_make1_oid(RelationGetRelid(attachRel));
@@ -13351,8 +13353,8 @@ ATExecAttachPartition(List **wqueue, Relation rel, PartitionCmd *cmd)
}
/*
- * Invalidate the relcache so that the new partition is now included
- * in rel's partition descriptor.
+ * Invalidate the parent's relcache so that the new partition is now
+ * included its partition descriptor.
*/
CacheInvalidateRelcache(rel);
@@ -13414,8 +13416,8 @@ ATExecDetachPartition(Relation rel, RangeVar *name)
heap_close(classRel, RowExclusiveLock);
/*
- * Invalidate the relcache so that the partition is no longer included
- * in our partition descriptor.
+ * Invalidate the parent's relcache so that the partition is no longer
+ * included in its partition descriptor.
*/
CacheInvalidateRelcache(rel);
diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c
index c0b58d1841c..ec440b353d0 100644
--- a/src/backend/executor/nodeModifyTable.c
+++ b/src/backend/executor/nodeModifyTable.c
@@ -1718,26 +1718,26 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags)
if (operation == CMD_INSERT &&
rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
{
- PartitionDispatch *pd;
int i,
j,
- num_parted,
- num_leaf_parts;
+ num_parted;
List *leaf_parts;
ListCell *cell;
ResultRelInfo *leaf_part_rri;
- /* Form the partition node tree and lock partitions */
- pd = RelationGetPartitionDispatchInfo(rel, RowExclusiveLock,
- &num_parted, &leaf_parts);
- mtstate->mt_partition_dispatch_info = pd;
+ /* Get the tuple-routing information and lock partitions */
+ mtstate->mt_partition_dispatch_info =
+ RelationGetPartitionDispatchInfo(rel, RowExclusiveLock,
+ &num_parted,
+ &leaf_parts);
mtstate->mt_num_dispatch = num_parted;
- num_leaf_parts = list_length(leaf_parts);
- mtstate->mt_num_partitions = num_leaf_parts;
+ mtstate->mt_num_partitions = list_length(leaf_parts);
mtstate->mt_partitions = (ResultRelInfo *)
- palloc0(num_leaf_parts * sizeof(ResultRelInfo));
+ palloc0(mtstate->mt_num_partitions *
+ sizeof(ResultRelInfo));
mtstate->mt_partition_tupconv_maps = (TupleConversionMap **)
- palloc0(num_leaf_parts * sizeof(TupleConversionMap *));
+ palloc0(mtstate->mt_num_partitions *
+ sizeof(TupleConversionMap *));
leaf_part_rri = mtstate->mt_partitions;
i = j = 0;
diff --git a/src/include/catalog/pg_partitioned_table.h b/src/include/catalog/pg_partitioned_table.h
index cec54ae62e5..c986428a65a 100644
--- a/src/include/catalog/pg_partitioned_table.h
+++ b/src/include/catalog/pg_partitioned_table.h
@@ -7,7 +7,7 @@
*
* Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group
*
- * $PostgreSQL: pgsql/src/include/catalog/pg_partitioned_table.h $
+ * src/include/catalog/pg_partitioned_table.h
*
* NOTES
* the genbki.sh script reads this file and generates .bki
@@ -29,9 +29,9 @@
CATALOG(pg_partitioned_table,3350) BKI_WITHOUT_OIDS
{
- Oid partrelid; /* partitioned table oid */
- char partstrat; /* partitioning strategy */
- int16 partnatts; /* number of partition key columns */
+ Oid partrelid; /* partitioned table oid */
+ char partstrat; /* partitioning strategy */
+ int16 partnatts; /* number of partition key columns */
/*
* variable-length fields start here, but we allow direct access to
@@ -39,29 +39,27 @@ CATALOG(pg_partitioned_table,3350) BKI_WITHOUT_OIDS
* field of a heap tuple can be reliably accessed using its C struct
* offset, as previous fields are all non-nullable fixed-length fields.
*/
- int2vector partattrs; /* each member of the array is the
- * attribute number of a partition key
- * column, or 0 if the column is actually
- * an expression */
+ int2vector partattrs; /* each member of the array is the attribute
+ * number of a partition key column, or 0 if
+ * the column is actually an expression */
#ifdef CATALOG_VARLEN
- oidvector partclass; /* operator class to compare keys */
- oidvector partcollation; /* user-specified collation for keys */
- pg_node_tree partexprs; /* list of expressions in the partitioning
- * key; one item for each zero entry in
- * partattrs[] */
+ oidvector partclass; /* operator class to compare keys */
+ oidvector partcollation; /* user-specified collation for keys */
+ pg_node_tree partexprs; /* list of expressions in the partition key;
+ * one item for each zero entry in partattrs[] */
#endif
} FormData_pg_partitioned_table;
/* ----------------
- * Form_pg_partitioned_table corresponds to a pointer to a tuple with
- * the format of pg_partitioned_table relation.
+ * Form_pg_partitioned_table corresponds to a pointer to a tuple with
+ * the format of pg_partitioned_table relation.
* ----------------
*/
typedef FormData_pg_partitioned_table *Form_pg_partitioned_table;
/* ----------------
- * compiler constants for pg_partitioned_table
+ * compiler constants for pg_partitioned_table
* ----------------
*/
#define Natts_pg_partitioned_table 7
@@ -70,7 +68,7 @@ typedef FormData_pg_partitioned_table *Form_pg_partitioned_table;
#define Anum_pg_partitioned_table_partnatts 3
#define Anum_pg_partitioned_table_partattrs 4
#define Anum_pg_partitioned_table_partclass 5
-#define Anum_pg_partitioned_table_partcollation 6
+#define Anum_pg_partitioned_table_partcollation 6
#define Anum_pg_partitioned_table_partexprs 7
#endif /* PG_PARTITIONED_TABLE_H */
generated by cgit v1.2.3 (git 2.25.1) at 2025-05-31 12:16:19 +0000