#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, const Oid partcollation, const Datum values, const 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)

void	check_partitions_for_split (Relation parent, Oid splitPartOid, RangeVar splitPartName, List partlist, ParseState *pstate)

void	calculate_partition_bound_for_merge (Relation parent, List partNames, List partOids, PartitionBoundSpec spec, ParseState pstate)

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

◆ calculate_partition_bound_for_merge()

void calculate_partition_bound_for_merge	(	Relation	parent,
		List *	partNames,
		List *	partOids,
		PartitionBoundSpec *	spec,
		ParseState *	pstate
	)

Definition at line 5782 of file partbounds.c.

 {
     PartitionKey key = RelationGetPartitionKey(parent);
     PartitionBoundSpec *bound;
  
     Assert(!spec->is_default);
  
     switch (key->strategy)
     {
         case PARTITION_STRATEGY_RANGE:
             {
                 int         i;
                 PartitionRangeBound **lower_bounds;
                 int         nparts = list_length(partOids);
                 List       *bounds = NIL;
  
                 lower_bounds = (PartitionRangeBound **)
                     palloc0(nparts * sizeof(PartitionRangeBound *));
  
                 /*
                  * Create array of lower bounds and list of
                  * PartitionBoundSpec.
                  */
                 for (i = 0; i < nparts; i++)
                 {
                     bound = get_partition_bound_spec(list_nth_oid(partOids, i),
                                                      (RangeVar *) list_nth(partNames, i));
  
                     lower_bounds[i] = make_one_partition_rbound(key, i, bound->lowerdatums, true);
                     bounds = lappend(bounds, bound);
                 }
  
                 /* Sort array of lower bounds. */
                 qsort_arg(lower_bounds, nparts, sizeof(PartitionRangeBound *),
                           qsort_partition_rbound_cmp, (void *) key);
  
                 /* Ranges of partitions should not overlap. */
                 for (i = 1; i < nparts; i++)
                 {
                     int         index = lower_bounds[i]->index;
                     int         prev_index = lower_bounds[i - 1]->index;
  
                     check_two_partitions_bounds_range(parent,
                                                       (RangeVar *) list_nth(partNames, prev_index),
                                                       (PartitionBoundSpec *) list_nth(bounds, prev_index),
                                                       (RangeVar *) list_nth(partNames, index),
                                                       (PartitionBoundSpec *) list_nth(bounds, index),
                                                       false, pstate);
                 }
  
                 /*
                  * Lower bound of first partition is the lower bound of merged
                  * partition.
                  */
                 spec->lowerdatums =
                     ((PartitionBoundSpec *) list_nth(bounds, lower_bounds[0]->index))->lowerdatums;
  
                 /*
                  * Upper bound of last partition is the upper bound of merged
                  * partition.
                  */
                 spec->upperdatums =
                     ((PartitionBoundSpec *) list_nth(bounds, lower_bounds[nparts - 1]->index))->upperdatums;
  
                 pfree(lower_bounds);
                 list_free(bounds);
                 break;
             }
  
         case PARTITION_STRATEGY_LIST:
             {
                 ListCell   *listptr,
                            *listptr2;
  
                 /* Consolidate bounds for all partitions in the list. */
                 forboth(listptr, partOids, listptr2, partNames)
                 {
                     RangeVar   *name = (RangeVar *) lfirst(listptr2);
                     Oid         curOid = lfirst_oid(listptr);
  
                     bound = get_partition_bound_spec(curOid, name);
                     spec->listdatums = list_concat(spec->listdatums, bound->listdatums);
                 }
                 break;
             }
  
         default:
             elog(ERROR, "unexpected partition strategy: %d",
                  (int) key->strategy);
     }
 }

References Assert, check_two_partitions_bounds_range(), elog, ERROR, forboth, get_partition_bound_spec(), i, PartitionRangeBound::index, PartitionBoundSpec::is_default, sort-test::key, lappend(), lfirst, lfirst_oid, list_concat(), list_free(), list_length(), list_nth(), list_nth_oid(), PartitionBoundSpec::listdatums, PartitionBoundSpec::lowerdatums, make_one_partition_rbound(), name, NIL, palloc0(), PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, pfree(), qsort_arg(), qsort_partition_rbound_cmp(), RelationGetPartitionKey(), and PartitionBoundSpec::upperdatums.

Referenced by transformPartitionCmdForMerge().

◆ 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 2896 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 list of lower
                          * datums; 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(), check_partitions_for_split(), and DefineRelation().

◆ check_partitions_for_split()

void check_partitions_for_split	(	Relation	parent,
		Oid	splitPartOid,
		RangeVar *	splitPartName,
		List *	partlist,
		ParseState *	pstate
	)

Definition at line 5563 of file partbounds.c.

 {
     PartitionKey key;
     char        strategy;
     Oid         defaultPartOid;
     bool        isSplitPartDefault;
     bool        existsDefaultPart;
     ListCell   *listptr;
     int         default_index = -1;
     int         i,
                 j;
     SinglePartitionSpec **new_parts;
     SinglePartitionSpec *spsPrev = NULL;
     int         nparts = 0;
  
     key = RelationGetPartitionKey(parent);
     strategy = get_partition_strategy(key);
  
     switch (strategy)
     {
         case PARTITION_STRATEGY_LIST:
         case PARTITION_STRATEGY_RANGE:
             {
                 /*
                  * Make array new_parts with new partitions except DEFAULT
                  * partition.
                  */
                 new_parts = (SinglePartitionSpec **)
                     palloc0(list_length(partlist) * sizeof(SinglePartitionSpec *));
                 i = 0;
                 foreach(listptr, partlist)
                 {
                     SinglePartitionSpec *sps =
                         (SinglePartitionSpec *) lfirst(listptr);
  
                     if (sps->bound->is_default)
                     {
                         if (default_index >= 0)
                             ereport(ERROR,
                                     (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                                      errmsg("DEFAULT partition should be one")),
                                     parser_errposition(pstate, sps->name->location));
                         default_index = i;
                     }
                     else
                     {
                         new_parts[nparts++] = sps;
                     }
                     i++;
                 }
             }
             break;
  
         case PARTITION_STRATEGY_HASH:
             ereport(ERROR,
                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                      errmsg("partition of hash-partitioned table cannot be split")));
             break;
  
         default:
             elog(ERROR, "unexpected partition strategy: %d",
                  (int) key->strategy);
             break;
     }
  
     if (strategy == PARTITION_STRATEGY_RANGE)
     {
         PartitionRangeBound **lower_bounds;
         SinglePartitionSpec **tmp_new_parts;
  
         /*
          * For simplify check for ranges of new partitions need to sort all
          * partitions in ascending order of them bounds (we compare upper
          * bound only).
          */
         lower_bounds = (PartitionRangeBound **)
             palloc0(nparts * sizeof(PartitionRangeBound *));
  
         /* Create array of lower bounds. */
         for (i = 0; i < nparts; i++)
         {
             lower_bounds[i] = make_one_partition_rbound(key, i,
                                                         new_parts[i]->bound->lowerdatums, true);
         }
  
         /* Sort array of lower bounds. */
         qsort_arg(lower_bounds, nparts, sizeof(PartitionRangeBound *),
                   qsort_partition_rbound_cmp, (void *) key);
  
         /* Reorder array of partitions. */
         tmp_new_parts = new_parts;
         new_parts = (SinglePartitionSpec **)
             palloc0(nparts * sizeof(SinglePartitionSpec *));
         for (i = 0; i < nparts; i++)
             new_parts[i] = tmp_new_parts[lower_bounds[i]->index];
  
         pfree(tmp_new_parts);
         pfree(lower_bounds);
     }
  
     defaultPartOid =
         get_default_oid_from_partdesc(RelationGetPartitionDesc(parent, true));
  
     /* isSplitPartDefault flag: is split partition a DEFAULT partition? */
     isSplitPartDefault = (defaultPartOid == splitPartOid);
  
     if (isSplitPartDefault && default_index < 0)
     {
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                  errmsg("one partition in the list should be DEFAULT because split partition is DEFAULT")),
                 parser_errposition(pstate, ((SinglePartitionSpec *) linitial(partlist))->name->location));
     }
     else if (!isSplitPartDefault && (default_index >= 0) && OidIsValid(defaultPartOid))
     {
         SinglePartitionSpec *spsDef =
             (SinglePartitionSpec *) list_nth(partlist, default_index);
  
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
                  errmsg("new partition cannot be DEFAULT because DEFAULT partition already exists")),
                 parser_errposition(pstate, spsDef->name->location));
     }
  
     /* Indicator that partitioned table has (or will have) DEFAULT partition */
     existsDefaultPart = OidIsValid(defaultPartOid) || (default_index >= 0);
  
     for (i = 0; i < nparts; i++)
     {
         SinglePartitionSpec *sps = new_parts[i];
  
         if (isSplitPartDefault)
         {
             /*
              * In case split partition is DEFAULT partition we can use any
              * free ranges - as when creating a new partition.
              */
             check_new_partition_bound(sps->name->relname, parent, sps->bound,
                                       pstate);
         }
         else
         {
             /*
              * Checks that bound of current partition is inside bound of split
              * partition. For range partitioning: checks that upper bound of
              * previous partition is equal to lower bound of current
              * partition. For list partitioning: checks that split partition
              * contains all values of current partition.
              */
             if (strategy == PARTITION_STRATEGY_RANGE)
             {
                 bool        first = (i == 0);
                 bool        last = (i == (nparts - 1));
  
                 check_partition_bounds_for_split_range(parent, sps->name->relname, sps->bound,
                                                        splitPartOid, splitPartName,
                                                        first, last,
                                                        existsDefaultPart, pstate);
             }
             else
                 check_partition_bounds_for_split_list(parent, sps->name->relname,
                                                       sps->bound, splitPartOid, pstate);
         }
  
         /* Ranges of new partitions should not overlap. */
         if (strategy == PARTITION_STRATEGY_RANGE && spsPrev)
             check_two_partitions_bounds_range(parent, spsPrev->name, spsPrev->bound,
                                               sps->name, sps->bound, existsDefaultPart, pstate);
  
         spsPrev = sps;
  
         /* Check: new partitions should have different names. */
         for (j = i + 1; j < nparts; j++)
         {
             SinglePartitionSpec *sps2 = new_parts[j];
  
             if (equal(sps->name, sps2->name))
                 ereport(ERROR,
                         (errcode(ERRCODE_DUPLICATE_TABLE),
                          errmsg("name \"%s\" is already used", sps2->name->relname)),
                         parser_errposition(pstate, sps2->name->location));
         }
     }
  
     if (strategy == PARTITION_STRATEGY_LIST)
     {
         /* Values of new partitions should not overlap. */
         check_partitions_not_overlap_list(parent, new_parts, nparts,
                                           pstate);
  
         /*
          * Need to check that all values of split partition contains in new
          * partitions. Skip this check if DEFAULT partition exists.
          */
         if (!existsDefaultPart)
             check_parent_values_in_new_partitions(parent, splitPartOid,
                                                   new_parts, nparts, pstate);
     }
  
     pfree(new_parts);
 }

References SinglePartitionSpec::bound, check_new_partition_bound(), check_parent_values_in_new_partitions(), check_partition_bounds_for_split_list(), check_partition_bounds_for_split_range(), check_partitions_not_overlap_list(), check_two_partitions_bounds_range(), elog, equal(), ereport, errcode(), errmsg(), ERROR, get_default_oid_from_partdesc(), get_partition_strategy(), i, PartitionBoundSpec::is_default, j, sort-test::key, lfirst, linitial, list_length(), list_nth(), RangeVar::location, make_one_partition_rbound(), name, SinglePartitionSpec::name, OidIsValid, palloc0(), parser_errposition(), PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, pfree(), qsort_arg(), qsort_partition_rbound_cmp(), RelationGetPartitionDesc(), RelationGetPartitionKey(), and RangeVar::relname.

Referenced by transformPartitionCmdForSplit().

◆ compute_partition_hash_value()

uint64 compute_partition_hash_value	(	int	partnatts,
		FmgrInfo *	partsupfunc,
		const Oid *	partcollation,
		const Datum *	values,
		const 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 249 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(), generate_partition_qual(), and moveSplitTableRows().

◆ partition_bounds_copy()

PartitionBoundInfo partition_bounds_copy	(	PartitionBoundInfo	src,
		PartitionKey	key
	)

Definition at line 1002 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 299 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 896 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 1118 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(), check_partition_bounds_for_split_list(), 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 2852 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