#include "postgres.h"
#include "access/relation.h"
#include "access/table.h"
#include "access/tableam.h"
#include "catalog/partition.h"
#include "catalog/pg_inherits.h"
#include "catalog/pg_type.h"
#include "commands/tablecmds.h"
#include "common/hashfn.h"
#include "executor/executor.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/pathnodes.h"
#include "parser/parse_coerce.h"
#include "partitioning/partbounds.h"
#include "partitioning/partdesc.h"
#include "partitioning/partprune.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/datum.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/partcache.h"
#include "utils/ruleutils.h"
#include "utils/snapmgr.h"
#include "utils/syscache.h"

Include dependency graph for partbounds.c:

Data Structures
struct	PartitionHashBound

struct	PartitionListValue

struct	PartitionRangeBound

struct	PartitionMap

Macros
#define	compare_range_bounds(partnatts, partsupfunc, partcollations, bound1, bound2)

Typedefs
typedef struct PartitionHashBound	PartitionHashBound

typedef struct PartitionListValue	PartitionListValue

typedef struct PartitionRangeBound	PartitionRangeBound

typedef struct PartitionMap	PartitionMap

Functions
static int32	qsort_partition_hbound_cmp (const void a, const void b)

static int32	qsort_partition_list_value_cmp (const void a, const void b, void *arg)

static int32	qsort_partition_rbound_cmp (const void a, const void b, void *arg)

static PartitionBoundInfo	create_hash_bounds (PartitionBoundSpec boundspecs, int nparts, PartitionKey key, int mapping)

static PartitionBoundInfo	create_list_bounds (PartitionBoundSpec boundspecs, int nparts, PartitionKey key, int mapping)

static PartitionBoundInfo	create_range_bounds (PartitionBoundSpec boundspecs, int nparts, PartitionKey key, int mapping)

static PartitionBoundInfo	merge_list_bounds (FmgrInfo partsupfunc, Oid partcollation, RelOptInfo outer_rel, RelOptInfo inner_rel, JoinType jointype, List outer_parts, List inner_parts)

static PartitionBoundInfo	merge_range_bounds (int partnatts, FmgrInfo partsupfuncs, Oid partcollations, RelOptInfo outer_rel, RelOptInfo inner_rel, JoinType jointype, List outer_parts, List inner_parts)

static void	init_partition_map (RelOptInfo rel, PartitionMap map)

static void	free_partition_map (PartitionMap *map)

static bool	is_dummy_partition (RelOptInfo *rel, int part_index)

static int	merge_matching_partitions (PartitionMap outer_map, PartitionMap inner_map, int outer_index, int inner_index, int *next_index)

static int	process_outer_partition (PartitionMap outer_map, PartitionMap inner_map, bool outer_has_default, bool inner_has_default, int outer_index, int inner_default, JoinType jointype, int next_index, int default_index)

static int	process_inner_partition (PartitionMap outer_map, PartitionMap inner_map, bool outer_has_default, bool inner_has_default, int inner_index, int outer_default, JoinType jointype, int next_index, int default_index)

static void	merge_null_partitions (PartitionMap outer_map, PartitionMap inner_map, bool outer_has_null, bool inner_has_null, int outer_null, int inner_null, JoinType jointype, int next_index, int null_index)

static void	merge_default_partitions (PartitionMap outer_map, PartitionMap inner_map, bool outer_has_default, bool inner_has_default, int outer_default, int inner_default, JoinType jointype, int next_index, int default_index)

static int	merge_partition_with_dummy (PartitionMap map, int index, int next_index)

static void	fix_merged_indexes (PartitionMap outer_map, PartitionMap inner_map, int nmerged, List *merged_indexes)

static void	generate_matching_part_pairs (RelOptInfo outer_rel, RelOptInfo inner_rel, PartitionMap outer_map, PartitionMap inner_map, int nmerged, List outer_parts, List inner_parts)

static PartitionBoundInfo	build_merged_partition_bounds (char strategy, List merged_datums, List merged_kinds, List *merged_indexes, int null_index, int default_index)

static int	get_range_partition (RelOptInfo rel, PartitionBoundInfo bi, int lb_pos, PartitionRangeBound lb, PartitionRangeBound ub)

static int	get_range_partition_internal (PartitionBoundInfo bi, int lb_pos, PartitionRangeBound lb, PartitionRangeBound *ub)

static bool	compare_range_partitions (int partnatts, FmgrInfo partsupfuncs, Oid partcollations, PartitionRangeBound outer_lb, PartitionRangeBound outer_ub, PartitionRangeBound inner_lb, PartitionRangeBound inner_ub, int lb_cmpval, int ub_cmpval)

static void	get_merged_range_bounds (int partnatts, FmgrInfo partsupfuncs, Oid partcollations, JoinType jointype, PartitionRangeBound outer_lb, PartitionRangeBound outer_ub, PartitionRangeBound inner_lb, PartitionRangeBound inner_ub, int lb_cmpval, int ub_cmpval, PartitionRangeBound merged_lb, PartitionRangeBound merged_ub)

static void	add_merged_range_bounds (int partnatts, FmgrInfo partsupfuncs, Oid partcollations, PartitionRangeBound merged_lb, PartitionRangeBound merged_ub, int merged_index, List merged_datums, List merged_kinds, List **merged_indexes)

static PartitionRangeBound *	make_one_partition_rbound (PartitionKey key, int index, List *datums, bool lower)

static int32	partition_hbound_cmp (int modulus1, int remainder1, int modulus2, int remainder2)

static int32	partition_rbound_cmp (int partnatts, FmgrInfo partsupfunc, Oid partcollation, Datum datums1, PartitionRangeDatumKind kind1, bool lower1, PartitionRangeBound *b2)

static int	partition_range_bsearch (int partnatts, FmgrInfo partsupfunc, Oid partcollation, PartitionBoundInfo boundinfo, PartitionRangeBound probe, int32 cmpval)

static Expr *	make_partition_op_expr (PartitionKey key, int keynum, uint16 strategy, Expr arg1, Expr arg2)

static Oid	get_partition_operator (PartitionKey key, int col, StrategyNumber strategy, bool *need_relabel)

static List *	get_qual_for_hash (Relation parent, PartitionBoundSpec *spec)

static List *	get_qual_for_list (Relation parent, PartitionBoundSpec *spec)

static List *	get_qual_for_range (Relation parent, PartitionBoundSpec *spec, bool for_default)

static void	get_range_key_properties (PartitionKey key, int keynum, PartitionRangeDatum ldatum, PartitionRangeDatum udatum, ListCell partexprs_item, Expr keyCol, Const lower_val, Const upper_val)

static List *	get_range_nulltest (PartitionKey key)

List *	get_qual_from_partbound (Relation parent, PartitionBoundSpec *spec)

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

static int	get_non_null_list_datum_count (PartitionBoundSpec **boundspecs, int nparts)

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, RelOptInfo outer_rel, 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)

int	get_hash_partition_greatest_modulus (PartitionBoundInfo bound)

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)

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

Datum	satisfies_hash_partition (PG_FUNCTION_ARGS)

Macro Definition Documentation

◆ compare_range_bounds

#define compare_range_bounds	(	partnatts,
		partsupfunc,
		partcollations,
		bound1,
		bound2
	)

Value:

    (partition_rbound_cmp(partnatts, partsupfunc, partcollations, \
                          (bound1)->datums, (bound1)->kind, (bound1)->lower, \
                          bound2))

Definition at line 89 of file partbounds.c.

Typedef Documentation

◆ PartitionHashBound

typedef struct PartitionHashBound PartitionHashBound

◆ PartitionListValue

typedef struct PartitionListValue PartitionListValue

◆ PartitionMap

typedef struct PartitionMap PartitionMap

◆ PartitionRangeBound

typedef struct PartitionRangeBound PartitionRangeBound

Function Documentation

◆ add_merged_range_bounds()

static void add_merged_range_bounds	(	int	partnatts,
		FmgrInfo *	partsupfuncs,
		Oid *	partcollations,
		PartitionRangeBound *	merged_lb,
		PartitionRangeBound *	merged_ub,
		int	merged_index,
		List **	merged_datums,
		List **	merged_kinds,
		List **	merged_indexes
	)

static

Definition at line 2776 of file partbounds.c.

 {
     int         cmpval;
  
     if (!*merged_datums)
     {
         /* First merged partition */
         Assert(!*merged_kinds);
         Assert(!*merged_indexes);
         cmpval = 1;
     }
     else
     {
         PartitionRangeBound prev_ub;
  
         Assert(*merged_datums);
         Assert(*merged_kinds);
         Assert(*merged_indexes);
  
         /* Get the last upper bound. */
         prev_ub.index = llast_int(*merged_indexes);
         prev_ub.datums = (Datum *) llast(*merged_datums);
         prev_ub.kind = (PartitionRangeDatumKind *) llast(*merged_kinds);
         prev_ub.lower = false;
  
         /*
          * We pass lower1 = false to partition_rbound_cmp() to prevent it from
          * considering the last upper bound to be smaller than the lower bound
          * of the merged partition when the values of the two range bounds
          * compare equal.
          */
         cmpval = partition_rbound_cmp(partnatts, partsupfuncs, partcollations,
                                       merged_lb->datums, merged_lb->kind,
                                       false, &prev_ub);
         Assert(cmpval >= 0);
     }
  
     /*
      * If the lower bound is higher than the last upper bound, add the lower
      * bound with the index as -1 indicating that that is a lower bound; else,
      * the last upper bound will be reused as the lower bound of the merged
      * partition, so skip this.
      */
     if (cmpval > 0)
     {
         *merged_datums = lappend(*merged_datums, merged_lb->datums);
         *merged_kinds = lappend(*merged_kinds, merged_lb->kind);
         *merged_indexes = lappend_int(*merged_indexes, -1);
     }
  
     /* Add the upper bound and index of the merged partition. */
     *merged_datums = lappend(*merged_datums, merged_ub->datums);
     *merged_kinds = lappend(*merged_kinds, merged_ub->kind);
     *merged_indexes = lappend_int(*merged_indexes, merged_index);
 }

References Assert(), PartitionRangeBound::datums, PartitionRangeBound::index, PartitionRangeBound::kind, lappend(), lappend_int(), llast, llast_int, PartitionRangeBound::lower, and partition_rbound_cmp().

Referenced by merge_range_bounds().

◆ build_merged_partition_bounds()

static PartitionBoundInfo build_merged_partition_bounds	(	char	strategy,
		List *	merged_datums,
		List *	merged_kinds,
		List *	merged_indexes,
		int	null_index,
		int	default_index
	)

static

Definition at line 2519 of file partbounds.c.

 {
     PartitionBoundInfo merged_bounds;
     int         ndatums = list_length(merged_datums);
     int         pos;
     ListCell   *lc;
  
     merged_bounds = (PartitionBoundInfo) palloc(sizeof(PartitionBoundInfoData));
     merged_bounds->strategy = strategy;
     merged_bounds->ndatums = ndatums;
  
     merged_bounds->datums = (Datum **) palloc(sizeof(Datum *) * ndatums);
     pos = 0;
     foreach(lc, merged_datums)
         merged_bounds->datums[pos++] = (Datum *) lfirst(lc);
  
     if (strategy == PARTITION_STRATEGY_RANGE)
     {
         Assert(list_length(merged_kinds) == ndatums);
         merged_bounds->kind = (PartitionRangeDatumKind **)
             palloc(sizeof(PartitionRangeDatumKind *) * ndatums);
         pos = 0;
         foreach(lc, merged_kinds)
             merged_bounds->kind[pos++] = (PartitionRangeDatumKind *) lfirst(lc);
  
         /* There are ndatums+1 indexes in the case of range partitioning. */
         merged_indexes = lappend_int(merged_indexes, -1);
         ndatums++;
     }
     else
     {
         Assert(strategy == PARTITION_STRATEGY_LIST);
         Assert(merged_kinds == NIL);
         merged_bounds->kind = NULL;
     }
  
     /* interleaved_parts is always NULL for join relations. */
     merged_bounds->interleaved_parts = NULL;
  
     Assert(list_length(merged_indexes) == ndatums);
     merged_bounds->nindexes = ndatums;
     merged_bounds->indexes = (int *) palloc(sizeof(int) * ndatums);
     pos = 0;
     foreach(lc, merged_indexes)
         merged_bounds->indexes[pos++] = lfirst_int(lc);
  
     merged_bounds->null_index = null_index;
     merged_bounds->default_index = default_index;
  
     return merged_bounds;
 }

References Assert(), PartitionBoundInfoData::datums, PartitionBoundInfoData::default_index, PartitionBoundInfoData::indexes, PartitionBoundInfoData::interleaved_parts, PartitionBoundInfoData::kind, lappend_int(), lfirst, lfirst_int, list_length(), PartitionBoundInfoData::ndatums, NIL, PartitionBoundInfoData::nindexes, PartitionBoundInfoData::null_index, palloc(), PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, and PartitionBoundInfoData::strategy.

Referenced by merge_list_bounds(), and merge_range_bounds().

◆ 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().

◆ compare_range_partitions()

static bool compare_range_partitions	(	int	partnatts,
		FmgrInfo *	partsupfuncs,
		Oid *	partcollations,
		PartitionRangeBound *	outer_lb,
		PartitionRangeBound *	outer_ub,
		PartitionRangeBound *	inner_lb,
		PartitionRangeBound *	inner_ub,
		int *	lb_cmpval,
		int *	ub_cmpval
	)

static

Definition at line 2663 of file partbounds.c.

 {
     /*
      * Check if the outer partition's upper bound is lower than the inner
      * partition's lower bound; if so the partitions aren't overlapping.
      */
     if (compare_range_bounds(partnatts, partsupfuncs, partcollations,
                              outer_ub, inner_lb) < 0)
     {
         *lb_cmpval = -1;
         *ub_cmpval = -1;
         return false;
     }
  
     /*
      * Check if the outer partition's lower bound is higher than the inner
      * partition's upper bound; if so the partitions aren't overlapping.
      */
     if (compare_range_bounds(partnatts, partsupfuncs, partcollations,
                              outer_lb, inner_ub) > 0)
     {
         *lb_cmpval = 1;
         *ub_cmpval = 1;
         return false;
     }
  
     /* All other cases indicate overlapping partitions. */
     *lb_cmpval = compare_range_bounds(partnatts, partsupfuncs, partcollations,
                                       outer_lb, inner_lb);
     *ub_cmpval = compare_range_bounds(partnatts, partsupfuncs, partcollations,
                                       outer_ub, inner_ub);
     return true;
 }

References compare_range_bounds.

Referenced by merge_range_bounds().

◆ 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().

◆ create_hash_bounds()

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

static

Definition at line 348 of file partbounds.c.

 {
     PartitionBoundInfo boundinfo;
     PartitionHashBound *hbounds;
     int         i;
     int         greatest_modulus;
     Datum      *boundDatums;
  
     boundinfo = (PartitionBoundInfoData *)
         palloc0(sizeof(PartitionBoundInfoData));
     boundinfo->strategy = key->strategy;
     /* No special hash partitions. */
     boundinfo->null_index = -1;
     boundinfo->default_index = -1;
  
     hbounds = (PartitionHashBound *)
         palloc(nparts * sizeof(PartitionHashBound));
  
     /* Convert from node to the internal representation */
     for (i = 0; i < nparts; i++)
     {
         PartitionBoundSpec *spec = boundspecs[i];
  
         if (spec->strategy != PARTITION_STRATEGY_HASH)
             elog(ERROR, "invalid strategy in partition bound spec");
  
         hbounds[i].modulus = spec->modulus;
         hbounds[i].remainder = spec->remainder;
         hbounds[i].index = i;
     }
  
     /* Sort all the bounds in ascending order */
     qsort(hbounds, nparts, sizeof(PartitionHashBound),
           qsort_partition_hbound_cmp);
  
     /* After sorting, moduli are now stored in ascending order. */
     greatest_modulus = hbounds[nparts - 1].modulus;
  
     boundinfo->ndatums = nparts;
     boundinfo->datums = (Datum **) palloc0(nparts * sizeof(Datum *));
     boundinfo->kind = NULL;
     boundinfo->interleaved_parts = NULL;
     boundinfo->nindexes = greatest_modulus;
     boundinfo->indexes = (int *) palloc(greatest_modulus * sizeof(int));
     for (i = 0; i < greatest_modulus; i++)
         boundinfo->indexes[i] = -1;
  
     /*
      * In the loop below, to save from allocating a series of small datum
      * arrays, here we just allocate a single array and below we'll just
      * assign a portion of this array per partition.
      */
     boundDatums = (Datum *) palloc(nparts * 2 * sizeof(Datum));
  
     /*
      * For hash partitioning, there are as many datums (modulus and remainder
      * pairs) as there are partitions.  Indexes are simply values ranging from
      * 0 to (nparts - 1).
      */
     for (i = 0; i < nparts; i++)
     {
         int         modulus = hbounds[i].modulus;
         int         remainder = hbounds[i].remainder;
  
         boundinfo->datums[i] = &boundDatums[i * 2];
         boundinfo->datums[i][0] = Int32GetDatum(modulus);
         boundinfo->datums[i][1] = Int32GetDatum(remainder);
  
         while (remainder < greatest_modulus)
         {
             /* overlap? */
             Assert(boundinfo->indexes[remainder] == -1);
             boundinfo->indexes[remainder] = i;
             remainder += modulus;
         }
  
         (*mapping)[hbounds[i].index] = i;
     }
     pfree(hbounds);
  
     return boundinfo;
 }

Referenced by partition_bounds_create().

◆ create_list_bounds()

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

static

Definition at line 463 of file partbounds.c.

 {
     PartitionBoundInfo boundinfo;
     PartitionListValue *all_values;
     int         i;
     int         j;
     int         ndatums;
     int         next_index = 0;
     int         default_index = -1;
     int         null_index = -1;
     Datum      *boundDatums;
  
     boundinfo = (PartitionBoundInfoData *)
         palloc0(sizeof(PartitionBoundInfoData));
     boundinfo->strategy = key->strategy;
     /* Will be set correctly below. */
     boundinfo->null_index = -1;
     boundinfo->default_index = -1;
  
     ndatums = get_non_null_list_datum_count(boundspecs, nparts);
     all_values = (PartitionListValue *)
         palloc(ndatums * sizeof(PartitionListValue));
  
     /* Create a unified list of non-null values across all partitions. */
     for (j = 0, i = 0; i < nparts; i++)
     {
         PartitionBoundSpec *spec = boundspecs[i];
         ListCell   *c;
  
         if (spec->strategy != PARTITION_STRATEGY_LIST)
             elog(ERROR, "invalid strategy in partition bound spec");
  
         /*
          * Note the index of the partition bound spec for the default
          * partition.  There's no datum to add to the list on non-null datums
          * for this partition.
          */
         if (spec->is_default)
         {
             default_index = i;
             continue;
         }
  
         foreach(c, spec->listdatums)
         {
             Const      *val = lfirst_node(Const, c);
  
             if (!val->constisnull)
             {
                 all_values[j].index = i;
                 all_values[j].value = val->constvalue;
                 j++;
             }
             else
             {
                 /*
                  * Never put a null into the values array; save the index of
                  * the partition that stores nulls, instead.
                  */
                 if (null_index != -1)
                     elog(ERROR, "found null more than once");
                 null_index = i;
             }
         }
     }
  
     /* ensure we found a Datum for every slot in the all_values array */
     Assert(j == ndatums);
  
     qsort_arg(all_values, ndatums, sizeof(PartitionListValue),
               qsort_partition_list_value_cmp, key);
  
     boundinfo->ndatums = ndatums;
     boundinfo->datums = (Datum **) palloc0(ndatums * sizeof(Datum *));
     boundinfo->kind = NULL;
     boundinfo->interleaved_parts = NULL;
     boundinfo->nindexes = ndatums;
     boundinfo->indexes = (int *) palloc(ndatums * sizeof(int));
  
     /*
      * In the loop below, to save from allocating a series of small datum
      * arrays, here we just allocate a single array and below we'll just
      * assign a portion of this array per datum.
      */
     boundDatums = (Datum *) palloc(ndatums * sizeof(Datum));
  
     /*
      * Copy values.  Canonical indexes are values ranging from 0 to (nparts -
      * 1) assigned to each partition such that all datums of a given partition
      * receive the same value. The value for a given partition is the index of
      * that partition's smallest datum in the all_values[] array.
      */
     for (i = 0; i < ndatums; i++)
     {
         int         orig_index = all_values[i].index;
  
         boundinfo->datums[i] = &boundDatums[i];
         boundinfo->datums[i][0] = datumCopy(all_values[i].value,
                                             key->parttypbyval[0],
                                             key->parttyplen[0]);
  
         /* If the old index has no mapping, assign one */
         if ((*mapping)[orig_index] == -1)
             (*mapping)[orig_index] = next_index++;
  
         boundinfo->indexes[i] = (*mapping)[orig_index];
     }
  
     pfree(all_values);
  
     /*
      * Set the canonical value for null_index, if any.
      *
      * It is possible that the null-accepting partition has not been assigned
      * an index yet, which could happen if such partition accepts only null
      * and hence not handled in the above loop which only looked at non-null
      * values.
      */
     if (null_index != -1)
     {
         Assert(null_index >= 0);
         if ((*mapping)[null_index] == -1)
             (*mapping)[null_index] = next_index++;
         boundinfo->null_index = (*mapping)[null_index];
     }
  
     /* Set the canonical value for default_index, if any. */
     if (default_index != -1)
     {
         /*
          * The default partition accepts any value not specified in the lists
          * of other partitions, hence it should not get mapped index while
          * assigning those for non-null datums.
          */
         Assert(default_index >= 0);
         Assert((*mapping)[default_index] == -1);
         (*mapping)[default_index] = next_index++;
         boundinfo->default_index = (*mapping)[default_index];
     }
  
     /*
      * Calculate interleaved partitions.  Here we look for partitions which
      * might be interleaved with other partitions and set a bit in
      * interleaved_parts for any partitions which may be interleaved with
      * another partition.
      */
  
     /*
      * There must be multiple partitions to have any interleaved partitions,
      * otherwise there's nothing to interleave with.
      */
     if (nparts > 1)
     {
         /*
          * Short-circuit check to see if only 1 Datum is allowed per
          * partition.  When this is true there's no need to do the more
          * expensive checks to look for interleaved values.
          */
         if (boundinfo->ndatums +
             partition_bound_accepts_nulls(boundinfo) +
             partition_bound_has_default(boundinfo) != nparts)
         {
             int         last_index = -1;
  
             /*
              * Since the indexes array is sorted in Datum order, if any
              * partitions are interleaved then it will show up by the
              * partition indexes not being in ascending order.  Here we check
              * for that and record all partitions that are out of order.
              */
             for (i = 0; i < boundinfo->nindexes; i++)
             {
                 int         index = boundinfo->indexes[i];
  
                 if (index < last_index)
                     boundinfo->interleaved_parts = bms_add_member(boundinfo->interleaved_parts,
                                                                   index);
  
                 /*
                  * Otherwise, if the null_index exists in the indexes array,
                  * then the NULL partition must also allow some other Datum,
                  * therefore it's "interleaved".
                  */
                 else if (partition_bound_accepts_nulls(boundinfo) &&
                          index == boundinfo->null_index)
                     boundinfo->interleaved_parts = bms_add_member(boundinfo->interleaved_parts,
                                                                   index);
  
                 last_index = index;
             }
         }
  
         /*
          * The DEFAULT partition is the "catch-all" partition that can contain
          * anything that does not belong to any other partition.  If there are
          * any other partitions then the DEFAULT partition must be marked as
          * interleaved.
          */
         if (partition_bound_has_default(boundinfo))
             boundinfo->interleaved_parts = bms_add_member(boundinfo->interleaved_parts,
                                                           boundinfo->default_index);
     }
  
  
     /* All partitions must now have been assigned canonical indexes. */
     Assert(next_index == nparts);
     return boundinfo;
 }

Referenced by partition_bounds_create().

◆ create_range_bounds()

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

static

Definition at line 678 of file partbounds.c.

 {
     PartitionBoundInfo boundinfo;
     PartitionRangeBound **rbounds = NULL;
     PartitionRangeBound **all_bounds,
                *prev;
     int         i,
                 k,
                 partnatts;
     int         ndatums = 0;
     int         default_index = -1;
     int         next_index = 0;
     Datum      *boundDatums;
     PartitionRangeDatumKind *boundKinds;
  
     boundinfo = (PartitionBoundInfoData *)
         palloc0(sizeof(PartitionBoundInfoData));
     boundinfo->strategy = key->strategy;
     /* There is no special null-accepting range partition. */
     boundinfo->null_index = -1;
     /* Will be set correctly below. */
     boundinfo->default_index = -1;
  
     all_bounds = (PartitionRangeBound **)
         palloc0(2 * nparts * sizeof(PartitionRangeBound *));
  
     /* Create a unified list of range bounds across all the partitions. */
     ndatums = 0;
     for (i = 0; i < nparts; i++)
     {
         PartitionBoundSpec *spec = boundspecs[i];
         PartitionRangeBound *lower,
                    *upper;
  
         if (spec->strategy != PARTITION_STRATEGY_RANGE)
             elog(ERROR, "invalid strategy in partition bound spec");
  
         /*
          * Note the index of the partition bound spec for the default
          * partition.  There's no datum to add to the all_bounds array for
          * this partition.
          */
         if (spec->is_default)
         {
             default_index = i;
             continue;
         }
  
         lower = make_one_partition_rbound(key, i, spec->lowerdatums, true);
         upper = make_one_partition_rbound(key, i, spec->upperdatums, false);
         all_bounds[ndatums++] = lower;
         all_bounds[ndatums++] = upper;
     }
  
     Assert(ndatums == nparts * 2 ||
            (default_index != -1 && ndatums == (nparts - 1) * 2));
  
     /* Sort all the bounds in ascending order */
     qsort_arg(all_bounds, ndatums,
               sizeof(PartitionRangeBound *),
               qsort_partition_rbound_cmp,
               key);
  
     /* Save distinct bounds from all_bounds into rbounds. */
     rbounds = (PartitionRangeBound **)
         palloc(ndatums * sizeof(PartitionRangeBound *));
     k = 0;
     prev = NULL;
     for (i = 0; i < ndatums; i++)
     {
         PartitionRangeBound *cur = all_bounds[i];
         bool        is_distinct = false;
         int         j;
  
         /* Is the current bound distinct from the previous one? */
         for (j = 0; j < key->partnatts; j++)
         {
             Datum       cmpval;
  
             if (prev == NULL || cur->kind[j] != prev->kind[j])
             {
                 is_distinct = true;
                 break;
             }
  
             /*
              * If the bounds are both MINVALUE or MAXVALUE, stop now and treat
              * them as equal, since any values after this point must be
              * ignored.
              */
             if (cur->kind[j] != PARTITION_RANGE_DATUM_VALUE)
                 break;
  
             cmpval = FunctionCall2Coll(&key->partsupfunc[j],
                                        key->partcollation[j],
                                        cur->datums[j],
                                        prev->datums[j]);
             if (DatumGetInt32(cmpval) != 0)
             {
                 is_distinct = true;
                 break;
             }
         }
  
         /*
          * Only if the bound is distinct save it into a temporary array, i.e,
          * rbounds which is later copied into boundinfo datums array.
          */
         if (is_distinct)
             rbounds[k++] = all_bounds[i];
  
         prev = cur;
     }
  
     pfree(all_bounds);
  
     /* Update ndatums to hold the count of distinct datums. */
     ndatums = k;
  
     /*
      * Add datums to boundinfo.  Canonical indexes are values ranging from 0
      * to nparts - 1, assigned in that order to each partition's upper bound.
      * For 'datums' elements that are lower bounds, there is -1 in the
      * 'indexes' array to signify that no partition exists for the values less
      * than such a bound and greater than or equal to the previous upper
      * bound.
      */
     boundinfo->ndatums = ndatums;
     boundinfo->datums = (Datum **) palloc0(ndatums * sizeof(Datum *));
     boundinfo->kind = (PartitionRangeDatumKind **)
         palloc(ndatums *
                sizeof(PartitionRangeDatumKind *));
     boundinfo->interleaved_parts = NULL;
  
     /*
      * For range partitioning, an additional value of -1 is stored as the last
      * element of the indexes[] array.
      */
     boundinfo->nindexes = ndatums + 1;
     boundinfo->indexes = (int *) palloc((ndatums + 1) * sizeof(int));
  
     /*
      * In the loop below, to save from allocating a series of small arrays,
      * here we just allocate a single array for Datums and another for
      * PartitionRangeDatumKinds, below we'll just assign a portion of these
      * arrays in each loop.
      */
     partnatts = key->partnatts;
     boundDatums = (Datum *) palloc(ndatums * partnatts * sizeof(Datum));
     boundKinds = (PartitionRangeDatumKind *) palloc(ndatums * partnatts *
                                                     sizeof(PartitionRangeDatumKind));
  
     for (i = 0; i < ndatums; i++)
     {
         int         j;
  
         boundinfo->datums[i] = &boundDatums[i * partnatts];
         boundinfo->kind[i] = &boundKinds[i * partnatts];
         for (j = 0; j < partnatts; j++)
         {
             if (rbounds[i]->kind[j] == PARTITION_RANGE_DATUM_VALUE)
                 boundinfo->datums[i][j] =
                     datumCopy(rbounds[i]->datums[j],
                               key->parttypbyval[j],
                               key->parttyplen[j]);
             boundinfo->kind[i][j] = rbounds[i]->kind[j];
         }
  
         /*
          * There is no mapping for invalid indexes.
          *
          * Any lower bounds in the rbounds array have invalid indexes
          * assigned, because the values between the previous bound (if there
          * is one) and this (lower) bound are not part of the range of any
          * existing partition.
          */
         if (rbounds[i]->lower)
             boundinfo->indexes[i] = -1;
         else
         {
             int         orig_index = rbounds[i]->index;
  
             /* If the old index has no mapping, assign one */
             if ((*mapping)[orig_index] == -1)
                 (*mapping)[orig_index] = next_index++;
  
             boundinfo->indexes[i] = (*mapping)[orig_index];
         }
     }
  
     pfree(rbounds);
  
     /* Set the canonical value for default_index, if any. */
     if (default_index != -1)
     {
         Assert(default_index >= 0 && (*mapping)[default_index] == -1);
         (*mapping)[default_index] = next_index++;
         boundinfo->default_index = (*mapping)[default_index];
     }
  
     /* The extra -1 element. */
     Assert(i == ndatums);
     boundinfo->indexes[i] = -1;
  
     /* All partitions must now have been assigned canonical indexes. */
     Assert(next_index == nparts);
     return boundinfo;
 }

Referenced by partition_bounds_create().

◆ fix_merged_indexes()

static void fix_merged_indexes	(	PartitionMap *	outer_map,
		PartitionMap *	inner_map,
		int	nmerged,
		List *	merged_indexes
	)

static

Definition at line 2386 of file partbounds.c.

 {
     int        *new_indexes;
     int         merged_index;
     int         i;
     ListCell   *lc;
  
     Assert(nmerged > 0);
  
     new_indexes = (int *) palloc(sizeof(int) * nmerged);
     for (i = 0; i < nmerged; i++)
         new_indexes[i] = -1;
  
     /* Build the mapping of old merged indexes to new merged indexes. */
     if (outer_map->did_remapping)
     {
         for (i = 0; i < outer_map->nparts; i++)
         {
             merged_index = outer_map->old_indexes[i];
             if (merged_index >= 0)
                 new_indexes[merged_index] = outer_map->merged_indexes[i];
         }
     }
     if (inner_map->did_remapping)
     {
         for (i = 0; i < inner_map->nparts; i++)
         {
             merged_index = inner_map->old_indexes[i];
             if (merged_index >= 0)
                 new_indexes[merged_index] = inner_map->merged_indexes[i];
         }
     }
  
     /* Fix the merged_indexes list using the mapping. */
     foreach(lc, merged_indexes)
     {
         merged_index = lfirst_int(lc);
         Assert(merged_index >= 0);
         if (new_indexes[merged_index] >= 0)
             lfirst_int(lc) = new_indexes[merged_index];
     }
  
     pfree(new_indexes);
 }

References Assert(), PartitionMap::did_remapping, i, lfirst_int, PartitionMap::merged_indexes, PartitionMap::nparts, PartitionMap::old_indexes, palloc(), and pfree().

Referenced by merge_list_bounds().

◆ free_partition_map()

static void free_partition_map ( PartitionMap * map )

static

Definition at line 1833 of file partbounds.c.

 {
     pfree(map->merged_indexes);
     pfree(map->merged);
     pfree(map->old_indexes);
 }

References PartitionMap::merged, PartitionMap::merged_indexes, PartitionMap::old_indexes, and pfree().

Referenced by merge_list_bounds(), and merge_range_bounds().

◆ generate_matching_part_pairs()

static void generate_matching_part_pairs	(	RelOptInfo *	outer_rel,
		RelOptInfo *	inner_rel,
		PartitionMap *	outer_map,
		PartitionMap *	inner_map,
		int	nmerged,
		List **	outer_parts,
		List **	inner_parts
	)

static

Definition at line 2440 of file partbounds.c.

 {
     int         outer_nparts = outer_map->nparts;
     int         inner_nparts = inner_map->nparts;
     int        *outer_indexes;
     int        *inner_indexes;
     int         max_nparts;
     int         i;
  
     Assert(nmerged > 0);
     Assert(*outer_parts == NIL);
     Assert(*inner_parts == NIL);
  
     outer_indexes = (int *) palloc(sizeof(int) * nmerged);
     inner_indexes = (int *) palloc(sizeof(int) * nmerged);
     for (i = 0; i < nmerged; i++)
         outer_indexes[i] = inner_indexes[i] = -1;
  
     /* Set pairs of matching partitions. */
     Assert(outer_nparts == outer_rel->nparts);
     Assert(inner_nparts == inner_rel->nparts);
     max_nparts = Max(outer_nparts, inner_nparts);
     for (i = 0; i < max_nparts; i++)
     {
         if (i < outer_nparts)
         {
             int         merged_index = outer_map->merged_indexes[i];
  
             if (merged_index >= 0)
             {
                 Assert(merged_index < nmerged);
                 outer_indexes[merged_index] = i;
             }
         }
         if (i < inner_nparts)
         {
             int         merged_index = inner_map->merged_indexes[i];
  
             if (merged_index >= 0)
             {
                 Assert(merged_index < nmerged);
                 inner_indexes[merged_index] = i;
             }
         }
     }
  
     /* Build the list pairs. */
     for (i = 0; i < nmerged; i++)
     {
         int         outer_index = outer_indexes[i];
         int         inner_index = inner_indexes[i];
  
         /*
          * If both partitions are dummy, it means the merged partition that
          * had been assigned to the outer/inner partition was removed when
          * re-merging the outer/inner partition in
          * merge_matching_partitions(); ignore the merged partition.
          */
         if (outer_index == -1 && inner_index == -1)
             continue;
  
         *outer_parts = lappend(*outer_parts, outer_index >= 0 ?
                                outer_rel->part_rels[outer_index] : NULL);
         *inner_parts = lappend(*inner_parts, inner_index >= 0 ?
                                inner_rel->part_rels[inner_index] : NULL);
     }
  
     pfree(outer_indexes);
     pfree(inner_indexes);
 }

References Assert(), i, lappend(), Max, PartitionMap::merged_indexes, NIL, PartitionMap::nparts, RelOptInfo::nparts, palloc(), and pfree().

Referenced by merge_list_bounds(), and merge_range_bounds().

◆ 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_merged_range_bounds()

static void get_merged_range_bounds	(	int	partnatts,
		FmgrInfo *	partsupfuncs,
		Oid *	partcollations,
		JoinType	jointype,
		PartitionRangeBound *	outer_lb,
		PartitionRangeBound *	outer_ub,
		PartitionRangeBound *	inner_lb,
		PartitionRangeBound *	inner_ub,
		int	lb_cmpval,
		int	ub_cmpval,
		PartitionRangeBound *	merged_lb,
		PartitionRangeBound *	merged_ub
	)

static

Definition at line 2712 of file partbounds.c.

 {
     Assert(compare_range_bounds(partnatts, partsupfuncs, partcollations,
                                 outer_lb, inner_lb) == lb_cmpval);
     Assert(compare_range_bounds(partnatts, partsupfuncs, partcollations,
                                 outer_ub, inner_ub) == ub_cmpval);
  
     switch (jointype)
     {
         case JOIN_INNER:
         case JOIN_SEMI:
  
             /*
              * An INNER/SEMI join will have the rows that fit both sides, so
              * the lower bound of the merged partition will be the higher of
              * the two lower bounds, and the upper bound of the merged
              * partition will be the lower of the two upper bounds.
              */
             *merged_lb = (lb_cmpval > 0) ? *outer_lb : *inner_lb;
             *merged_ub = (ub_cmpval < 0) ? *outer_ub : *inner_ub;
             break;
  
         case JOIN_LEFT:
         case JOIN_ANTI:
  
             /*
              * A LEFT/ANTI join will have all the rows from the outer side, so
              * the bounds of the merged partition will be the same as the
              * outer bounds.
              */
             *merged_lb = *outer_lb;
             *merged_ub = *outer_ub;
             break;
  
         case JOIN_FULL:
  
             /*
              * A FULL join will have all the rows from both sides, so the
              * lower bound of the merged partition will be the lower of the
              * two lower bounds, and the upper bound of the merged partition
              * will be the higher of the two upper bounds.
              */
             *merged_lb = (lb_cmpval < 0) ? *outer_lb : *inner_lb;
             *merged_ub = (ub_cmpval > 0) ? *outer_ub : *inner_ub;
             break;
  
         default:
             elog(ERROR, "unrecognized join type: %d", (int) jointype);
     }
 }

References Assert(), compare_range_bounds, elog(), ERROR, JOIN_ANTI, JOIN_FULL, JOIN_INNER, JOIN_LEFT, and JOIN_SEMI.

Referenced by merge_range_bounds().

◆ get_non_null_list_datum_count()

static int get_non_null_list_datum_count	(	PartitionBoundSpec **	boundspecs,
		int	nparts
	)

static

Definition at line 437 of file partbounds.c.

 {
     int         i;
     int         count = 0;
  
     for (i = 0; i < nparts; i++)
     {
         ListCell   *lc;
  
         foreach(lc, boundspecs[i]->listdatums)
         {
             Const      *val = lfirst_node(Const, lc);
  
             if (!val->constisnull)
                 count++;
         }
     }
  
     return count;
 }

References i, lfirst_node, and val.

Referenced by create_list_bounds().

◆ get_partition_operator()

static Oid get_partition_operator	(	PartitionKey	key,
		int	col,
		StrategyNumber	strategy,
		bool *	need_relabel
	)

static

Definition at line 3833 of file partbounds.c.

 {
     Oid         operoid;
  
     /*
      * Get the operator in the partitioning opfamily using the opclass'
      * declared input type as both left- and righttype.
      */
     operoid = get_opfamily_member(key->partopfamily[col],
                                   key->partopcintype[col],
                                   key->partopcintype[col],
                                   strategy);
     if (!OidIsValid(operoid))
         elog(ERROR, "missing operator %d(%u,%u) in partition opfamily %u",
              strategy, key->partopcintype[col], key->partopcintype[col],
              key->partopfamily[col]);
  
     /*
      * If the partition key column is not of the same type as the operator
      * class and not polymorphic, tell caller to wrap the non-Const expression
      * in a RelabelType.  This matches what parse_coerce.c does.
      */
     *need_relabel = (key->parttypid[col] != key->partopcintype[col] &&
                      key->partopcintype[col] != RECORDOID &&
                      !IsPolymorphicType(key->partopcintype[col]));
  
     return operoid;
 }

References elog(), ERROR, get_opfamily_member(), sort-test::key, and OidIsValid.

Referenced by make_partition_op_expr().

◆ get_qual_for_hash()

static List * get_qual_for_hash	(	Relation	parent,
		PartitionBoundSpec *	spec
	)

static

Definition at line 3984 of file partbounds.c.

 {
     PartitionKey key = RelationGetPartitionKey(parent);
     FuncExpr   *fexpr;
     Node       *relidConst;
     Node       *modulusConst;
     Node       *remainderConst;
     List       *args;
     ListCell   *partexprs_item;
     int         i;
  
     /* Fixed arguments. */
     relidConst = (Node *) makeConst(OIDOID,
                                     -1,
                                     InvalidOid,
                                     sizeof(Oid),
                                     ObjectIdGetDatum(RelationGetRelid(parent)),
                                     false,
                                     true);
  
     modulusConst = (Node *) makeConst(INT4OID,
                                       -1,
                                       InvalidOid,
                                       sizeof(int32),
                                       Int32GetDatum(spec->modulus),
                                       false,
                                       true);
  
     remainderConst = (Node *) makeConst(INT4OID,
                                         -1,
                                         InvalidOid,
                                         sizeof(int32),
                                         Int32GetDatum(spec->remainder),
                                         false,
                                         true);
  
     args = list_make3(relidConst, modulusConst, remainderConst);
     partexprs_item = list_head(key->partexprs);
  
     /* Add an argument for each key column. */
     for (i = 0; i < key->partnatts; i++)
     {
         Node       *keyCol;
  
         /* Left operand */
         if (key->partattrs[i] != 0)
         {
             keyCol = (Node *) makeVar(1,
                                       key->partattrs[i],
                                       key->parttypid[i],
                                       key->parttypmod[i],
                                       key->parttypcoll[i],
                                       0);
         }
         else
         {
             keyCol = (Node *) copyObject(lfirst(partexprs_item));
             partexprs_item = lnext(key->partexprs, partexprs_item);
         }
  
         args = lappend(args, keyCol);
     }
  
     fexpr = makeFuncExpr(F_SATISFIES_HASH_PARTITION,
                          BOOLOID,
                          args,
                          InvalidOid,
                          InvalidOid,
                          COERCE_EXPLICIT_CALL);
  
     return list_make1(fexpr);
 }

References generate_unaccent_rules::args, COERCE_EXPLICIT_CALL, copyObject, i, Int32GetDatum(), InvalidOid, sort-test::key, lappend(), lfirst, list_head(), list_make1, list_make3, lnext(), makeConst(), makeFuncExpr(), makeVar(), PartitionBoundSpec::modulus, ObjectIdGetDatum(), RelationGetPartitionKey(), RelationGetRelid, and PartitionBoundSpec::remainder.

Referenced by get_qual_from_partbound().

◆ get_qual_for_list()

static List * get_qual_for_list	(	Relation	parent,
		PartitionBoundSpec *	spec
	)

static

Definition at line 4067 of file partbounds.c.

 {
     PartitionKey key = RelationGetPartitionKey(parent);
     List       *result;
     Expr       *keyCol;
     Expr       *opexpr;
     NullTest   *nulltest;
     ListCell   *cell;
     List       *elems = NIL;
     bool        list_has_null = false;
  
     /*
      * Only single-column list partitioning is supported, so we are worried
      * only about the partition key with index 0.
      */
     Assert(key->partnatts == 1);
  
     /* Construct Var or expression representing the partition column */
     if (key->partattrs[0] != 0)
         keyCol = (Expr *) makeVar(1,
                                   key->partattrs[0],
                                   key->parttypid[0],
                                   key->parttypmod[0],
                                   key->parttypcoll[0],
                                   0);
     else
         keyCol = (Expr *) copyObject(linitial(key->partexprs));
  
     /*
      * For default list partition, collect datums for all the partitions. The
      * default partition constraint should check that the partition key is
      * equal to none of those.
      */
     if (spec->is_default)
     {
         int         i;
         int         ndatums = 0;
         PartitionDesc pdesc = RelationGetPartitionDesc(parent, false);
         PartitionBoundInfo boundinfo = pdesc->boundinfo;
  
         if (boundinfo)
         {
             ndatums = boundinfo->ndatums;
  
             if (partition_bound_accepts_nulls(boundinfo))
                 list_has_null = true;
         }
  
         /*
          * If default is the only partition, there need not be any partition
          * constraint on it.
          */
         if (ndatums == 0 && !list_has_null)
             return NIL;
  
         for (i = 0; i < ndatums; i++)
         {
             Const      *val;
  
             /*
              * Construct Const from known-not-null datum.  We must be careful
              * to copy the value, because our result has to be able to outlive
              * the relcache entry we're copying from.
              */
             val = makeConst(key->parttypid[0],
                             key->parttypmod[0],
                             key->parttypcoll[0],
                             key->parttyplen[0],
                             datumCopy(*boundinfo->datums[i],
                                       key->parttypbyval[0],
                                       key->parttyplen[0]),
                             false,  /* isnull */
                             key->parttypbyval[0]);
  
             elems = lappend(elems, val);
         }
     }
     else
     {
         /*
          * Create list of Consts for the allowed values, excluding any nulls.
          */
         foreach(cell, spec->listdatums)
         {
             Const      *val = lfirst_node(Const, cell);
  
             if (val->constisnull)
                 list_has_null = true;
             else
                 elems = lappend(elems, copyObject(val));
         }
     }
  
     if (elems)
     {
         /*
          * Generate the operator expression from the non-null partition
          * values.
          */
         opexpr = make_partition_op_expr(key, 0, BTEqualStrategyNumber,
                                         keyCol, (Expr *) elems);
     }
     else
     {
         /*
          * If there are no partition values, we don't need an operator
          * expression.
          */
         opexpr = NULL;
     }
  
     if (!list_has_null)
     {
         /*
          * Gin up a "col IS NOT NULL" test that will be ANDed with the main
          * expression.  This might seem redundant, but the partition routing
          * machinery needs it.
          */
         nulltest = makeNode(NullTest);
         nulltest->arg = keyCol;
         nulltest->nulltesttype = IS_NOT_NULL;
         nulltest->argisrow = false;
         nulltest->location = -1;
  
         result = opexpr ? list_make2(nulltest, opexpr) : list_make1(nulltest);
     }
     else
     {
         /*
          * Gin up a "col IS NULL" test that will be OR'd with the main
          * expression.
          */
         nulltest = makeNode(NullTest);
         nulltest->arg = keyCol;
         nulltest->nulltesttype = IS_NULL;
         nulltest->argisrow = false;
         nulltest->location = -1;
  
         if (opexpr)
         {
             Expr       *or;
  
             or = makeBoolExpr(OR_EXPR, list_make2(nulltest, opexpr), -1);
             result = list_make1(or);
         }
         else
             result = list_make1(nulltest);
     }
  
     /*
      * Note that, in general, applying NOT to a constraint expression doesn't
      * necessarily invert the set of rows it accepts, because NOT (NULL) is
      * NULL.  However, the partition constraints we construct here never
      * evaluate to NULL, so applying NOT works as intended.
      */
     if (spec->is_default)
     {
         result = list_make1(make_ands_explicit(result));
         result = list_make1(makeBoolExpr(NOT_EXPR, result, -1));
     }
  
     return result;
 }

References NullTest::arg, Assert(), PartitionDescData::boundinfo, BTEqualStrategyNumber, copyObject, datumCopy(), PartitionBoundInfoData::datums, i, PartitionBoundSpec::is_default, IS_NOT_NULL, IS_NULL, sort-test::key, lappend(), lfirst_node, linitial, list_make1, list_make2, PartitionBoundSpec::listdatums, NullTest::location, make_ands_explicit(), make_partition_op_expr(), makeBoolExpr(), makeConst(), makeNode, makeVar(), PartitionBoundInfoData::ndatums, NIL, NOT_EXPR, NullTest::nulltesttype, OR_EXPR, partition_bound_accepts_nulls, RelationGetPartitionDesc(), RelationGetPartitionKey(), and val.

Referenced by check_default_partition_contents(), and get_qual_from_partbound().

◆ get_qual_for_range()

static List * get_qual_for_range	(	Relation	parent,
		PartitionBoundSpec *	spec,
		bool	for_default
	)

static

Definition at line 4276 of file partbounds.c.

 {
     List       *result = NIL;
     ListCell   *cell1,
                *cell2,
                *partexprs_item,
                *partexprs_item_saved;
     int         i,
                 j;
     PartitionRangeDatum *ldatum,
                *udatum;
     PartitionKey key = RelationGetPartitionKey(parent);
     Expr       *keyCol;
     Const      *lower_val,
                *upper_val;
     List       *lower_or_arms,
                *upper_or_arms;
     int         num_or_arms,
                 current_or_arm;
     ListCell   *lower_or_start_datum,
                *upper_or_start_datum;
     bool        need_next_lower_arm,
                 need_next_upper_arm;
  
     if (spec->is_default)
     {
         List       *or_expr_args = NIL;
         PartitionDesc pdesc = RelationGetPartitionDesc(parent, false);
         Oid        *inhoids = pdesc->oids;
         int         nparts = pdesc->nparts,
                     k;
  
         for (k = 0; k < nparts; k++)
         {
             Oid         inhrelid = inhoids[k];
             HeapTuple   tuple;
             Datum       datum;
             PartitionBoundSpec *bspec;
  
             tuple = SearchSysCache1(RELOID, ObjectIdGetDatum(inhrelid));
             if (!HeapTupleIsValid(tuple))
                 elog(ERROR, "cache lookup failed for relation %u", inhrelid);
  
             datum = SysCacheGetAttrNotNull(RELOID, tuple,
                                            Anum_pg_class_relpartbound);
             bspec = (PartitionBoundSpec *)
                 stringToNode(TextDatumGetCString(datum));
             if (!IsA(bspec, PartitionBoundSpec))
                 elog(ERROR, "expected PartitionBoundSpec");
  
             if (!bspec->is_default)
             {
                 List       *part_qual;
  
                 part_qual = get_qual_for_range(parent, bspec, true);
  
                 /*
                  * AND the constraints of the partition and add to
                  * or_expr_args
                  */
                 or_expr_args = lappend(or_expr_args, list_length(part_qual) > 1
                                        ? makeBoolExpr(AND_EXPR, part_qual, -1)
                                        : linitial(part_qual));
             }
             ReleaseSysCache(tuple);
         }
  
         if (or_expr_args != NIL)
         {
             Expr       *other_parts_constr;
  
             /*
              * Combine the constraints obtained for non-default partitions
              * using OR.  As requested, each of the OR's args doesn't include
              * the NOT NULL test for partition keys (which is to avoid its
              * useless repetition).  Add the same now.
              */
             other_parts_constr =
                 makeBoolExpr(AND_EXPR,
                              lappend(get_range_nulltest(key),
                                      list_length(or_expr_args) > 1
                                      ? makeBoolExpr(OR_EXPR, or_expr_args,
                                                     -1)
                                      : linitial(or_expr_args)),
                              -1);
  
             /*
              * Finally, the default partition contains everything *NOT*
              * contained in the non-default partitions.
              */
             result = list_make1(makeBoolExpr(NOT_EXPR,
                                              list_make1(other_parts_constr), -1));
         }
  
         return result;
     }
  
     /*
      * If it is the recursive call for default, we skip the get_range_nulltest
      * to avoid accumulating the NullTest on the same keys for each partition.
      */
     if (!for_default)
         result = get_range_nulltest(key);
  
     /*
      * Iterate over the key columns and check if the corresponding lower and
      * upper datums are equal using the btree equality operator for the
      * column's type.  If equal, we emit single keyCol = common_value
      * expression.  Starting from the first column for which the corresponding
      * lower and upper bound datums are not equal, we generate OR expressions
      * as shown in the function's header comment.
      */
     i = 0;
     partexprs_item = list_head(key->partexprs);
     partexprs_item_saved = partexprs_item;  /* placate compiler */
     forboth(cell1, spec->lowerdatums, cell2, spec->upperdatums)
     {
         EState     *estate;
         MemoryContext oldcxt;
         Expr       *test_expr;
         ExprState  *test_exprstate;
         Datum       test_result;
         bool        isNull;
  
         ldatum = lfirst_node(PartitionRangeDatum, cell1);
         udatum = lfirst_node(PartitionRangeDatum, cell2);
  
         /*
          * Since get_range_key_properties() modifies partexprs_item, and we
          * might need to start over from the previous expression in the later
          * part of this function, save away the current value.
          */
         partexprs_item_saved = partexprs_item;
  
         get_range_key_properties(key, i, ldatum, udatum,
                                  &partexprs_item,
                                  &keyCol,
                                  &lower_val, &upper_val);
  
         /*
          * If either value is NULL, the corresponding partition bound is
          * either MINVALUE or MAXVALUE, and we treat them as unequal, because
          * even if they're the same, there is no common value to equate the
          * key column with.
          */
         if (!lower_val || !upper_val)
             break;
  
         /* Create the test expression */
         estate = CreateExecutorState();
         oldcxt = MemoryContextSwitchTo(estate->es_query_cxt);
         test_expr = make_partition_op_expr(key, i, BTEqualStrategyNumber,
                                            (Expr *) lower_val,
                                            (Expr *) upper_val);
         fix_opfuncids((Node *) test_expr);
         test_exprstate = ExecInitExpr(test_expr, NULL);
         test_result = ExecEvalExprSwitchContext(test_exprstate,
                                                 GetPerTupleExprContext(estate),
                                                 &isNull);
         MemoryContextSwitchTo(oldcxt);
         FreeExecutorState(estate);
  
         /* If not equal, go generate the OR expressions */
         if (!DatumGetBool(test_result))
             break;
  
         /*
          * The bounds for the last key column can't be equal, because such a
          * range partition would never be allowed to be defined (it would have
          * an empty range otherwise).
          */
         if (i == key->partnatts - 1)
             elog(ERROR, "invalid range bound specification");
  
         /* Equal, so generate keyCol = lower_val expression */
         result = lappend(result,
                          make_partition_op_expr(key, i, BTEqualStrategyNumber,
                                                 keyCol, (Expr *) lower_val));
  
         i++;
     }
  
     /* First pair of lower_val and upper_val that are not equal. */
     lower_or_start_datum = cell1;
     upper_or_start_datum = cell2;
  
     /* OR will have as many arms as there are key columns left. */
     num_or_arms = key->partnatts - i;
     current_or_arm = 0;
     lower_or_arms = upper_or_arms = NIL;
     need_next_lower_arm = need_next_upper_arm = true;
     while (current_or_arm < num_or_arms)
     {
         List       *lower_or_arm_args = NIL,
                    *upper_or_arm_args = NIL;
  
         /* Restart scan of columns from the i'th one */
         j = i;
         partexprs_item = partexprs_item_saved;
  
         for_both_cell(cell1, spec->lowerdatums, lower_or_start_datum,
                       cell2, spec->upperdatums, upper_or_start_datum)
         {
             PartitionRangeDatum *ldatum_next = NULL,
                        *udatum_next = NULL;
  
             ldatum = lfirst_node(PartitionRangeDatum, cell1);
             if (lnext(spec->lowerdatums, cell1))
                 ldatum_next = castNode(PartitionRangeDatum,
                                        lfirst(lnext(spec->lowerdatums, cell1)));
             udatum = lfirst_node(PartitionRangeDatum, cell2);
             if (lnext(spec->upperdatums, cell2))
                 udatum_next = castNode(PartitionRangeDatum,
                                        lfirst(lnext(spec->upperdatums, cell2)));
             get_range_key_properties(key, j, ldatum, udatum,
                                      &partexprs_item,
                                      &keyCol,
                                      &lower_val, &upper_val);
  
             if (need_next_lower_arm && lower_val)
             {
                 uint16      strategy;
  
                 /*
                  * For the non-last columns of this arm, use the EQ operator.
                  * For the last column of this arm, use GT, unless this is the
                  * last column of the whole bound check, or the next bound
                  * datum is MINVALUE, in which case use GE.
                  */
                 if (j - i < current_or_arm)
                     strategy = BTEqualStrategyNumber;
                 else if (j == key->partnatts - 1 ||
                          (ldatum_next &&
                           ldatum_next->kind == PARTITION_RANGE_DATUM_MINVALUE))
                     strategy = BTGreaterEqualStrategyNumber;
                 else
                     strategy = BTGreaterStrategyNumber;
  
                 lower_or_arm_args = lappend(lower_or_arm_args,
                                             make_partition_op_expr(key, j,
                                                                    strategy,
                                                                    keyCol,
                                                                    (Expr *) lower_val));
             }
  
             if (need_next_upper_arm && upper_val)
             {
                 uint16      strategy;
  
                 /*
                  * For the non-last columns of this arm, use the EQ operator.
                  * For the last column of this arm, use LT, unless the next
                  * bound datum is MAXVALUE, in which case use LE.
                  */
                 if (j - i < current_or_arm)
                     strategy = BTEqualStrategyNumber;
                 else if (udatum_next &&
                          udatum_next->kind == PARTITION_RANGE_DATUM_MAXVALUE)
                     strategy = BTLessEqualStrategyNumber;
                 else
                     strategy = BTLessStrategyNumber;
  
                 upper_or_arm_args = lappend(upper_or_arm_args,
                                             make_partition_op_expr(key, j,
                                                                    strategy,
                                                                    keyCol,
                                                                    (Expr *) upper_val));
             }
  
             /*
              * Did we generate enough of OR's arguments?  First arm considers
              * the first of the remaining columns, second arm considers first
              * two of the remaining columns, and so on.
              */
             ++j;
             if (j - i > current_or_arm)
             {
                 /*
                  * We must not emit any more arms if the new column that will
                  * be considered is unbounded, or this one was.
                  */
                 if (!lower_val || !ldatum_next ||
                     ldatum_next->kind != PARTITION_RANGE_DATUM_VALUE)
                     need_next_lower_arm = false;
                 if (!upper_val || !udatum_next ||
                     udatum_next->kind != PARTITION_RANGE_DATUM_VALUE)
                     need_next_upper_arm = false;
                 break;
             }
         }
  
         if (lower_or_arm_args != NIL)
             lower_or_arms = lappend(lower_or_arms,
                                     list_length(lower_or_arm_args) > 1
                                     ? makeBoolExpr(AND_EXPR, lower_or_arm_args, -1)
                                     : linitial(lower_or_arm_args));
  
         if (upper_or_arm_args != NIL)
             upper_or_arms = lappend(upper_or_arms,
                                     list_length(upper_or_arm_args) > 1
                                     ? makeBoolExpr(AND_EXPR, upper_or_arm_args, -1)
                                     : linitial(upper_or_arm_args));
  
         /* If no work to do in the next iteration, break away. */
         if (!need_next_lower_arm && !need_next_upper_arm)
             break;
  
         ++current_or_arm;
     }
  
     /*
      * Generate the OR expressions for each of lower and upper bounds (if
      * required), and append to the list of implicitly ANDed list of
      * expressions.
      */
     if (lower_or_arms != NIL)
         result = lappend(result,
                          list_length(lower_or_arms) > 1
                          ? makeBoolExpr(OR_EXPR, lower_or_arms, -1)
                          : linitial(lower_or_arms));
     if (upper_or_arms != NIL)
         result = lappend(result,
                          list_length(upper_or_arms) > 1
                          ? makeBoolExpr(OR_EXPR, upper_or_arms, -1)
                          : linitial(upper_or_arms));
  
     /*
      * As noted above, for non-default, we return list with constant TRUE. If
      * the result is NIL during the recursive call for default, it implies
      * this is the only other partition which can hold every value of the key
      * except NULL. Hence we return the NullTest result skipped earlier.
      */
     if (result == NIL)
         result = for_default
             ? get_range_nulltest(key)
             : list_make1(makeBoolConst(true, false));
  
     return result;
 }

References AND_EXPR, BTEqualStrategyNumber, BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, castNode, CreateExecutorState(), DatumGetBool(), elog(), ERROR, EState::es_query_cxt, ExecEvalExprSwitchContext(), ExecInitExpr(), fix_opfuncids(), for_both_cell, forboth, FreeExecutorState(), get_range_key_properties(), get_range_nulltest(), GetPerTupleExprContext, HeapTupleIsValid, i, PartitionBoundSpec::is_default, IsA, j, sort-test::key, PartitionRangeDatum::kind, lappend(), lfirst, lfirst_node, linitial, list_head(), list_length(), list_make1, lnext(), PartitionBoundSpec::lowerdatums, make_partition_op_expr(), makeBoolConst(), makeBoolExpr(), MemoryContextSwitchTo(), NIL, NOT_EXPR, PartitionDescData::nparts, ObjectIdGetDatum(), PartitionDescData::oids, OR_EXPR, PARTITION_RANGE_DATUM_MAXVALUE, PARTITION_RANGE_DATUM_MINVALUE, PARTITION_RANGE_DATUM_VALUE, RelationGetPartitionDesc(), RelationGetPartitionKey(), ReleaseSysCache(), RELOID, SearchSysCache1(), stringToNode(), SysCacheGetAttrNotNull(), TextDatumGetCString, and PartitionBoundSpec::upperdatums.

Referenced by check_default_partition_contents(), and get_qual_from_partbound().

◆ 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().

◆ get_range_key_properties()

static void get_range_key_properties	(	PartitionKey	key,
		int	keynum,
		PartitionRangeDatum *	ldatum,
		PartitionRangeDatum *	udatum,
		ListCell **	partexprs_item,
		Expr **	keyCol,
		Const **	lower_val,
		Const **	upper_val
	)

static

Definition at line 4633 of file partbounds.c.

 {
     /* Get partition key expression for this column */
     if (key->partattrs[keynum] != 0)
     {
         *keyCol = (Expr *) makeVar(1,
                                    key->partattrs[keynum],
                                    key->parttypid[keynum],
                                    key->parttypmod[keynum],
                                    key->parttypcoll[keynum],
                                    0);
     }
     else
     {
         if (*partexprs_item == NULL)
             elog(ERROR, "wrong number of partition key expressions");
         *keyCol = copyObject(lfirst(*partexprs_item));
         *partexprs_item = lnext(key->partexprs, *partexprs_item);
     }
  
     /* Get appropriate Const nodes for the bounds */
     if (ldatum->kind == PARTITION_RANGE_DATUM_VALUE)
         *lower_val = castNode(Const, copyObject(ldatum->value));
     else
         *lower_val = NULL;
  
     if (udatum->kind == PARTITION_RANGE_DATUM_VALUE)
         *upper_val = castNode(Const, copyObject(udatum->value));
     else
         *upper_val = NULL;
 }

References castNode, copyObject, elog(), ERROR, sort-test::key, PartitionRangeDatum::kind, lfirst, lnext(), makeVar(), PARTITION_RANGE_DATUM_VALUE, and PartitionRangeDatum::value.

Referenced by get_qual_for_range().

◆ get_range_nulltest()

static List * get_range_nulltest ( PartitionKey key )

static

Definition at line 4677 of file partbounds.c.

 {
     List       *result = NIL;
     NullTest   *nulltest;
     ListCell   *partexprs_item;
     int         i;
  
     partexprs_item = list_head(key->partexprs);
     for (i = 0; i < key->partnatts; i++)
     {
         Expr       *keyCol;
  
         if (key->partattrs[i] != 0)
         {
             keyCol = (Expr *) makeVar(1,
                                       key->partattrs[i],
                                       key->parttypid[i],
                                       key->parttypmod[i],
                                       key->parttypcoll[i],
                                       0);
         }
         else
         {
             if (partexprs_item == NULL)
                 elog(ERROR, "wrong number of partition key expressions");
             keyCol = copyObject(lfirst(partexprs_item));
             partexprs_item = lnext(key->partexprs, partexprs_item);
         }
  
         nulltest = makeNode(NullTest);
         nulltest->arg = keyCol;
         nulltest->nulltesttype = IS_NOT_NULL;
         nulltest->argisrow = false;
         nulltest->location = -1;
         result = lappend(result, nulltest);
     }
  
     return result;
 }

References NullTest::arg, copyObject, elog(), ERROR, i, IS_NOT_NULL, sort-test::key, lappend(), lfirst, list_head(), lnext(), NullTest::location, makeNode, makeVar(), NIL, and NullTest::nulltesttype.

Referenced by get_qual_for_range().

◆ get_range_partition()

static int get_range_partition	(	RelOptInfo *	rel,
		PartitionBoundInfo	bi,
		int *	lb_pos,
		PartitionRangeBound *	lb,
		PartitionRangeBound *	ub
	)

static

Definition at line 2582 of file partbounds.c.

 {
     int         part_index;
  
     Assert(bi->strategy == PARTITION_STRATEGY_RANGE);
  
     do
     {
         part_index = get_range_partition_internal(bi, lb_pos, lb, ub);
         if (part_index == -1)
             return -1;
     } while (is_dummy_partition(rel, part_index));
  
     return part_index;
 }

References Assert(), get_range_partition_internal(), is_dummy_partition(), PARTITION_STRATEGY_RANGE, and PartitionBoundInfoData::strategy.

Referenced by merge_range_bounds().

◆ get_range_partition_internal()

static int get_range_partition_internal	(	PartitionBoundInfo	bi,
		int *	lb_pos,
		PartitionRangeBound *	lb,
		PartitionRangeBound *	ub
	)

static

Definition at line 2603 of file partbounds.c.

 {
     /* Return the index as -1 if we've exhausted all lower bounds. */
     if (*lb_pos >= bi->ndatums)
         return -1;
  
     /* A lower bound should have at least one more bound after it. */
     Assert(*lb_pos + 1 < bi->ndatums);
  
     /* Set the lower bound. */
     lb->index = bi->indexes[*lb_pos];
     lb->datums = bi->datums[*lb_pos];
     lb->kind = bi->kind[*lb_pos];
     lb->lower = true;
     /* Set the upper bound. */
     ub->index = bi->indexes[*lb_pos + 1];
     ub->datums = bi->datums[*lb_pos + 1];
     ub->kind = bi->kind[*lb_pos + 1];
     ub->lower = false;
  
     /* The index assigned to an upper bound should be valid. */
     Assert(ub->index >= 0);
  
     /*
      * Advance the position to the next lower bound.  If there are no bounds
      * left beyond the upper bound, we have reached the last lower bound.
      */
     if (*lb_pos + 2 >= bi->ndatums)
         *lb_pos = bi->ndatums;
     else
     {
         /*
          * If the index assigned to the bound next to the upper bound isn't
          * valid, that is the next lower bound; else, the upper bound is also
          * the lower bound of the next range partition.
          */
         if (bi->indexes[*lb_pos + 2] < 0)
             *lb_pos = *lb_pos + 2;
         else
             *lb_pos = *lb_pos + 1;
     }
  
     return ub->index;
 }

References Assert(), PartitionRangeBound::datums, PartitionBoundInfoData::datums, PartitionRangeBound::index, PartitionBoundInfoData::indexes, PartitionRangeBound::kind, PartitionBoundInfoData::kind, PartitionRangeBound::lower, and PartitionBoundInfoData::ndatums.

Referenced by get_range_partition().

◆ init_partition_map()

static void init_partition_map	(	RelOptInfo *	rel,
		PartitionMap *	map
	)

static

Definition at line 1812 of file partbounds.c.

 {
     int         nparts = rel->nparts;
     int         i;
  
     map->nparts = nparts;
     map->merged_indexes = (int *) palloc(sizeof(int) * nparts);
     map->merged = (bool *) palloc(sizeof(bool) * nparts);
     map->did_remapping = false;
     map->old_indexes = (int *) palloc(sizeof(int) * nparts);
     for (i = 0; i < nparts; i++)
     {
         map->merged_indexes[i] = map->old_indexes[i] = -1;
         map->merged[i] = false;
     }
 }

References PartitionMap::did_remapping, i, PartitionMap::merged, PartitionMap::merged_indexes, PartitionMap::nparts, RelOptInfo::nparts, PartitionMap::old_indexes, and palloc().

Referenced by merge_list_bounds(), and merge_range_bounds().

◆ is_dummy_partition()

static bool is_dummy_partition	(	RelOptInfo *	rel,
		int	part_index
	)

static

Definition at line 1844 of file partbounds.c.

 {
     RelOptInfo *part_rel;
  
     Assert(part_index >= 0);
     part_rel = rel->part_rels[part_index];
     if (part_rel == NULL || IS_DUMMY_REL(part_rel))
         return true;
     return false;
 }

References Assert(), and IS_DUMMY_REL.

Referenced by get_range_partition(), merge_list_bounds(), and merge_range_bounds().

◆ make_one_partition_rbound()

static PartitionRangeBound * make_one_partition_rbound	(	PartitionKey	key,
		int	index,
		List *	datums,
		bool	lower
	)

static

Definition at line 3429 of file partbounds.c.

 {
     PartitionRangeBound *bound;
     ListCell   *lc;
     int         i;
  
     Assert(datums != NIL);
  
     bound = (PartitionRangeBound *) palloc0(sizeof(PartitionRangeBound));
     bound->index = index;
     bound->datums = (Datum *) palloc0(key->partnatts * sizeof(Datum));
     bound->kind = (PartitionRangeDatumKind *) palloc0(key->partnatts *
                                                       sizeof(PartitionRangeDatumKind));
     bound->lower = lower;
  
     i = 0;
     foreach(lc, datums)
     {
         PartitionRangeDatum *datum = lfirst_node(PartitionRangeDatum, lc);
  
         /* What's contained in this range datum? */
         bound->kind[i] = datum->kind;
  
         if (datum->kind == PARTITION_RANGE_DATUM_VALUE)
         {
             Const      *val = castNode(Const, datum->value);
  
             if (val->constisnull)
                 elog(ERROR, "invalid range bound datum");
             bound->datums[i] = val->constvalue;
         }
  
         i++;
     }
  
     return bound;
 }

References Assert(), castNode, PartitionRangeBound::datums, elog(), ERROR, i, PartitionRangeBound::index, sort-test::key, PartitionRangeBound::kind, PartitionRangeDatum::kind, lfirst_node, PartitionRangeBound::lower, lower(), NIL, palloc0(), PARTITION_RANGE_DATUM_VALUE, val, and PartitionRangeDatum::value.

Referenced by check_new_partition_bound(), and create_range_bounds().

◆ make_partition_op_expr()

static Expr * make_partition_op_expr	(	PartitionKey	key,
		int	keynum,
		uint16	strategy,
		Expr *	arg1,
		Expr *	arg2
	)

static

Definition at line 3869 of file partbounds.c.

 {
     Oid         operoid;
     bool        need_relabel = false;
     Expr       *result = NULL;
  
     /* Get the correct btree operator for this partitioning column */
     operoid = get_partition_operator(key, keynum, strategy, &need_relabel);
  
     /*
      * Chosen operator may be such that the non-Const operand needs to be
      * coerced, so apply the same; see the comment in
      * get_partition_operator().
      */
     if (!IsA(arg1, Const) &&
         (need_relabel ||
          key->partcollation[keynum] != key->parttypcoll[keynum]))
         arg1 = (Expr *) makeRelabelType(arg1,
                                         key->partopcintype[keynum],
                                         -1,
                                         key->partcollation[keynum],
                                         COERCE_EXPLICIT_CAST);
  
     /* Generate the actual expression */
     switch (key->strategy)
     {
         case PARTITION_STRATEGY_LIST:
             {
                 List       *elems = (List *) arg2;
                 int         nelems = list_length(elems);
  
                 Assert(nelems >= 1);
                 Assert(keynum == 0);
  
                 if (nelems > 1 &&
                     !type_is_array(key->parttypid[keynum]))
                 {
                     ArrayExpr  *arrexpr;
                     ScalarArrayOpExpr *saopexpr;
  
                     /* Construct an ArrayExpr for the right-hand inputs */
                     arrexpr = makeNode(ArrayExpr);
                     arrexpr->array_typeid =
                         get_array_type(key->parttypid[keynum]);
                     arrexpr->array_collid = key->parttypcoll[keynum];
                     arrexpr->element_typeid = key->parttypid[keynum];
                     arrexpr->elements = elems;
                     arrexpr->multidims = false;
                     arrexpr->location = -1;
  
                     /* Build leftop = ANY (rightop) */
                     saopexpr = makeNode(ScalarArrayOpExpr);
                     saopexpr->opno = operoid;
                     saopexpr->opfuncid = get_opcode(operoid);
                     saopexpr->hashfuncid = InvalidOid;
                     saopexpr->negfuncid = InvalidOid;
                     saopexpr->useOr = true;
                     saopexpr->inputcollid = key->partcollation[keynum];
                     saopexpr->args = list_make2(arg1, arrexpr);
                     saopexpr->location = -1;
  
                     result = (Expr *) saopexpr;
                 }
                 else
                 {
                     List       *elemops = NIL;
                     ListCell   *lc;
  
                     foreach(lc, elems)
                     {
                         Expr       *elem = lfirst(lc),
                                    *elemop;
  
                         elemop = make_opclause(operoid,
                                                BOOLOID,
                                                false,
                                                arg1, elem,
                                                InvalidOid,
                                                key->partcollation[keynum]);
                         elemops = lappend(elemops, elemop);
                     }
  
                     result = nelems > 1 ? makeBoolExpr(OR_EXPR, elemops, -1) : linitial(elemops);
                 }
                 break;
             }
  
         case PARTITION_STRATEGY_RANGE:
             result = make_opclause(operoid,
                                    BOOLOID,
                                    false,
                                    arg1, arg2,
                                    InvalidOid,
                                    key->partcollation[keynum]);
             break;
  
         case PARTITION_STRATEGY_HASH:
             Assert(false);
             break;
     }
  
     return result;
 }

References ScalarArrayOpExpr::args, Assert(), COERCE_EXPLICIT_CAST, ArrayExpr::elements, get_array_type(), get_opcode(), get_partition_operator(), InvalidOid, IsA, sort-test::key, lappend(), lfirst, linitial, list_length(), list_make2, ScalarArrayOpExpr::location, ArrayExpr::location, make_opclause(), makeBoolExpr(), makeNode, makeRelabelType(), NIL, ScalarArrayOpExpr::opno, OR_EXPR, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, type_is_array, and ScalarArrayOpExpr::useOr.

Referenced by get_qual_for_list(), and get_qual_for_range().

◆ merge_default_partitions()

static void merge_default_partitions	(	PartitionMap *	outer_map,
		PartitionMap *	inner_map,
		bool	outer_has_default,
		bool	inner_has_default,
		int	outer_default,
		int	inner_default,
		JoinType	jointype,
		int *	next_index,
		int *	default_index
	)

static

Definition at line 2258 of file partbounds.c.

 {
     int         outer_merged_index = -1;
     int         inner_merged_index = -1;
  
     Assert(outer_has_default || inner_has_default);
  
     /* Get the merged partition indexes for the default partitions. */
     if (outer_has_default)
     {
         Assert(outer_default >= 0 && outer_default < outer_map->nparts);
         outer_merged_index = outer_map->merged_indexes[outer_default];
     }
     if (inner_has_default)
     {
         Assert(inner_default >= 0 && inner_default < inner_map->nparts);
         inner_merged_index = inner_map->merged_indexes[inner_default];
     }
  
     if (outer_has_default && !inner_has_default)
     {
         /*
          * If this is an outer join, the default partition on the outer side
          * has to be scanned all the way anyway; if we have not yet assigned a
          * partition, merge the default partition with a dummy partition on
          * the other side.  The merged partition will act as the default
          * partition of the join relation (see comments in
          * process_inner_partition()).
          */
         if (IS_OUTER_JOIN(jointype))
         {
             Assert(jointype != JOIN_RIGHT);
             if (outer_merged_index == -1)
             {
                 Assert(*default_index == -1);
                 *default_index = merge_partition_with_dummy(outer_map,
                                                             outer_default,
                                                             next_index);
             }
             else
                 Assert(*default_index == outer_merged_index);
         }
         else
             Assert(*default_index == -1);
     }
     else if (!outer_has_default && inner_has_default)
     {
         /*
          * If this is a FULL join, the default partition on the inner side has
          * to be scanned all the way anyway; if we have not yet assigned a
          * partition, merge the default partition with a dummy partition on
          * the other side.  The merged partition will act as the default
          * partition of the join relation (see comments in
          * process_outer_partition()).
          */
         if (jointype == JOIN_FULL)
         {
             if (inner_merged_index == -1)
             {
                 Assert(*default_index == -1);
                 *default_index = merge_partition_with_dummy(inner_map,
                                                             inner_default,
                                                             next_index);
             }
             else
                 Assert(*default_index == inner_merged_index);
         }
         else
             Assert(*default_index == -1);
     }
     else
     {
         Assert(outer_has_default && inner_has_default);
  
         /*
          * The default partitions have to be joined with each other, so merge
          * them.  Note that each of the default partitions isn't merged yet
          * (see, process_outer_partition()/process_inner_partition()), so they
          * should be merged successfully.  The merged partition will act as
          * the default partition of the join relation.
          */
         Assert(outer_merged_index == -1);
         Assert(inner_merged_index == -1);
         Assert(*default_index == -1);
         *default_index = merge_matching_partitions(outer_map,
                                                    inner_map,
                                                    outer_default,
                                                    inner_default,
                                                    next_index);
         Assert(*default_index >= 0);
     }
 }

References Assert(), IS_OUTER_JOIN, JOIN_FULL, JOIN_RIGHT, merge_matching_partitions(), merge_partition_with_dummy(), and PartitionMap::merged_indexes.

Referenced by merge_list_bounds(), and merge_range_bounds().

◆ merge_list_bounds()

static PartitionBoundInfo merge_list_bounds	(	FmgrInfo *	partsupfunc,
		Oid *	partcollation,
		RelOptInfo *	outer_rel,
		RelOptInfo *	inner_rel,
		JoinType	jointype,
		List **	outer_parts,
		List **	inner_parts
	)

static

Definition at line 1199 of file partbounds.c.

 {
     PartitionBoundInfo merged_bounds = NULL;
     PartitionBoundInfo outer_bi = outer_rel->boundinfo;
     PartitionBoundInfo inner_bi = inner_rel->boundinfo;
     bool        outer_has_default = partition_bound_has_default(outer_bi);
     bool        inner_has_default = partition_bound_has_default(inner_bi);
     int         outer_default = outer_bi->default_index;
     int         inner_default = inner_bi->default_index;
     bool        outer_has_null = partition_bound_accepts_nulls(outer_bi);
     bool        inner_has_null = partition_bound_accepts_nulls(inner_bi);
     PartitionMap outer_map;
     PartitionMap inner_map;
     int         outer_pos;
     int         inner_pos;
     int         next_index = 0;
     int         null_index = -1;
     int         default_index = -1;
     List       *merged_datums = NIL;
     List       *merged_indexes = NIL;
  
     Assert(*outer_parts == NIL);
     Assert(*inner_parts == NIL);
     Assert(outer_bi->strategy == inner_bi->strategy &&
            outer_bi->strategy == PARTITION_STRATEGY_LIST);
     /* List partitioning doesn't require kinds. */
     Assert(!outer_bi->kind && !inner_bi->kind);
  
     init_partition_map(outer_rel, &outer_map);
     init_partition_map(inner_rel, &inner_map);
  
     /*
      * If the default partitions (if any) have been proven empty, deem them
      * non-existent.
      */
     if (outer_has_default && is_dummy_partition(outer_rel, outer_default))
         outer_has_default = false;
     if (inner_has_default && is_dummy_partition(inner_rel, inner_default))
         inner_has_default = false;
  
     /*
      * Merge partitions from both sides.  In each iteration we compare a pair
      * of list values, one from each side, and decide whether the
      * corresponding partitions match or not.  If the two values match
      * exactly, move to the next pair of list values, otherwise move to the
      * next list value on the side with a smaller list value.
      */
     outer_pos = inner_pos = 0;
     while (outer_pos < outer_bi->ndatums || inner_pos < inner_bi->ndatums)
     {
         int         outer_index = -1;
         int         inner_index = -1;
         Datum      *outer_datums;
         Datum      *inner_datums;
         int         cmpval;
         Datum      *merged_datum = NULL;
         int         merged_index = -1;
  
         if (outer_pos < outer_bi->ndatums)
         {
             /*
              * If the partition on the outer side has been proven empty,
              * ignore it and move to the next datum on the outer side.
              */
             outer_index = outer_bi->indexes[outer_pos];
             if (is_dummy_partition(outer_rel, outer_index))
             {
                 outer_pos++;
                 continue;
             }
         }
         if (inner_pos < inner_bi->ndatums)
         {
             /*
              * If the partition on the inner side has been proven empty,
              * ignore it and move to the next datum on the inner side.
              */
             inner_index = inner_bi->indexes[inner_pos];
             if (is_dummy_partition(inner_rel, inner_index))
             {
                 inner_pos++;
                 continue;
             }
         }
  
         /* Get the list values. */
         outer_datums = outer_pos < outer_bi->ndatums ?
             outer_bi->datums[outer_pos] : NULL;
         inner_datums = inner_pos < inner_bi->ndatums ?
             inner_bi->datums[inner_pos] : NULL;
  
         /*
          * We run this loop till both sides finish.  This allows us to avoid
          * duplicating code to handle the remaining values on the side which
          * finishes later.  For that we set the comparison parameter cmpval in
          * such a way that it appears as if the side which finishes earlier
          * has an extra value higher than any other value on the unfinished
          * side. That way we advance the values on the unfinished side till
          * all of its values are exhausted.
          */
         if (outer_pos >= outer_bi->ndatums)
             cmpval = 1;
         else if (inner_pos >= inner_bi->ndatums)
             cmpval = -1;
         else
         {
             Assert(outer_datums != NULL && inner_datums != NULL);
             cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[0],
                                                      partcollation[0],
                                                      outer_datums[0],
                                                      inner_datums[0]));
         }
  
         if (cmpval == 0)
         {
             /* Two list values match exactly. */
             Assert(outer_pos < outer_bi->ndatums);
             Assert(inner_pos < inner_bi->ndatums);
             Assert(outer_index >= 0);
             Assert(inner_index >= 0);
  
             /*
              * Try merging both partitions.  If successful, add the list value
              * and index of the merged partition below.
              */
             merged_index = merge_matching_partitions(&outer_map, &inner_map,
                                                      outer_index, inner_index,
                                                      &next_index);
             if (merged_index == -1)
                 goto cleanup;
  
             merged_datum = outer_datums;
  
             /* Move to the next pair of list values. */
             outer_pos++;
             inner_pos++;
         }
         else if (cmpval < 0)
         {
             /* A list value missing from the inner side. */
             Assert(outer_pos < outer_bi->ndatums);
  
             /*
              * If the inner side has the default partition, or this is an
              * outer join, try to assign a merged partition to the outer
              * partition (see process_outer_partition()).  Otherwise, the
              * outer partition will not contribute to the result.
              */
             if (inner_has_default || IS_OUTER_JOIN(jointype))
             {
                 /* Get the outer partition. */
                 outer_index = outer_bi->indexes[outer_pos];
                 Assert(outer_index >= 0);
                 merged_index = process_outer_partition(&outer_map,
                                                        &inner_map,
                                                        outer_has_default,
                                                        inner_has_default,
                                                        outer_index,
                                                        inner_default,
                                                        jointype,
                                                        &next_index,
                                                        &default_index);
                 if (merged_index == -1)
                     goto cleanup;
                 merged_datum = outer_datums;
             }
  
             /* Move to the next list value on the outer side. */
             outer_pos++;
         }
         else
         {
             /* A list value missing from the outer side. */
             Assert(cmpval > 0);
             Assert(inner_pos < inner_bi->ndatums);
  
             /*
              * If the outer side has the default partition, or this is a FULL
              * join, try to assign a merged partition to the inner partition
              * (see process_inner_partition()).  Otherwise, the inner
              * partition will not contribute to the result.
              */
             if (outer_has_default || jointype == JOIN_FULL)
             {
                 /* Get the inner partition. */
                 inner_index = inner_bi->indexes[inner_pos];
                 Assert(inner_index >= 0);
                 merged_index = process_inner_partition(&outer_map,
                                                        &inner_map,
                                                        outer_has_default,
                                                        inner_has_default,
                                                        inner_index,
                                                        outer_default,
                                                        jointype,
                                                        &next_index,
                                                        &default_index);
                 if (merged_index == -1)
                     goto cleanup;
                 merged_datum = inner_datums;
             }
  
             /* Move to the next list value on the inner side. */
             inner_pos++;
         }
  
         /*
          * If we assigned a merged partition, add the list value and index of
          * the merged partition if appropriate.
          */
         if (merged_index >= 0 && merged_index != default_index)
         {
             merged_datums = lappend(merged_datums, merged_datum);
             merged_indexes = lappend_int(merged_indexes, merged_index);
         }
     }
  
     /*
      * If the NULL partitions (if any) have been proven empty, deem them
      * non-existent.
      */
     if (outer_has_null &&
         is_dummy_partition(outer_rel, outer_bi->null_index))
         outer_has_null = false;
     if (inner_has_null &&
         is_dummy_partition(inner_rel, inner_bi->null_index))
         inner_has_null = false;
  
     /* Merge the NULL partitions if any. */
     if (outer_has_null || inner_has_null)
         merge_null_partitions(&outer_map, &inner_map,
                               outer_has_null, inner_has_null,
                               outer_bi->null_index, inner_bi->null_index,
                               jointype, &next_index, &null_index);
     else
         Assert(null_index == -1);
  
     /* Merge the default partitions if any. */
     if (outer_has_default || inner_has_default)
         merge_default_partitions(&outer_map, &inner_map,
                                  outer_has_default, inner_has_default,
                                  outer_default, inner_default,
                                  jointype, &next_index, &default_index);
     else
         Assert(default_index == -1);
  
     /* If we have merged partitions, create the partition bounds. */
     if (next_index > 0)
     {
         /* Fix the merged_indexes list if necessary. */
         if (outer_map.did_remapping || inner_map.did_remapping)
         {
             Assert(jointype == JOIN_FULL);
             fix_merged_indexes(&outer_map, &inner_map,
                                next_index, merged_indexes);
         }
  
         /* Use maps to match partitions from inputs. */
         generate_matching_part_pairs(outer_rel, inner_rel,
                                      &outer_map, &inner_map,
                                      next_index,
                                      outer_parts, inner_parts);
         Assert(*outer_parts != NIL);
         Assert(*inner_parts != NIL);
         Assert(list_length(*outer_parts) == list_length(*inner_parts));
         Assert(list_length(*outer_parts) <= next_index);
  
         /* Make a PartitionBoundInfo struct to return. */
         merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
                                                       merged_datums,
                                                       NIL,
                                                       merged_indexes,
                                                       null_index,
                                                       default_index);
         Assert(merged_bounds);
     }
  
 cleanup:
     /* Free local memory before returning. */
     list_free(merged_datums);
     list_free(merged_indexes);
     free_partition_map(&outer_map);
     free_partition_map(&inner_map);
  
     return merged_bounds;
 }

References Assert(), build_merged_partition_bounds(), cleanup(), DatumGetInt32(), PartitionBoundInfoData::datums, PartitionBoundInfoData::default_index, PartitionMap::did_remapping, fix_merged_indexes(), free_partition_map(), FunctionCall2Coll(), generate_matching_part_pairs(), PartitionBoundInfoData::indexes, init_partition_map(), is_dummy_partition(), IS_OUTER_JOIN, JOIN_FULL, PartitionBoundInfoData::kind, lappend(), lappend_int(), list_free(), list_length(), merge_default_partitions(), merge_matching_partitions(), merge_null_partitions(), PartitionBoundInfoData::ndatums, NIL, PartitionBoundInfoData::null_index, partition_bound_accepts_nulls, partition_bound_has_default, PARTITION_STRATEGY_LIST, process_inner_partition(), process_outer_partition(), and PartitionBoundInfoData::strategy.

Referenced by partition_bounds_merge().

◆ merge_matching_partitions()

static int merge_matching_partitions	(	PartitionMap *	outer_map,
		PartitionMap *	inner_map,
		int	outer_index,
		int	inner_index,
		int *	next_index
	)

static

Definition at line 1863 of file partbounds.c.

 {
     int         outer_merged_index;
     int         inner_merged_index;
     bool        outer_merged;
     bool        inner_merged;
  
     Assert(outer_index >= 0 && outer_index < outer_map->nparts);
     outer_merged_index = outer_map->merged_indexes[outer_index];
     outer_merged = outer_map->merged[outer_index];
     Assert(inner_index >= 0 && inner_index < inner_map->nparts);
     inner_merged_index = inner_map->merged_indexes[inner_index];
     inner_merged = inner_map->merged[inner_index];
  
     /*
      * Handle cases where we have already assigned a merged partition to each
      * of the given partitions.
      */
     if (outer_merged_index >= 0 && inner_merged_index >= 0)
     {
         /*
          * If the merged partitions are the same, no need to do anything;
          * return the index of the merged partitions.  Otherwise, if each of
          * the given partitions has been merged with a dummy partition on the
          * other side, re-map them to either of the two merged partitions.
          * Otherwise, they can't be merged, so return -1.
          */
         if (outer_merged_index == inner_merged_index)
         {
             Assert(outer_merged);
             Assert(inner_merged);
             return outer_merged_index;
         }
         if (!outer_merged && !inner_merged)
         {
             /*
              * This can only happen for a list-partitioning case.  We re-map
              * them to the merged partition with the smaller of the two merged
              * indexes to preserve the property that the canonical order of
              * list partitions is determined by the indexes assigned to the
              * smallest list value of each partition.
              */
             if (outer_merged_index < inner_merged_index)
             {
                 outer_map->merged[outer_index] = true;
                 inner_map->merged_indexes[inner_index] = outer_merged_index;
                 inner_map->merged[inner_index] = true;
                 inner_map->did_remapping = true;
                 inner_map->old_indexes[inner_index] = inner_merged_index;
                 return outer_merged_index;
             }
             else
             {
                 inner_map->merged[inner_index] = true;
                 outer_map->merged_indexes[outer_index] = inner_merged_index;
                 outer_map->merged[outer_index] = true;
                 outer_map->did_remapping = true;
                 outer_map->old_indexes[outer_index] = outer_merged_index;
                 return inner_merged_index;
             }
         }
         return -1;
     }
  
     /* At least one of the given partitions should not have yet been merged. */
     Assert(outer_merged_index == -1 || inner_merged_index == -1);
  
     /*
      * If neither of them has been merged, merge them.  Otherwise, if one has
      * been merged with a dummy partition on the other side (and the other
      * hasn't yet been merged with anything), re-merge them.  Otherwise, they
      * can't be merged, so return -1.
      */
     if (outer_merged_index == -1 && inner_merged_index == -1)
     {
         int         merged_index = *next_index;
  
         Assert(!outer_merged);
         Assert(!inner_merged);
         outer_map->merged_indexes[outer_index] = merged_index;
         outer_map->merged[outer_index] = true;
         inner_map->merged_indexes[inner_index] = merged_index;
         inner_map->merged[inner_index] = true;
         *next_index = *next_index + 1;
         return merged_index;
     }
     if (outer_merged_index >= 0 && !outer_map->merged[outer_index])
     {
         Assert(inner_merged_index == -1);
         Assert(!inner_merged);
         inner_map->merged_indexes[inner_index] = outer_merged_index;
         inner_map->merged[inner_index] = true;
         outer_map->merged[outer_index] = true;
         return outer_merged_index;
     }
     if (inner_merged_index >= 0 && !inner_map->merged[inner_index])
     {
         Assert(outer_merged_index == -1);
         Assert(!outer_merged);
         outer_map->merged_indexes[outer_index] = inner_merged_index;
         outer_map->merged[outer_index] = true;
         inner_map->merged[inner_index] = true;
         return inner_merged_index;
     }
     return -1;
 }

References Assert(), PartitionMap::did_remapping, PartitionMap::merged, PartitionMap::merged_indexes, and PartitionMap::old_indexes.

Referenced by merge_default_partitions(), merge_list_bounds(), merge_null_partitions(), merge_range_bounds(), process_inner_partition(), and process_outer_partition().

◆ merge_null_partitions()

static void merge_null_partitions	(	PartitionMap *	outer_map,
		PartitionMap *	inner_map,
		bool	outer_has_null,
		bool	inner_has_null,
		int	outer_null,
		int	inner_null,
		JoinType	jointype,
		int *	next_index,
		int *	null_index
	)

static

Definition at line 2148 of file partbounds.c.

 {
     bool        consider_outer_null = false;
     bool        consider_inner_null = false;
  
     Assert(outer_has_null || inner_has_null);
     Assert(*null_index == -1);
  
     /*
      * Check whether the NULL partitions have already been merged and if so,
      * set the consider_outer_null/consider_inner_null flags.
      */
     if (outer_has_null)
     {
         Assert(outer_null >= 0 && outer_null < outer_map->nparts);
         if (outer_map->merged_indexes[outer_null] == -1)
             consider_outer_null = true;
     }
     if (inner_has_null)
     {
         Assert(inner_null >= 0 && inner_null < inner_map->nparts);
         if (inner_map->merged_indexes[inner_null] == -1)
             consider_inner_null = true;
     }
  
     /* If both flags are set false, we don't need to do anything. */
     if (!consider_outer_null && !consider_inner_null)
         return;
  
     if (consider_outer_null && !consider_inner_null)
     {
         Assert(outer_has_null);
  
         /*
          * If this is an outer join, the NULL partition on the outer side has
          * to be scanned all the way anyway; merge the NULL partition with a
          * dummy partition on the other side.  In that case
          * consider_outer_null means that the NULL partition only contains
          * NULL values as the key values, so the merged partition will do so;
          * treat it as the NULL partition of the join relation.
          */
         if (IS_OUTER_JOIN(jointype))
         {
             Assert(jointype != JOIN_RIGHT);
             *null_index = merge_partition_with_dummy(outer_map, outer_null,
                                                      next_index);
         }
     }
     else if (!consider_outer_null && consider_inner_null)
     {
         Assert(inner_has_null);
  
         /*
          * If this is a FULL join, the NULL partition on the inner side has to
          * be scanned all the way anyway; merge the NULL partition with a
          * dummy partition on the other side.  In that case
          * consider_inner_null means that the NULL partition only contains
          * NULL values as the key values, so the merged partition will do so;
          * treat it as the NULL partition of the join relation.
          */
         if (jointype == JOIN_FULL)
             *null_index = merge_partition_with_dummy(inner_map, inner_null,
                                                      next_index);
     }
     else
     {
         Assert(consider_outer_null && consider_inner_null);
         Assert(outer_has_null);
         Assert(inner_has_null);
  
         /*
          * If this is an outer join, the NULL partition on the outer side (and
          * that on the inner side if this is a FULL join) have to be scanned
          * all the way anyway, so merge them.  Note that each of the NULL
          * partitions isn't merged yet, so they should be merged successfully.
          * Like the above, each of the NULL partitions only contains NULL
          * values as the key values, so the merged partition will do so; treat
          * it as the NULL partition of the join relation.
          *
          * Note: if this an INNER/SEMI join, the join clause will never be
          * satisfied by two NULL values (see comments above), so both the NULL
          * partitions can be eliminated.
          */
         if (IS_OUTER_JOIN(jointype))
         {
             Assert(jointype != JOIN_RIGHT);
             *null_index = merge_matching_partitions(outer_map, inner_map,
                                                     outer_null, inner_null,
                                                     next_index);
             Assert(*null_index >= 0);
         }
     }
 }

References Assert(), IS_OUTER_JOIN, JOIN_FULL, JOIN_RIGHT, merge_matching_partitions(), merge_partition_with_dummy(), and PartitionMap::merged_indexes.

Referenced by merge_list_bounds().

◆ merge_partition_with_dummy()

static int merge_partition_with_dummy	(	PartitionMap *	map,
		int	index,
		int *	next_index
	)

static

Definition at line 2368 of file partbounds.c.

 {
     int         merged_index = *next_index;
  
     Assert(index >= 0 && index < map->nparts);
     Assert(map->merged_indexes[index] == -1);
     Assert(!map->merged[index]);
     map->merged_indexes[index] = merged_index;
     /* Leave the merged flag alone! */
     *next_index = *next_index + 1;
     return merged_index;
 }

References Assert(), PartitionMap::merged, and PartitionMap::merged_indexes.

Referenced by merge_default_partitions(), merge_null_partitions(), process_inner_partition(), and process_outer_partition().

◆ merge_range_bounds()

static PartitionBoundInfo merge_range_bounds	(	int	partnatts,
		FmgrInfo *	partsupfuncs,
		Oid *	partcollations,
		RelOptInfo *	outer_rel,
		RelOptInfo *	inner_rel,
		JoinType	jointype,
		List **	outer_parts,
		List **	inner_parts
	)

static

Definition at line 1507 of file partbounds.c.

 {
     PartitionBoundInfo merged_bounds = NULL;
     PartitionBoundInfo outer_bi = outer_rel->boundinfo;
     PartitionBoundInfo inner_bi = inner_rel->boundinfo;
     bool        outer_has_default = partition_bound_has_default(outer_bi);
     bool        inner_has_default = partition_bound_has_default(inner_bi);
     int         outer_default = outer_bi->default_index;
     int         inner_default = inner_bi->default_index;
     PartitionMap outer_map;
     PartitionMap inner_map;
     int         outer_index;
     int         inner_index;
     int         outer_lb_pos;
     int         inner_lb_pos;
     PartitionRangeBound outer_lb;
     PartitionRangeBound outer_ub;
     PartitionRangeBound inner_lb;
     PartitionRangeBound inner_ub;
     int         next_index = 0;
     int         default_index = -1;
     List       *merged_datums = NIL;
     List       *merged_kinds = NIL;
     List       *merged_indexes = NIL;
  
     Assert(*outer_parts == NIL);
     Assert(*inner_parts == NIL);
     Assert(outer_bi->strategy == inner_bi->strategy &&
            outer_bi->strategy == PARTITION_STRATEGY_RANGE);
  
     init_partition_map(outer_rel, &outer_map);
     init_partition_map(inner_rel, &inner_map);
  
     /*
      * If the default partitions (if any) have been proven empty, deem them
      * non-existent.
      */
     if (outer_has_default && is_dummy_partition(outer_rel, outer_default))
         outer_has_default = false;
     if (inner_has_default && is_dummy_partition(inner_rel, inner_default))
         inner_has_default = false;
  
     /*
      * Merge partitions from both sides.  In each iteration we compare a pair
      * of ranges, one from each side, and decide whether the corresponding
      * partitions match or not.  If the two ranges overlap, move to the next
      * pair of ranges, otherwise move to the next range on the side with a
      * lower range.  outer_lb_pos/inner_lb_pos keep track of the positions of
      * lower bounds in the datums arrays in the outer/inner
      * PartitionBoundInfos respectively.
      */
     outer_lb_pos = inner_lb_pos = 0;
     outer_index = get_range_partition(outer_rel, outer_bi, &outer_lb_pos,
                                       &outer_lb, &outer_ub);
     inner_index = get_range_partition(inner_rel, inner_bi, &inner_lb_pos,
                                       &inner_lb, &inner_ub);
     while (outer_index >= 0 || inner_index >= 0)
     {
         bool        overlap;
         int         ub_cmpval;
         int         lb_cmpval;
         PartitionRangeBound merged_lb = {-1, NULL, NULL, true};
         PartitionRangeBound merged_ub = {-1, NULL, NULL, false};
         int         merged_index = -1;
  
         /*
          * We run this loop till both sides finish.  This allows us to avoid
          * duplicating code to handle the remaining ranges on the side which
          * finishes later.  For that we set the comparison parameter cmpval in
          * such a way that it appears as if the side which finishes earlier
          * has an extra range higher than any other range on the unfinished
          * side. That way we advance the ranges on the unfinished side till
          * all of its ranges are exhausted.
          */
         if (outer_index == -1)
         {
             overlap = false;
             lb_cmpval = 1;
             ub_cmpval = 1;
         }
         else if (inner_index == -1)
         {
             overlap = false;
             lb_cmpval = -1;
             ub_cmpval = -1;
         }
         else
             overlap = compare_range_partitions(partnatts, partsupfuncs,
                                                partcollations,
                                                &outer_lb, &outer_ub,
                                                &inner_lb, &inner_ub,
                                                &lb_cmpval, &ub_cmpval);
  
         if (overlap)
         {
             /* Two ranges overlap; form a join pair. */
  
             PartitionRangeBound save_outer_ub;
             PartitionRangeBound save_inner_ub;
  
             /* Both partitions should not have been merged yet. */
             Assert(outer_index >= 0);
             Assert(outer_map.merged_indexes[outer_index] == -1 &&
                    outer_map.merged[outer_index] == false);
             Assert(inner_index >= 0);
             Assert(inner_map.merged_indexes[inner_index] == -1 &&
                    inner_map.merged[inner_index] == false);
  
             /*
              * Get the index of the merged partition.  Both partitions aren't
              * merged yet, so the partitions should be merged successfully.
              */
             merged_index = merge_matching_partitions(&outer_map, &inner_map,
                                                      outer_index, inner_index,
                                                      &next_index);
             Assert(merged_index >= 0);
  
             /* Get the range bounds of the merged partition. */
             get_merged_range_bounds(partnatts, partsupfuncs,
                                     partcollations, jointype,
                                     &outer_lb, &outer_ub,
                                     &inner_lb, &inner_ub,
                                     lb_cmpval, ub_cmpval,
                                     &merged_lb, &merged_ub);
  
             /* Save the upper bounds of both partitions for use below. */
             save_outer_ub = outer_ub;
             save_inner_ub = inner_ub;
  
             /* Move to the next pair of ranges. */
             outer_index = get_range_partition(outer_rel, outer_bi, &outer_lb_pos,
                                               &outer_lb, &outer_ub);
             inner_index = get_range_partition(inner_rel, inner_bi, &inner_lb_pos,
                                               &inner_lb, &inner_ub);
  
             /*
              * If the range of a partition on one side overlaps the range of
              * the next partition on the other side, that will cause the
              * partition on one side to match at least two partitions on the
              * other side, which is the case that we currently don't support
              * partitioned join for; give up.
              */
             if (ub_cmpval > 0 && inner_index >= 0 &&
                 compare_range_bounds(partnatts, partsupfuncs, partcollations,
                                      &save_outer_ub, &inner_lb) > 0)
                 goto cleanup;
             if (ub_cmpval < 0 && outer_index >= 0 &&
                 compare_range_bounds(partnatts, partsupfuncs, partcollations,
                                      &outer_lb, &save_inner_ub) < 0)
                 goto cleanup;
  
             /*
              * A row from a non-overlapping portion (if any) of a partition on
              * one side might find its join partner in the default partition
              * (if any) on the other side, causing the same situation as
              * above; give up in that case.
              */
             if ((outer_has_default && (lb_cmpval > 0 || ub_cmpval < 0)) ||
                 (inner_has_default && (lb_cmpval < 0 || ub_cmpval > 0)))
                 goto cleanup;
         }
         else if (ub_cmpval < 0)
         {
             /* A non-overlapping outer range. */
  
             /* The outer partition should not have been merged yet. */
             Assert(outer_index >= 0);
             Assert(outer_map.merged_indexes[outer_index] == -1 &&
                    outer_map.merged[outer_index] == false);
  
             /*
              * If the inner side has the default partition, or this is an
              * outer join, try to assign a merged partition to the outer
              * partition (see process_outer_partition()).  Otherwise, the
              * outer partition will not contribute to the result.
              */
             if (inner_has_default || IS_OUTER_JOIN(jointype))
             {
                 merged_index = process_outer_partition(&outer_map,
                                                        &inner_map,
                                                        outer_has_default,
                                                        inner_has_default,
                                                        outer_index,
                                                        inner_default,
                                                        jointype,
                                                        &next_index,
                                                        &default_index);
                 if (merged_index == -1)
                     goto cleanup;
                 merged_lb = outer_lb;
                 merged_ub = outer_ub;
             }
  
             /* Move to the next range on the outer side. */
             outer_index = get_range_partition(outer_rel, outer_bi, &outer_lb_pos,
                                               &outer_lb, &outer_ub);
         }
         else
         {
             /* A non-overlapping inner range. */
             Assert(ub_cmpval > 0);
  
             /* The inner partition should not have been merged yet. */
             Assert(inner_index >= 0);
             Assert(inner_map.merged_indexes[inner_index] == -1 &&
                    inner_map.merged[inner_index] == false);
  
             /*
              * If the outer side has the default partition, or this is a FULL
              * join, try to assign a merged partition to the inner partition
              * (see process_inner_partition()).  Otherwise, the inner
              * partition will not contribute to the result.
              */
             if (outer_has_default || jointype == JOIN_FULL)
             {
                 merged_index = process_inner_partition(&outer_map,
                                                        &inner_map,
                                                        outer_has_default,
                                                        inner_has_default,
                                                        inner_index,
                                                        outer_default,
                                                        jointype,
                                                        &next_index,
                                                        &default_index);
                 if (merged_index == -1)
                     goto cleanup;
                 merged_lb = inner_lb;
                 merged_ub = inner_ub;
             }
  
             /* Move to the next range on the inner side. */
             inner_index = get_range_partition(inner_rel, inner_bi, &inner_lb_pos,
                                               &inner_lb, &inner_ub);
         }
  
         /*
          * If we assigned a merged partition, add the range bounds and index
          * of the merged partition if appropriate.
          */
         if (merged_index >= 0 && merged_index != default_index)
             add_merged_range_bounds(partnatts, partsupfuncs, partcollations,
                                     &merged_lb, &merged_ub, merged_index,
                                     &merged_datums, &merged_kinds,
                                     &merged_indexes);
     }
  
     /* Merge the default partitions if any. */
     if (outer_has_default || inner_has_default)
         merge_default_partitions(&outer_map, &inner_map,
                                  outer_has_default, inner_has_default,
                                  outer_default, inner_default,
                                  jointype, &next_index, &default_index);
     else
         Assert(default_index == -1);
  
     /* If we have merged partitions, create the partition bounds. */
     if (next_index > 0)
     {
         /*
          * Unlike the case of list partitioning, we wouldn't have re-merged
          * partitions, so did_remapping should be left alone.
          */
         Assert(!outer_map.did_remapping);
         Assert(!inner_map.did_remapping);
  
         /* Use maps to match partitions from inputs. */
         generate_matching_part_pairs(outer_rel, inner_rel,
                                      &outer_map, &inner_map,
                                      next_index,
                                      outer_parts, inner_parts);
         Assert(*outer_parts != NIL);
         Assert(*inner_parts != NIL);
         Assert(list_length(*outer_parts) == list_length(*inner_parts));
         Assert(list_length(*outer_parts) == next_index);
  
         /* Make a PartitionBoundInfo struct to return. */
         merged_bounds = build_merged_partition_bounds(outer_bi->strategy,
                                                       merged_datums,
                                                       merged_kinds,
                                                       merged_indexes,
                                                       -1,
                                                       default_index);
         Assert(merged_bounds);
     }
  
 cleanup:
     /* Free local memory before returning. */
     list_free(merged_datums);
     list_free(merged_kinds);
     list_free(merged_indexes);
     free_partition_map(&outer_map);
     free_partition_map(&inner_map);
  
     return merged_bounds;
 }

References add_merged_range_bounds(), Assert(), build_merged_partition_bounds(), cleanup(), compare_range_bounds, compare_range_partitions(), PartitionBoundInfoData::default_index, PartitionMap::did_remapping, free_partition_map(), generate_matching_part_pairs(), get_merged_range_bounds(), get_range_partition(), init_partition_map(), is_dummy_partition(), IS_OUTER_JOIN, JOIN_FULL, list_free(), list_length(), merge_default_partitions(), merge_matching_partitions(), PartitionMap::merged, PartitionMap::merged_indexes, NIL, partition_bound_has_default, PARTITION_STRATEGY_RANGE, process_inner_partition(), process_outer_partition(), and PartitionBoundInfoData::strategy.

Referenced by partition_bounds_merge().

◆ 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,
		RelOptInfo *	outer_rel,
		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_hbound_cmp()

static int32 partition_hbound_cmp	(	int	modulus1,
		int	remainder1,
		int	modulus2,
		int	remainder2
	)

static

Definition at line 3588 of file partbounds.c.

 {
     if (modulus1 < modulus2)
         return -1;
     if (modulus1 > modulus2)
         return 1;
     if (modulus1 == modulus2 && remainder1 != remainder2)
         return (remainder1 > remainder2) ? 1 : -1;
     return 0;
 }

Referenced by partition_hash_bsearch(), and qsort_partition_hbound_cmp().

◆ 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_bsearch()

static int partition_range_bsearch	(	int	partnatts,
		FmgrInfo *	partsupfunc,
		Oid *	partcollation,
		PartitionBoundInfo	boundinfo,
		PartitionRangeBound *	probe,
		int32 *	cmpval
	)

static

Definition at line 3654 of file partbounds.c.

 {
     int         lo,
                 hi,
                 mid;
  
     lo = -1;
     hi = boundinfo->ndatums - 1;
     while (lo < hi)
     {
         mid = (lo + hi + 1) / 2;
         *cmpval = partition_rbound_cmp(partnatts, partsupfunc,
                                        partcollation,
                                        boundinfo->datums[mid],
                                        boundinfo->kind[mid],
                                        (boundinfo->indexes[mid] == -1),
                                        probe);
         if (*cmpval <= 0)
         {
             lo = mid;
             if (*cmpval == 0)
                 break;
         }
         else
             hi = mid - 1;
     }
  
     return lo;
 }

References PartitionBoundInfoData::datums, PartitionBoundInfoData::indexes, PartitionBoundInfoData::kind, PartitionBoundInfoData::ndatums, and partition_rbound_cmp().

Referenced by check_new_partition_bound().

◆ 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_cmp()

static int32 partition_rbound_cmp	(	int	partnatts,
		FmgrInfo *	partsupfunc,
		Oid *	partcollation,
		Datum *	datums1,
		PartitionRangeDatumKind *	kind1,
		bool	lower1,
		PartitionRangeBound *	b2
	)

static

Definition at line 3489 of file partbounds.c.

 {
     int32       colnum = 0;
     int32       cmpval = 0;     /* placate compiler */
     int         i;
     Datum      *datums2 = b2->datums;
     PartitionRangeDatumKind *kind2 = b2->kind;
     bool        lower2 = b2->lower;
  
     for (i = 0; i < partnatts; i++)
     {
         /* Track column number in case we need it for result */
         colnum++;
  
         /*
          * First, handle cases where the column is unbounded, which should not
          * invoke the comparison procedure, and should not consider any later
          * columns. Note that the PartitionRangeDatumKind enum elements
          * compare the same way as the values they represent.
          */
         if (kind1[i] < kind2[i])
             return -colnum;
         else if (kind1[i] > kind2[i])
             return colnum;
         else if (kind1[i] != PARTITION_RANGE_DATUM_VALUE)
         {
             /*
              * The column bounds are both MINVALUE or both MAXVALUE. No later
              * columns should be considered, but we still need to compare
              * whether they are upper or lower bounds.
              */
             break;
         }
  
         cmpval = DatumGetInt32(FunctionCall2Coll(&partsupfunc[i],
                                                  partcollation[i],
                                                  datums1[i],
                                                  datums2[i]));
         if (cmpval != 0)
             break;
     }
  
     /*
      * If the comparison is anything other than equal, we're done. If they
      * compare equal though, we still have to consider whether the boundaries
      * are inclusive or exclusive.  Exclusive one is considered smaller of the
      * two.
      */
     if (cmpval == 0 && lower1 != lower2)
         cmpval = lower1 ? 1 : -1;
  
     return cmpval == 0 ? 0 : (cmpval < 0 ? -colnum : colnum);
 }

References DatumGetInt32(), PartitionRangeBound::datums, FunctionCall2Coll(), i, PartitionRangeBound::kind, PartitionRangeBound::lower, and PARTITION_RANGE_DATUM_VALUE.

Referenced by add_merged_range_bounds(), check_new_partition_bound(), and partition_range_bsearch().

◆ 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().

◆ process_inner_partition()

static int process_inner_partition	(	PartitionMap *	outer_map,
		PartitionMap *	inner_map,
		bool	outer_has_default,
		bool	inner_has_default,
		int	inner_index,
		int	outer_default,
		JoinType	jointype,
		int *	next_index,
		int *	default_index
	)

static

Definition at line 2063 of file partbounds.c.

 {
     int         merged_index = -1;
  
     Assert(inner_index >= 0);
  
     /*
      * If the outer side has the default partition, a row from the inner
      * partition might find its join partner in the default partition; try
      * merging the inner partition with the default partition.  Otherwise,
      * this should be a FULL join, in which case the inner partition has to be
      * scanned all the way anyway; merge the inner partition with a dummy
      * partition on the other side.
      */
     if (outer_has_default)
     {
         Assert(outer_default >= 0);
  
         /*
          * If the inner side has the default partition as well, the default
          * partition on the outer side will have two matching partitions on
          * the other side: the inner partition and the default partition on
          * the inner side.  Partitionwise join doesn't handle this scenario
          * yet.
          */
         if (inner_has_default)
             return -1;
  
         merged_index = merge_matching_partitions(outer_map, inner_map,
                                                  outer_default, inner_index,
                                                  next_index);
         if (merged_index == -1)
             return -1;
  
         /*
          * If this is an outer join, the default partition on the outer side
          * has to be scanned all the way anyway, so the resulting partition
          * will contain all key values from the default partition, which any
          * other partition of the join relation will not contain.  Thus the
          * resulting partition will act as the default partition of the join
          * relation; record the index in *default_index if not already done.
          */
         if (IS_OUTER_JOIN(jointype))
         {
             Assert(jointype != JOIN_RIGHT);
             if (*default_index == -1)
                 *default_index = merged_index;
             else
                 Assert(*default_index == merged_index);
         }
     }
     else
     {
         Assert(jointype == JOIN_FULL);
  
         /* If we have already assigned a partition, no need to do anything. */
         merged_index = inner_map->merged_indexes[inner_index];
         if (merged_index == -1)
             merged_index = merge_partition_with_dummy(inner_map, inner_index,
                                                       next_index);
     }
     return merged_index;
 }

References Assert(), IS_OUTER_JOIN, JOIN_FULL, JOIN_RIGHT, merge_matching_partitions(), merge_partition_with_dummy(), and PartitionMap::merged_indexes.

Referenced by merge_list_bounds(), and merge_range_bounds().

◆ process_outer_partition()

static int process_outer_partition	(	PartitionMap *	outer_map,
		PartitionMap *	inner_map,
		bool	outer_has_default,
		bool	inner_has_default,
		int	outer_index,
		int	inner_default,
		JoinType	jointype,
		int *	next_index,
		int *	default_index
	)

static

Definition at line 1981 of file partbounds.c.

 {
     int         merged_index = -1;
  
     Assert(outer_index >= 0);
  
     /*
      * If the inner side has the default partition, a row from the outer
      * partition might find its join partner in the default partition; try
      * merging the outer partition with the default partition.  Otherwise,
      * this should be an outer join, in which case the outer partition has to
      * be scanned all the way anyway; merge the outer partition with a dummy
      * partition on the other side.
      */
     if (inner_has_default)
     {
         Assert(inner_default >= 0);
  
         /*
          * If the outer side has the default partition as well, the default
          * partition on the inner side will have two matching partitions on
          * the other side: the outer partition and the default partition on
          * the outer side.  Partitionwise join doesn't handle this scenario
          * yet.
          */
         if (outer_has_default)
             return -1;
  
         merged_index = merge_matching_partitions(outer_map, inner_map,
                                                  outer_index, inner_default,
                                                  next_index);
         if (merged_index == -1)
             return -1;
  
         /*
          * If this is a FULL join, the default partition on the inner side has
          * to be scanned all the way anyway, so the resulting partition will
          * contain all key values from the default partition, which any other
          * partition of the join relation will not contain.  Thus the
          * resulting partition will act as the default partition of the join
          * relation; record the index in *default_index if not already done.
          */
         if (jointype == JOIN_FULL)
         {
             if (*default_index == -1)
                 *default_index = merged_index;
             else
                 Assert(*default_index == merged_index);
         }
     }
     else
     {
         Assert(IS_OUTER_JOIN(jointype));
         Assert(jointype != JOIN_RIGHT);
  
         /* If we have already assigned a partition, no need to do anything. */
         merged_index = outer_map->merged_indexes[outer_index];
         if (merged_index == -1)
             merged_index = merge_partition_with_dummy(outer_map, outer_index,
                                                       next_index);
     }
     return merged_index;
 }

References Assert(), IS_OUTER_JOIN, JOIN_FULL, JOIN_RIGHT, merge_matching_partitions(), merge_partition_with_dummy(), and PartitionMap::merged_indexes.

Referenced by merge_list_bounds(), and merge_range_bounds().

◆ qsort_partition_hbound_cmp()

static int32 qsort_partition_hbound_cmp	(	const void *	a,
		const void *	b
	)

static

Definition at line 3779 of file partbounds.c.

 {
     const PartitionHashBound *h1 = (const PartitionHashBound *) a;
     const PartitionHashBound *h2 = (const PartitionHashBound *) b;
  
     return partition_hbound_cmp(h1->modulus, h1->remainder,
                                 h2->modulus, h2->remainder);
 }

References a, b, PartitionHashBound::modulus, partition_hbound_cmp(), and PartitionHashBound::remainder.

Referenced by create_hash_bounds().

◆ qsort_partition_list_value_cmp()

static int32 qsort_partition_list_value_cmp	(	const void *	a,
		const void *	b,
		void *	arg
	)

static

Definition at line 3794 of file partbounds.c.

 {
     Datum       val1 = ((const PartitionListValue *) a)->value,
                 val2 = ((const PartitionListValue *) b)->value;
     PartitionKey key = (PartitionKey) arg;
  
     return DatumGetInt32(FunctionCall2Coll(&key->partsupfunc[0],
                                            key->partcollation[0],
                                            val1, val2));
 }

References a, arg, b, DatumGetInt32(), FunctionCall2Coll(), and sort-test::key.

Referenced by create_list_bounds().

◆ qsort_partition_rbound_cmp()

static int32 qsort_partition_rbound_cmp	(	const void *	a,
		const void *	b,
		void *	arg
	)

static

Definition at line 3811 of file partbounds.c.

 {
     PartitionRangeBound *b1 = (*(PartitionRangeBound *const *) a);
     PartitionRangeBound *b2 = (*(PartitionRangeBound *const *) b);
     PartitionKey key = (PartitionKey) arg;
  
     return compare_range_bounds(key->partnatts, key->partsupfunc,
                                 key->partcollation,
                                 b1, b2);
 }

References a, arg, b, compare_range_bounds, and sort-test::key.

Referenced by create_range_bounds().

◆ satisfies_hash_partition()

Datum satisfies_hash_partition ( PG_FUNCTION_ARGS )

Definition at line 4772 of file partbounds.c.

 {
     typedef struct ColumnsHashData
     {
         Oid         relid;
         int         nkeys;
         Oid         variadic_type;
         int16       variadic_typlen;
         bool        variadic_typbyval;
         char        variadic_typalign;
         Oid         partcollid[PARTITION_MAX_KEYS];
         FmgrInfo    partsupfunc[FLEXIBLE_ARRAY_MEMBER];
     } ColumnsHashData;
     Oid         parentId;
     int         modulus;
     int         remainder;
     Datum       seed = UInt64GetDatum(HASH_PARTITION_SEED);
     ColumnsHashData *my_extra;
     uint64      rowHash = 0;
  
     /* Return false if the parent OID, modulus, or remainder is NULL. */
     if (PG_ARGISNULL(0) || PG_ARGISNULL(1) || PG_ARGISNULL(2))
         PG_RETURN_BOOL(false);
     parentId = PG_GETARG_OID(0);
     modulus = PG_GETARG_INT32(1);
     remainder = PG_GETARG_INT32(2);
  
     /* Sanity check modulus and remainder. */
     if (modulus <= 0)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("modulus for hash partition must be an integer value greater than zero")));
     if (remainder < 0)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("remainder for hash partition must be an integer value greater than or equal to zero")));
     if (remainder >= modulus)
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                  errmsg("remainder for hash partition must be less than modulus")));
  
     /*
      * Cache hash function information.
      */
     my_extra = (ColumnsHashData *) fcinfo->flinfo->fn_extra;
     if (my_extra == NULL || my_extra->relid != parentId)
     {
         Relation    parent;
         PartitionKey key;
         int         j;
  
         /* Open parent relation and fetch partition key info */
         parent = relation_open(parentId, AccessShareLock);
         key = RelationGetPartitionKey(parent);
  
         /* Reject parent table that is not hash-partitioned. */
         if (key == NULL || key->strategy != PARTITION_STRATEGY_HASH)
             ereport(ERROR,
                     (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                      errmsg("\"%s\" is not a hash partitioned table",
                             get_rel_name(parentId))));
  
         if (!get_fn_expr_variadic(fcinfo->flinfo))
         {
             int         nargs = PG_NARGS() - 3;
  
             /* complain if wrong number of column values */
             if (key->partnatts != nargs)
                 ereport(ERROR,
                         (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                          errmsg("number of partitioning columns (%d) does not match number of partition keys provided (%d)",
                                 key->partnatts, nargs)));
  
             /* allocate space for our cache */
             fcinfo->flinfo->fn_extra =
                 MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
                                        offsetof(ColumnsHashData, partsupfunc) +
                                        sizeof(FmgrInfo) * nargs);
             my_extra = (ColumnsHashData *) fcinfo->flinfo->fn_extra;
             my_extra->relid = parentId;
             my_extra->nkeys = key->partnatts;
             memcpy(my_extra->partcollid, key->partcollation,
                    key->partnatts * sizeof(Oid));
  
             /* check argument types and save fmgr_infos */
             for (j = 0; j < key->partnatts; ++j)
             {
                 Oid         argtype = get_fn_expr_argtype(fcinfo->flinfo, j + 3);
  
                 if (argtype != key->parttypid[j] && !IsBinaryCoercible(argtype, key->parttypid[j]))
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                              errmsg("column %d of the partition key has type %s, but supplied value is of type %s",
                                     j + 1, format_type_be(key->parttypid[j]), format_type_be(argtype))));
  
                 fmgr_info_copy(&my_extra->partsupfunc[j],
                                &key->partsupfunc[j],
                                fcinfo->flinfo->fn_mcxt);
             }
         }
         else
         {
             ArrayType  *variadic_array = PG_GETARG_ARRAYTYPE_P(3);
  
             /* allocate space for our cache -- just one FmgrInfo in this case */
             fcinfo->flinfo->fn_extra =
                 MemoryContextAllocZero(fcinfo->flinfo->fn_mcxt,
                                        offsetof(ColumnsHashData, partsupfunc) +
                                        sizeof(FmgrInfo));
             my_extra = (ColumnsHashData *) fcinfo->flinfo->fn_extra;
             my_extra->relid = parentId;
             my_extra->nkeys = key->partnatts;
             my_extra->variadic_type = ARR_ELEMTYPE(variadic_array);
             get_typlenbyvalalign(my_extra->variadic_type,
                                  &my_extra->variadic_typlen,
                                  &my_extra->variadic_typbyval,
                                  &my_extra->variadic_typalign);
             my_extra->partcollid[0] = key->partcollation[0];
  
             /* check argument types */
             for (j = 0; j < key->partnatts; ++j)
                 if (key->parttypid[j] != my_extra->variadic_type)
                     ereport(ERROR,
                             (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                              errmsg("column %d of the partition key has type \"%s\", but supplied value is of type \"%s\"",
                                     j + 1,
                                     format_type_be(key->parttypid[j]),
                                     format_type_be(my_extra->variadic_type))));
  
             fmgr_info_copy(&my_extra->partsupfunc[0],
                            &key->partsupfunc[0],
                            fcinfo->flinfo->fn_mcxt);
         }
  
         /* Hold lock until commit */
         relation_close(parent, NoLock);
     }
  
     if (!OidIsValid(my_extra->variadic_type))
     {
         int         nkeys = my_extra->nkeys;
         int         i;
  
         /*
          * For a non-variadic call, neither the number of arguments nor their
          * types can change across calls, so avoid the expense of rechecking
          * here.
          */
<

Data Structures

Macros

Typedefs

Functions

Macro Definition Documentation

◆ compare_range_bounds

Typedef Documentation

◆ PartitionHashBound

◆ PartitionListValue

◆ PartitionMap

◆ PartitionRangeBound

Function Documentation

◆ add_merged_range_bounds()

◆ build_merged_partition_bounds()

◆ check_default_partition_contents()

◆ check_new_partition_bound()

◆ compare_range_partitions()

◆ compute_partition_hash_value()

◆ create_hash_bounds()

◆ create_list_bounds()

◆ create_range_bounds()

◆ fix_merged_indexes()

◆ free_partition_map()

◆ generate_matching_part_pairs()

◆ get_hash_partition_greatest_modulus()

◆ get_merged_range_bounds()

◆ get_non_null_list_datum_count()

◆ get_partition_operator()

◆ get_qual_for_hash()

◆ get_qual_for_list()

◆ get_qual_for_range()

◆ get_qual_from_partbound()

◆ get_range_key_properties()

◆ get_range_nulltest()

◆ get_range_partition()

◆ get_range_partition_internal()

◆ init_partition_map()

◆ is_dummy_partition()

◆ make_one_partition_rbound()

◆ make_partition_op_expr()

◆ merge_default_partitions()

◆ merge_list_bounds()

◆ merge_matching_partitions()

◆ merge_null_partitions()

◆ merge_partition_with_dummy()

◆ merge_range_bounds()

◆ partition_bounds_copy()

◆ partition_bounds_create()

◆ partition_bounds_equal()

◆ partition_bounds_merge()

◆ partition_hash_bsearch()

◆ partition_hbound_cmp()

◆ partition_list_bsearch()

◆ partition_range_bsearch()

◆ partition_range_datum_bsearch()

◆ partition_rbound_cmp()

◆ partition_rbound_datum_cmp()

◆ partitions_are_ordered()

◆ process_inner_partition()

◆ process_outer_partition()

◆ qsort_partition_hbound_cmp()

◆ qsort_partition_list_value_cmp()

◆ qsort_partition_rbound_cmp()

◆ satisfies_hash_partition()