#include "fmgr.h"
#include "parser/parse_node.h"
#include "partitioning/partdefs.h"

Include dependency graph for partbounds.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	PartitionBoundInfoData

Macros
#define	partition_bound_accepts_nulls(bi) ((bi)->null_index != -1)

#define	partition_bound_has_default(bi) ((bi)->default_index != -1)

Typedefs
typedef struct PartitionBoundInfoData	PartitionBoundInfoData

Functions
int	get_hash_partition_greatest_modulus (PartitionBoundInfo bound)

uint64	compute_partition_hash_value (int partnatts, FmgrInfo partsupfunc, Oid partcollation, Datum values, bool isnull)

List *	get_qual_from_partbound (Relation parent, PartitionBoundSpec *spec)

PartitionBoundInfo	partition_bounds_create (PartitionBoundSpec boundspecs, int nparts, PartitionKey key, int mapping)

bool	partition_bounds_equal (int partnatts, int16 parttyplen, bool parttypbyval, PartitionBoundInfo b1, PartitionBoundInfo b2)

PartitionBoundInfo	partition_bounds_copy (PartitionBoundInfo src, PartitionKey key)

PartitionBoundInfo	partition_bounds_merge (int partnatts, FmgrInfo partsupfunc, Oid partcollation, struct RelOptInfo outer_rel, struct RelOptInfo inner_rel, JoinType jointype, List outer_parts, List inner_parts)

bool	partitions_are_ordered (PartitionBoundInfo boundinfo, Bitmapset *live_parts)

void	check_new_partition_bound (char relname, Relation parent, PartitionBoundSpec spec, ParseState *pstate)

void	check_default_partition_contents (Relation parent, Relation default_rel, PartitionBoundSpec *new_spec)

int32	partition_rbound_datum_cmp (FmgrInfo partsupfunc, Oid partcollation, Datum rb_datums, PartitionRangeDatumKind rb_kind, Datum *tuple_datums, int n_tuple_datums)

int	partition_list_bsearch (FmgrInfo partsupfunc, Oid partcollation, PartitionBoundInfo boundinfo, Datum value, bool *is_equal)

int	partition_range_datum_bsearch (FmgrInfo partsupfunc, Oid partcollation, PartitionBoundInfo boundinfo, int nvalues, Datum values, bool is_equal)

int	partition_hash_bsearch (PartitionBoundInfo boundinfo, int modulus, int remainder)

Macro Definition Documentation

◆ partition_bound_accepts_nulls

#define partition_bound_accepts_nulls ( bi ) ((bi)->null_index != -1)

Definition at line 98 of file partbounds.h.

◆ partition_bound_has_default

#define partition_bound_has_default ( bi ) ((bi)->default_index != -1)

Definition at line 99 of file partbounds.h.

Typedef Documentation

◆ PartitionBoundInfoData

typedef struct PartitionBoundInfoData PartitionBoundInfoData

Function Documentation

◆ check_default_partition_contents()

void check_default_partition_contents	(	Relation	parent,
		Relation	default_rel,
		PartitionBoundSpec *	new_spec
	)

Definition at line 3252 of file partbounds.c.

 {
     List       *new_part_constraints;
     List       *def_part_constraints;
     List       *all_parts;
     ListCell   *lc;
  
     new_part_constraints = (new_spec->strategy == PARTITION_STRATEGY_LIST)
         ? get_qual_for_list(parent, new_spec)
         : get_qual_for_range(parent, new_spec, false);
     def_part_constraints =
         get_proposed_default_constraint(new_part_constraints);
  
     /*
      * Map the Vars in the constraint expression from parent's attnos to
      * default_rel's.
      */
     def_part_constraints =
         map_partition_varattnos(def_part_constraints, 1, default_rel,
                                 parent);
  
     /*
      * If the existing constraints on the default partition imply that it will
      * not contain any row that would belong to the new partition, we can
      * avoid scanning the default partition.
      */
     if (PartConstraintImpliedByRelConstraint(default_rel, def_part_constraints))
     {
         ereport(DEBUG1,
                 (errmsg_internal("updated partition constraint for default partition \"%s\" is implied by existing constraints",
                                  RelationGetRelationName(default_rel))));
         return;
     }
  
     /*
      * Scan the default partition and its subpartitions, and check for rows
      * that do not satisfy the revised partition constraints.
      */
     if (default_rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
         all_parts = find_all_inheritors(RelationGetRelid(default_rel),
                                         AccessExclusiveLock, NULL);
     else
         all_parts = list_make1_oid(RelationGetRelid(default_rel));
  
     foreach(lc, all_parts)
     {
         Oid         part_relid = lfirst_oid(lc);
         Relation    part_rel;
         Expr       *partition_constraint;
         EState     *estate;
         ExprState  *partqualstate = NULL;
         Snapshot    snapshot;
         ExprContext *econtext;
         TableScanDesc scan;
         MemoryContext oldCxt;
         TupleTableSlot *tupslot;
  
         /* Lock already taken above. */
         if (part_relid != RelationGetRelid(default_rel))
         {
             part_rel = table_open(part_relid, NoLock);
  
             /*
              * Map the Vars in the constraint expression from default_rel's
              * the sub-partition's.
              */
             partition_constraint = make_ands_explicit(def_part_constraints);
             partition_constraint = (Expr *)
                 map_partition_varattnos((List *) partition_constraint, 1,
                                         part_rel, default_rel);
  
             /*
              * If the partition constraints on default partition child imply
              * that it will not contain any row that would belong to the new
              * partition, we can avoid scanning the child table.
              */
             if (PartConstraintImpliedByRelConstraint(part_rel,
                                                      def_part_constraints))
             {
                 ereport(DEBUG1,
                         (errmsg_internal("updated partition constraint for default partition \"%s\" is implied by existing constraints",
                                          RelationGetRelationName(part_rel))));
  
                 table_close(part_rel, NoLock);
                 continue;
             }
         }
         else
         {
             part_rel = default_rel;
             partition_constraint = make_ands_explicit(def_part_constraints);
         }
  
         /*
          * Only RELKIND_RELATION relations (i.e. leaf partitions) need to be
          * scanned.
          */
         if (part_rel->rd_rel->relkind != RELKIND_RELATION)
         {
             if (part_rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
                 ereport(WARNING,
                         (errcode(ERRCODE_CHECK_VIOLATION),
                          errmsg("skipped scanning foreign table \"%s\" which is a partition of default partition \"%s\"",
                                 RelationGetRelationName(part_rel),
                                 RelationGetRelationName(default_rel))));
  
             if (RelationGetRelid(default_rel) != RelationGetRelid(part_rel))
                 table_close(part_rel, NoLock);
  
             continue;
         }
  
         estate = CreateExecutorState();
  
         /* Build expression execution states for partition check quals */
         partqualstate = ExecPrepareExpr(partition_constraint, estate);
  
         econtext = GetPerTupleExprContext(estate);
         snapshot = RegisterSnapshot(GetLatestSnapshot());
         tupslot = table_slot_create(part_rel, &estate->es_tupleTable);
         scan = table_beginscan(part_rel, snapshot, 0, NULL);
  
         /*
          * Switch to per-tuple memory context and reset it for each tuple
          * produced, so we don't leak memory.
          */
         oldCxt = MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
  
         while (table_scan_getnextslot(scan, ForwardScanDirection, tupslot))
         {
             econtext->ecxt_scantuple = tupslot;
  
             if (!ExecCheck(partqualstate, econtext))
                 ereport(ERROR,
                         (errcode(ERRCODE_CHECK_VIOLATION),
                          errmsg("updated partition constraint for default partition \"%s\" would be violated by some row",
                                 RelationGetRelationName(default_rel)),
                          errtable(default_rel)));
  
             ResetExprContext(econtext);
             CHECK_FOR_INTERRUPTS();
         }
  
         MemoryContextSwitchTo(oldCxt);
         table_endscan(scan);
         UnregisterSnapshot(snapshot);
         ExecDropSingleTupleTableSlot(tupslot);
         FreeExecutorState(estate);
  
         if (RelationGetRelid(default_rel) != RelationGetRelid(part_rel))
             table_close(part_rel, NoLock);  /* keep the lock until commit */
     }
 }

References AccessExclusiveLock, CHECK_FOR_INTERRUPTS, CreateExecutorState(), DEBUG1, ExprContext::ecxt_scantuple, ereport, errcode(), errmsg(), errmsg_internal(), ERROR, errtable(), EState::es_tupleTable, ExecCheck(), ExecDropSingleTupleTableSlot(), ExecPrepareExpr(), find_all_inheritors(), ForwardScanDirection, FreeExecutorState(), get_proposed_default_constraint(), get_qual_for_list(), get_qual_for_range(), GetLatestSnapshot(), GetPerTupleExprContext, GetPerTupleMemoryContext, lfirst_oid, list_make1_oid, make_ands_explicit(), map_partition_varattnos(), MemoryContextSwitchTo(), NoLock, PartConstraintImpliedByRelConstraint(), PARTITION_STRATEGY_LIST, RelationData::rd_rel, RegisterSnapshot(), RelationGetRelationName, RelationGetRelid, ResetExprContext, PartitionBoundSpec::strategy, table_beginscan(), table_close(), table_endscan(), table_open(), table_scan_getnextslot(), table_slot_create(), UnregisterSnapshot(), and WARNING.

Referenced by DefineRelation().

◆ check_new_partition_bound()

void check_new_partition_bound	(	char *	relname,
		Relation	parent,
		PartitionBoundSpec *	spec,
		ParseState *	pstate
	)

Definition at line 2897 of file partbounds.c.

 {
     PartitionKey key = RelationGetPartitionKey(parent);
     PartitionDesc partdesc = RelationGetPartitionDesc(parent, false);
     PartitionBoundInfo boundinfo = partdesc->boundinfo;
     int         with = -1;
     bool        overlap = false;
     int         overlap_location = -1;
  
     if (spec->is_default)
     {
         /*
          * The default partition bound never conflicts with any other
          * partition's; if that's what we're attaching, the only possible
          * problem is that one already exists, so check for that and we're
          * done.
          */
         if (boundinfo == NULL || !partition_bound_has_default(boundinfo))
             return;
  
         /* Default partition already exists, error out. */
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                  errmsg("partition \"%s\" conflicts with existing default partition \"%s\"",
                         relname, get_rel_name(partdesc->oids[boundinfo->default_index])),
                  parser_errposition(pstate, spec->location)));
     }
  
     switch (key->strategy)
     {
         case PARTITION_STRATEGY_HASH:
             {
                 Assert(spec->strategy == PARTITION_STRATEGY_HASH);
                 Assert(spec->remainder >= 0 && spec->remainder < spec->modulus);
  
                 if (partdesc->nparts > 0)
                 {
                     int         greatest_modulus;
                     int         remainder;
                     int         offset;
  
                     /*
                      * Check rule that every modulus must be a factor of the
                      * next larger modulus.  (For example, if you have a bunch
                      * of partitions that all have modulus 5, you can add a
                      * new partition with modulus 10 or a new partition with
                      * modulus 15, but you cannot add both a partition with
                      * modulus 10 and a partition with modulus 15, because 10
                      * is not a factor of 15.)  We need only check the next
                      * smaller and next larger existing moduli, relying on
                      * previous enforcement of this rule to be sure that the
                      * rest are in line.
                      */
  
                     /*
                      * Get the greatest (modulus, remainder) pair contained in
                      * boundinfo->datums that is less than or equal to the
                      * (spec->modulus, spec->remainder) pair.
                      */
                     offset = partition_hash_bsearch(boundinfo,
                                                     spec->modulus,
                                                     spec->remainder);
                     if (offset < 0)
                     {
                         int         next_modulus;
  
                         /*
                          * All existing moduli are greater or equal, so the
                          * new one must be a factor of the smallest one, which
                          * is first in the boundinfo.
                          */
                         next_modulus = DatumGetInt32(boundinfo->datums[0][0]);
                         if (next_modulus % spec->modulus != 0)
                             ereport(ERROR,
                                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                      errmsg("every hash partition modulus must be a factor of the next larger modulus"),
                                      errdetail("The new modulus %d is not a factor of %d, the modulus of existing partition \"%s\".",
                                                spec->modulus, next_modulus,
                                                get_rel_name(partdesc->oids[0]))));
                     }
                     else
                     {
                         int         prev_modulus;
  
                         /*
                          * We found the largest (modulus, remainder) pair less
                          * than or equal to the new one.  That modulus must be
                          * a divisor of, or equal to, the new modulus.
                          */
                         prev_modulus = DatumGetInt32(boundinfo->datums[offset][0]);
  
                         if (spec->modulus % prev_modulus != 0)
                             ereport(ERROR,
                                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                      errmsg("every hash partition modulus must be a factor of the next larger modulus"),
                                      errdetail("The new modulus %d is not divisible by %d, the modulus of existing partition \"%s\".",
                                                spec->modulus,
                                                prev_modulus,
                                                get_rel_name(partdesc->oids[offset]))));
  
                         if (offset + 1 < boundinfo->ndatums)
                         {
                             int         next_modulus;
  
                             /*
                              * Look at the next higher (modulus, remainder)
                              * pair.  That could have the same modulus and a
                              * larger remainder than the new pair, in which
                              * case we're good.  If it has a larger modulus,
                              * the new modulus must divide that one.
                              */
                             next_modulus = DatumGetInt32(boundinfo->datums[offset + 1][0]);
  
                             if (next_modulus % spec->modulus != 0)
                                 ereport(ERROR,
                                         (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                          errmsg("every hash partition modulus must be a factor of the next larger modulus"),
                                          errdetail("The new modulus %d is not a factor of %d, the modulus of existing partition \"%s\".",
                                                    spec->modulus, next_modulus,
                                                    get_rel_name(partdesc->oids[offset + 1]))));
                         }
                     }
  
                     greatest_modulus = boundinfo->nindexes;
                     remainder = spec->remainder;
  
                     /*
                      * Normally, the lowest remainder that could conflict with
                      * the new partition is equal to the remainder specified
                      * for the new partition, but when the new partition has a
                      * modulus higher than any used so far, we need to adjust.
                      */
                     if (remainder >= greatest_modulus)
                         remainder = remainder % greatest_modulus;
  
                     /* Check every potentially-conflicting remainder. */
                     do
                     {
                         if (boundinfo->indexes[remainder] != -1)
                         {
                             overlap = true;
                             overlap_location = spec->location;
                             with = boundinfo->indexes[remainder];
                             break;
                         }
                         remainder += spec->modulus;
                     } while (remainder < greatest_modulus);
                 }
  
                 break;
             }
  
         case PARTITION_STRATEGY_LIST:
             {
                 Assert(spec->strategy == PARTITION_STRATEGY_LIST);
  
                 if (partdesc->nparts > 0)
                 {
                     ListCell   *cell;
  
                     Assert(boundinfo &&
                            boundinfo->strategy == PARTITION_STRATEGY_LIST &&
                            (boundinfo->ndatums > 0 ||
                             partition_bound_accepts_nulls(boundinfo) ||
                             partition_bound_has_default(boundinfo)));
  
                     foreach(cell, spec->listdatums)
                     {
                         Const      *val = lfirst_node(Const, cell);
  
                         overlap_location = val->location;
                         if (!val->constisnull)
                         {
                             int         offset;
                             bool        equal;
  
                             offset = partition_list_bsearch(&key->partsupfunc[0],
                                                             key->partcollation,
                                                             boundinfo,
                                                             val->constvalue,
                                                             &equal);
                             if (offset >= 0 && equal)
                             {
                                 overlap = true;
                                 with = boundinfo->indexes[offset];
                                 break;
                             }
                         }
                         else if (partition_bound_accepts_nulls(boundinfo))
                         {
                             overlap = true;
                             with = boundinfo->null_index;
                             break;
                         }
                     }
                 }
  
                 break;
             }
  
         case PARTITION_STRATEGY_RANGE:
             {
                 PartitionRangeBound *lower,
                            *upper;
                 int         cmpval;
  
                 Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
                 lower = make_one_partition_rbound(key, -1, spec->lowerdatums, true);
                 upper = make_one_partition_rbound(key, -1, spec->upperdatums, false);
  
                 /*
                  * First check if the resulting range would be empty with
                  * specified lower and upper bounds.  partition_rbound_cmp
                  * cannot return zero here, since the lower-bound flags are
                  * different.
                  */
                 cmpval = partition_rbound_cmp(key->partnatts,
                                               key->partsupfunc,
                                               key->partcollation,
                                               lower->datums, lower->kind,
                                               true, upper);
                 Assert(cmpval != 0);
                 if (cmpval > 0)
                 {
                     /* Point to problematic key in the lower datums list. */
                     PartitionRangeDatum *datum = list_nth(spec->lowerdatums,
                                                           cmpval - 1);
  
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                              errmsg("empty range bound specified for partition \"%s\"",
                                     relname),
                              errdetail("Specified lower bound %s is greater than or equal to upper bound %s.",
                                        get_range_partbound_string(spec->lowerdatums),
                                        get_range_partbound_string(spec->upperdatums)),
                              parser_errposition(pstate, datum->location)));
                 }
  
                 if (partdesc->nparts > 0)
                 {
                     int         offset;
  
                     Assert(boundinfo &&
                            boundinfo->strategy == PARTITION_STRATEGY_RANGE &&
                            (boundinfo->ndatums > 0 ||
                             partition_bound_has_default(boundinfo)));
  
                     /*
                      * Test whether the new lower bound (which is treated
                      * inclusively as part of the new partition) lies inside
                      * an existing partition, or in a gap.
                      *
                      * If it's inside an existing partition, the bound at
                      * offset + 1 will be the upper bound of that partition,
                      * and its index will be >= 0.
                      *
                      * If it's in a gap, the bound at offset + 1 will be the
                      * lower bound of the next partition, and its index will
                      * be -1. This is also true if there is no next partition,
                      * since the index array is initialised with an extra -1
                      * at the end.
                      */
                     offset = partition_range_bsearch(key->partnatts,
                                                      key->partsupfunc,
                                                      key->partcollation,
                                                      boundinfo, lower,
                                                      &cmpval);
  
                     if (boundinfo->indexes[offset + 1] < 0)
                     {
                         /*
                          * Check that the new partition will fit in the gap.
                          * For it to fit, the new upper bound must be less
                          * than or equal to the lower bound of the next
                          * partition, if there is one.
                          */
                         if (offset + 1 < boundinfo->ndatums)
                         {
                             Datum      *datums;
                             PartitionRangeDatumKind *kind;
                             bool        is_lower;
  
                             datums = boundinfo->datums[offset + 1];
                             kind = boundinfo->kind[offset + 1];
                             is_lower = (boundinfo->indexes[offset + 1] == -1);
  
                             cmpval = partition_rbound_cmp(key->partnatts,
                                                           key->partsupfunc,
                                                           key->partcollation,
                                                           datums, kind,
                                                           is_lower, upper);
                             if (cmpval < 0)
                             {
                                 /*
                                  * Point to problematic key in the upper
                                  * datums list.
                                  */
                                 PartitionRangeDatum *datum =
                                     list_nth(spec->upperdatums, abs(cmpval) - 1);
  
                                 /*
                                  * The new partition overlaps with the
                                  * existing partition between offset + 1 and
                                  * offset + 2.
                                  */
                                 overlap = true;
                                 overlap_location = datum->location;
                                 with = boundinfo->indexes[offset + 2];
                             }
                         }
                     }
                     else
                     {
                         /*
                          * The new partition overlaps with the existing
                          * partition between offset and offset + 1.
                          */
                         PartitionRangeDatum *datum;
  
                         /*
                          * Point to problematic key in the lower datums list;
                          * if we have equality, point to the first one.
                          */
                         datum = cmpval == 0 ? linitial(spec->lowerdatums) :
                             list_nth(spec->lowerdatums, abs(cmpval) - 1);
                         overlap = true;
                         overlap_location = datum->location;
                         with = boundinfo->indexes[offset + 1];
                     }
                 }
  
                 break;
             }
     }
  
     if (overlap)
     {
         Assert(with >= 0);
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                  errmsg("partition \"%s\" would overlap partition \"%s\"",
                         relname, get_rel_name(partdesc->oids[with])),
                  parser_errposition(pstate, overlap_location)));
     }
 }

Referenced by ATExecAttachPartition(), and DefineRelation().

◆ compute_partition_hash_value()

uint64 compute_partition_hash_value	(	int	partnatts,
		FmgrInfo *	partsupfunc,
		Oid *	partcollation,
		Datum *	values,
		bool *	isnull
	)

Definition at line 4723 of file partbounds.c.

 {
     int         i;
     uint64      rowHash = 0;
     Datum       seed = UInt64GetDatum(HASH_PARTITION_SEED);
  
     for (i = 0; i < partnatts; i++)
     {
         /* Nulls are just ignored */
         if (!isnull[i])
         {
             Datum       hash;
  
             Assert(OidIsValid(partsupfunc[i].fn_oid));
  
             /*
              * Compute hash for each datum value by calling respective
              * datatype-specific hash functions of each partition key
              * attribute.
              */
             hash = FunctionCall2Coll(&partsupfunc[i], partcollation[i],
                                      values[i], seed);
  
             /* Form a single 64-bit hash value */
             rowHash = hash_combine64(rowHash, DatumGetUInt64(hash));
         }
     }
  
     return rowHash;
 }

References Assert(), DatumGetUInt64(), FunctionCall2Coll(), hash(), hash_combine64(), HASH_PARTITION_SEED, i, OidIsValid, UInt64GetDatum(), and values.

Referenced by get_matching_hash_bounds(), and get_partition_for_tuple().

◆ get_hash_partition_greatest_modulus()

int get_hash_partition_greatest_modulus ( PartitionBoundInfo bound )

Definition at line 3415 of file partbounds.c.

 {
     Assert(bound && bound->strategy == PARTITION_STRATEGY_HASH);
     return bound->nindexes;
 }

References Assert(), PartitionBoundInfoData::nindexes, PARTITION_STRATEGY_HASH, and PartitionBoundInfoData::strategy.

◆ get_qual_from_partbound()

List* get_qual_from_partbound	(	Relation	parent,
		PartitionBoundSpec *	spec
	)

Definition at line 250 of file partbounds.c.

 {
     PartitionKey key = RelationGetPartitionKey(parent);
     List       *my_qual = NIL;
  
     Assert(key != NULL);
  
     switch (key->strategy)
     {
         case PARTITION_STRATEGY_HASH:
             Assert(spec->strategy == PARTITION_STRATEGY_HASH);
             my_qual = get_qual_for_hash(parent, spec);
             break;
  
         case PARTITION_STRATEGY_LIST:
             Assert(spec->strategy == PARTITION_STRATEGY_LIST);
             my_qual = get_qual_for_list(parent, spec);
             break;
  
         case PARTITION_STRATEGY_RANGE:
             Assert(spec->strategy == PARTITION_STRATEGY_RANGE);
             my_qual = get_qual_for_range(parent, spec, false);
             break;
     }
  
     return my_qual;
 }

References Assert(), get_qual_for_hash(), get_qual_for_list(), get_qual_for_range(), sort-test::key, NIL, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, RelationGetPartitionKey(), and PartitionBoundSpec::strategy.

Referenced by ATExecAttachPartition(), and generate_partition_qual().

◆ partition_bounds_copy()

PartitionBoundInfo partition_bounds_copy	(	PartitionBoundInfo	src,
		PartitionKey	key
	)

Definition at line 1003 of file partbounds.c.

 {
     PartitionBoundInfo dest;
     int         i;
     int         ndatums;
     int         nindexes;
     int         partnatts;
     bool        hash_part;
     int         natts;
     Datum      *boundDatums;
  
     dest = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
  
     dest->strategy = src->strategy;
     ndatums = dest->ndatums = src->ndatums;
     nindexes = dest->nindexes = src->nindexes;
     partnatts = key->partnatts;
  
     /* List partitioned tables have only a single partition key. */
     Assert(key->strategy != PARTITION_STRATEGY_LIST || partnatts == 1);
  
     dest->datums = (Datum **) palloc(sizeof(Datum *) * ndatums);
  
     if (src->kind != NULL)
     {
         PartitionRangeDatumKind *boundKinds;
  
         /* only RANGE partition should have a non-NULL kind */
         Assert(key->strategy == PARTITION_STRATEGY_RANGE);
  
         dest->kind = (PartitionRangeDatumKind **) palloc(ndatums *
                                                          sizeof(PartitionRangeDatumKind *));
  
         /*
          * In the loop below, to save from allocating a series of small arrays
          * for storing the PartitionRangeDatumKind, we allocate a single chunk
          * here and use a smaller portion of it for each datum.
          */
         boundKinds = (PartitionRangeDatumKind *) palloc(ndatums * partnatts *
                                                         sizeof(PartitionRangeDatumKind));
  
         for (i = 0; i < ndatums; i++)
         {
             dest->kind[i] = &boundKinds[i * partnatts];
             memcpy(dest->kind[i], src->kind[i],
                    sizeof(PartitionRangeDatumKind) * partnatts);
         }
     }
     else
         dest->kind = NULL;
  
     /* copy interleaved partitions for LIST partitioned tables */
     dest->interleaved_parts = bms_copy(src->interleaved_parts);
  
     /*
      * For hash partitioning, datums array will have two elements - modulus
      * and remainder.
      */
     hash_part = (key->strategy == PARTITION_STRATEGY_HASH);
     natts = hash_part ? 2 : partnatts;
     boundDatums = palloc(ndatums * natts * sizeof(Datum));
  
     for (i = 0; i < ndatums; i++)
     {
         int         j;
  
         dest->datums[i] = &boundDatums[i * natts];
  
         for (j = 0; j < natts; j++)
         {
             bool        byval;
             int         typlen;
  
             if (hash_part)
             {
                 typlen = sizeof(int32); /* Always int4 */
                 byval = true;   /* int4 is pass-by-value */
             }
             else
             {
                 byval = key->parttypbyval[j];
                 typlen = key->parttyplen[j];
             }
  
             if (dest->kind == NULL ||
                 dest->kind[i][j] == PARTITION_RANGE_DATUM_VALUE)
                 dest->datums[i][j] = datumCopy(src->datums[i][j],
                                                byval, typlen);
         }
     }
  
     dest->indexes = (int *) palloc(sizeof(int) * nindexes);
     memcpy(dest->indexes, src->indexes, sizeof(int) * nindexes);
  
     dest->null_index = src->null_index;
     dest->default_index = src->default_index;
  
     return dest;
 }

Referenced by RelationBuildPartitionDesc().

◆ partition_bounds_create()

PartitionBoundInfo partition_bounds_create	(	PartitionBoundSpec **	boundspecs,
		int	nparts,
		PartitionKey	key,
		int **	mapping
	)

Definition at line 300 of file partbounds.c.

 {
     int         i;
  
     Assert(nparts > 0);
  
     /*
      * For each partitioning method, we first convert the partition bounds
      * from their parser node representation to the internal representation,
      * along with any additional preprocessing (such as de-duplicating range
      * bounds).  Resulting bound datums are then added to the 'datums' array
      * in PartitionBoundInfo.  For each datum added, an integer indicating the
      * canonical partition index is added to the 'indexes' array.
      *
      * For each bound, we remember its partition's position (0-based) in the
      * original list to later map it to the canonical index.
      */
  
     /*
      * Initialize mapping array with invalid values, this is filled within
      * each sub-routine below depending on the bound type.
      */
     *mapping = (int *) palloc(sizeof(int) * nparts);
     for (i = 0; i < nparts; i++)
         (*mapping)[i] = -1;
  
     switch (key->strategy)
     {
         case PARTITION_STRATEGY_HASH:
             return create_hash_bounds(boundspecs, nparts, key, mapping);
  
         case PARTITION_STRATEGY_LIST:
             return create_list_bounds(boundspecs, nparts, key, mapping);
  
         case PARTITION_STRATEGY_RANGE:
             return create_range_bounds(boundspecs, nparts, key, mapping);
     }
  
     Assert(false);
     return NULL;                /* keep compiler quiet */
 }

References Assert(), create_hash_bounds(), create_list_bounds(), create_range_bounds(), i, sort-test::key, palloc(), PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, and PARTITION_STRATEGY_RANGE.

Referenced by RelationBuildPartitionDesc().

◆ partition_bounds_equal()

bool partition_bounds_equal	(	int	partnatts,
		int16 *	parttyplen,
		bool *	parttypbyval,
		PartitionBoundInfo	b1,
		PartitionBoundInfo	b2
	)

Definition at line 897 of file partbounds.c.

 {
     int         i;
  
     if (b1->strategy != b2->strategy)
         return false;
  
     if (b1->ndatums != b2->ndatums)
         return false;
  
     if (b1->nindexes != b2->nindexes)
         return false;
  
     if (b1->null_index != b2->null_index)
         return false;
  
     if (b1->default_index != b2->default_index)
         return false;
  
     /* For all partition strategies, the indexes[] arrays have to match */
     for (i = 0; i < b1->nindexes; i++)
     {
         if (b1->indexes[i] != b2->indexes[i])
             return false;
     }
  
     /* Finally, compare the datums[] arrays */
     if (b1->strategy == PARTITION_STRATEGY_HASH)
     {
         /*
          * We arrange the partitions in the ascending order of their moduli
          * and remainders.  Also every modulus is factor of next larger
          * modulus.  Therefore we can safely store index of a given partition
          * in indexes array at remainder of that partition.  Also entries at
          * (remainder + N * modulus) positions in indexes array are all same
          * for (modulus, remainder) specification for any partition.  Thus the
          * datums arrays from the given bounds are the same, if and only if
          * their indexes arrays are the same.  So, it suffices to compare the
          * indexes arrays.
          *
          * Nonetheless make sure that the bounds are indeed the same when the
          * indexes match.  Hash partition bound stores modulus and remainder
          * at b1->datums[i][0] and b1->datums[i][1] position respectively.
          */
 #ifdef USE_ASSERT_CHECKING
         for (i = 0; i < b1->ndatums; i++)
             Assert((b1->datums[i][0] == b2->datums[i][0] &&
                     b1->datums[i][1] == b2->datums[i][1]));
 #endif
     }
     else
     {
         for (i = 0; i < b1->ndatums; i++)
         {
             int         j;
  
             for (j = 0; j < partnatts; j++)
             {
                 /* For range partitions, the bounds might not be finite. */
                 if (b1->kind != NULL)
                 {
                     /* The different kinds of bound all differ from each other */
                     if (b1->kind[i][j] != b2->kind[i][j])
                         return false;
  
                     /*
                      * Non-finite bounds are equal without further
                      * examination.
                      */
                     if (b1->kind[i][j] != PARTITION_RANGE_DATUM_VALUE)
                         continue;
                 }
  
                 /*
                  * Compare the actual values. Note that it would be both
                  * incorrect and unsafe to invoke the comparison operator
                  * derived from the partitioning specification here.  It would
                  * be incorrect because we want the relcache entry to be
                  * updated for ANY change to the partition bounds, not just
                  * those that the partitioning operator thinks are
                  * significant.  It would be unsafe because we might reach
                  * this code in the context of an aborted transaction, and an
                  * arbitrary partitioning operator might not be safe in that
                  * context.  datumIsEqual() should be simple enough to be
                  * safe.
                  */
                 if (!datumIsEqual(b1->datums[i][j], b2->datums[i][j],
                                   parttypbyval[j], parttyplen[j]))
                     return false;
             }
         }
     }
     return true;
 }

References Assert(), datumIsEqual(), PartitionBoundInfoData::datums, PartitionBoundInfoData::default_index, i, PartitionBoundInfoData::indexes, j, PartitionBoundInfoData::kind, PartitionBoundInfoData::ndatums, PartitionBoundInfoData::nindexes, PartitionBoundInfoData::null_index, PARTITION_RANGE_DATUM_VALUE, PARTITION_STRATEGY_HASH, and PartitionBoundInfoData::strategy.

Referenced by compute_partition_bounds().

◆ partition_bounds_merge()

PartitionBoundInfo partition_bounds_merge	(	int	partnatts,
		FmgrInfo *	partsupfunc,
		Oid *	partcollation,
		struct RelOptInfo *	outer_rel,
		struct RelOptInfo *	inner_rel,
		JoinType	jointype,
		List **	outer_parts,
		List **	inner_parts
	)

Definition at line 1119 of file partbounds.c.

 {
     /*
      * Currently, this function is called only from try_partitionwise_join(),
      * so the join type should be INNER, LEFT, FULL, SEMI, or ANTI.
      */
     Assert(jointype == JOIN_INNER || jointype == JOIN_LEFT ||
            jointype == JOIN_FULL || jointype == JOIN_SEMI ||
            jointype == JOIN_ANTI);
  
     /* The partitioning strategies should be the same. */
     Assert(outer_rel->boundinfo->strategy == inner_rel->boundinfo->strategy);
  
     *outer_parts = *inner_parts = NIL;
     switch (outer_rel->boundinfo->strategy)
     {
         case PARTITION_STRATEGY_HASH:
  
             /*
              * For hash partitioned tables, we currently support partitioned
              * join only when they have exactly the same partition bounds.
              *
              * XXX: it might be possible to relax the restriction to support
              * cases where hash partitioned tables have missing partitions
              * and/or different moduli, but it's not clear if it would be
              * useful to support the former case since it's unusual to have
              * missing partitions.  On the other hand, it would be useful to
              * support the latter case, but in that case, there is a high
              * probability that a partition on one side will match multiple
              * partitions on the other side, which is the scenario the current
              * implementation of partitioned join can't handle.
              */
             return NULL;
  
         case PARTITION_STRATEGY_LIST:
             return merge_list_bounds(partsupfunc,
                                      partcollation,
                                      outer_rel,
                                      inner_rel,
                                      jointype,
                                      outer_parts,
                                      inner_parts);
  
         case PARTITION_STRATEGY_RANGE:
             return merge_range_bounds(partnatts,
                                       partsupfunc,
                                       partcollation,
                                       outer_rel,
                                       inner_rel,
                                       jointype,
                                       outer_parts,
                                       inner_parts);
     }
  
     return NULL;
 }

References Assert(), JOIN_ANTI, JOIN_FULL, JOIN_INNER, JOIN_LEFT, JOIN_SEMI, merge_list_bounds(), merge_range_bounds(), NIL, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, and PARTITION_STRATEGY_RANGE.

Referenced by compute_partition_bounds().

◆ partition_hash_bsearch()

int partition_hash_bsearch	(	PartitionBoundInfo	boundinfo,
		int	modulus,
		int	remainder
	)

Definition at line 3739 of file partbounds.c.

 {
     int         lo,
                 hi,
                 mid;
  
     lo = -1;
     hi = boundinfo->ndatums - 1;
     while (lo < hi)
     {
         int32       cmpval,
                     bound_modulus,
                     bound_remainder;
  
         mid = (lo + hi + 1) / 2;
         bound_modulus = DatumGetInt32(boundinfo->datums[mid][0]);
         bound_remainder = DatumGetInt32(boundinfo->datums[mid][1]);
         cmpval = partition_hbound_cmp(bound_modulus, bound_remainder,
                                       modulus, remainder);
         if (cmpval <= 0)
         {
             lo = mid;
  
             if (cmpval == 0)
                 break;
         }
         else
             hi = mid - 1;
     }
  
     return lo;
 }

References DatumGetInt32(), PartitionBoundInfoData::datums, PartitionBoundInfoData::ndatums, and partition_hbound_cmp().

Referenced by check_new_partition_bound().

◆ partition_list_bsearch()

int partition_list_bsearch	(	FmgrInfo *	partsupfunc,
		Oid *	partcollation,
		PartitionBoundInfo	boundinfo,
		Datum	value,
		bool *	is_equal
	)

Definition at line 3608 of file partbounds.c.

 {
     int         lo,
                 hi,
                 mid;
  
     lo = -1;
     hi = boundinfo->ndatums - 1;
     while (lo < hi)
     {
         int32       cmpval;
  
         mid = (lo + hi + 1) / 2;
         cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
                                                  partcollation[0],
                                                  boundinfo->datums[mid][0],
                                                  value));
         if (cmpval <= 0)
         {
             lo = mid;
             *is_equal = (cmpval == 0);
             if (*is_equal)
                 break;
         }
         else
             hi = mid - 1;
     }
  
     return lo;
 }

References DatumGetInt32(), PartitionBoundInfoData::datums, FunctionCall2Coll(), PartitionBoundInfoData::ndatums, and value.

Referenced by check_new_partition_bound(), get_matching_list_bounds(), and get_partition_for_tuple().

◆ partition_range_datum_bsearch()

int partition_range_datum_bsearch	(	FmgrInfo *	partsupfunc,
		Oid *	partcollation,
		PartitionBoundInfo	boundinfo,
		int	nvalues,
		Datum *	values,
		bool *	is_equal
	)

Definition at line 3696 of file partbounds.c.

 {
     int         lo,
                 hi,
                 mid;
  
     lo = -1;
     hi = boundinfo->ndatums - 1;
     while (lo < hi)
     {
         int32       cmpval;
  
         mid = (lo + hi + 1) / 2;
         cmpval = partition_rbound_datum_cmp(partsupfunc,
                                             partcollation,
                                             boundinfo->datums[mid],
                                             boundinfo->kind[mid],
                                             values,
                                             nvalues);
         if (cmpval <= 0)
         {
             lo = mid;
             *is_equal = (cmpval == 0);
  
             if (*is_equal)
                 break;
         }
         else
             hi = mid - 1;
     }
  
     return lo;
 }

References PartitionBoundInfoData::datums, PartitionBoundInfoData::kind, PartitionBoundInfoData::ndatums, partition_rbound_datum_cmp(), and values.

Referenced by get_matching_range_bounds(), and get_partition_for_tuple().

◆ partition_rbound_datum_cmp()

int32 partition_rbound_datum_cmp	(	FmgrInfo *	partsupfunc,
		Oid *	partcollation,
		Datum *	rb_datums,
		PartitionRangeDatumKind *	rb_kind,
		Datum *	tuple_datums,
		int	n_tuple_datums
	)

Definition at line 3557 of file partbounds.c.

 {
     int         i;
     int32       cmpval = -1;
  
     for (i = 0; i < n_tuple_datums; i++)
     {
         if (rb_kind[i] == PARTITION_RANGE_DATUM_MINVALUE)
             return -1;
         else if (rb_kind[i] == PARTITION_RANGE_DATUM_MAXVALUE)
             return 1;
  
         cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
                                                  partcollation[i],
                                                  rb_datums[i],
                                                  tuple_datums[i]));
         if (cmpval != 0)
             break;
     }
  
     return cmpval;
 }

References DatumGetInt32(), FunctionCall2Coll(), i, PARTITION_RANGE_DATUM_MAXVALUE, and PARTITION_RANGE_DATUM_MINVALUE.

Referenced by get_matching_range_bounds(), get_partition_for_tuple(), and partition_range_datum_bsearch().

◆ partitions_are_ordered()

bool partitions_are_ordered	(	PartitionBoundInfo	boundinfo,
		Bitmapset *	live_parts
	)

Definition at line 2853 of file partbounds.c.

 {
     Assert(boundinfo != NULL);
  
     switch (boundinfo->strategy)
     {
         case PARTITION_STRATEGY_RANGE:
  
             /*
              * RANGE-type partitioning guarantees that the partitions can be
              * scanned in the order that they're defined in the PartitionDesc
              * to provide sequential, non-overlapping ranges of tuples.
              * However, if a DEFAULT partition exists and it's contained
              * within live_parts, then the partitions are not ordered.
              */
             if (!partition_bound_has_default(boundinfo) ||
                 !bms_is_member(boundinfo->default_index, live_parts))
                 return true;
             break;
  
         case PARTITION_STRATEGY_LIST:
  
             /*
              * LIST partitioned are ordered providing none of live_parts
              * overlap with the partitioned table's interleaved partitions.
              */
             if (!bms_overlap(live_parts, boundinfo->interleaved_parts))
                 return true;
  
             break;
         case PARTITION_STRATEGY_HASH:
             break;
     }
  
     return false;
 }

References Assert(), bms_is_member(), bms_overlap(), PartitionBoundInfoData::default_index, PartitionBoundInfoData::interleaved_parts, partition_bound_has_default, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, and PartitionBoundInfoData::strategy.

Referenced by build_partition_pathkeys(), and generate_orderedappend_paths().

Data Structures

Macros

Typedefs

Functions