partbounds.h File Reference

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

Include dependency graph for partbounds.h:

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

Go to the source code of this file.

Data Structures
struct	PartitionBoundInfoData

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

Typedefs
typedef struct RelOptInfo	RelOptInfo
typedef struct PartitionBoundInfoData	PartitionBoundInfoData

Functions
int	get_hash_partition_greatest_modulus (PartitionBoundInfo bound)
uint64	compute_partition_hash_value (int partnatts, FmgrInfo *partsupfunc, const Oid *partcollation, const Datum *values, const bool *isnull)
List *	get_qual_from_partbound (Relation parent, PartitionBoundSpec *spec)
PartitionBoundInfo	partition_bounds_create (PartitionBoundSpec **boundspecs, int nparts, PartitionKey key, int **mapping)
bool	partition_bounds_equal (int partnatts, int16 *parttyplen, bool *parttypbyval, PartitionBoundInfo b1, PartitionBoundInfo b2)
PartitionBoundInfo	partition_bounds_copy (PartitionBoundInfo src, PartitionKey key)
PartitionBoundInfo	partition_bounds_merge (int partnatts, FmgrInfo *partsupfunc, Oid *partcollation, 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)
int32	partition_rbound_datum_cmp (FmgrInfo *partsupfunc, Oid *partcollation, const Datum *rb_datums, PartitionRangeDatumKind *rb_kind, const 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, const Datum *values, bool *is_equal)
int	partition_hash_bsearch (PartitionBoundInfo boundinfo, int modulus, int remainder)
void	check_partitions_for_split (Relation parent, Oid splitPartOid, List *partlist, ParseState *pstate)
void	calculate_partition_bound_for_merge (Relation parent, List *partNames, List *partOids, PartitionBoundSpec *spec, ParseState *pstate)

Macro Definition Documentation

partition_bound_accepts_nulls

#define partition_bound_accepts_nulls

(

bi

)

((bi)->null_index != -1)

Definition at line 98 of file partbounds.h.

partition_bound_has_default

#define partition_bound_has_default

(

bi

)

((bi)->default_index != -1)

Definition at line 99 of file partbounds.h.

Typedef Documentation

PartitionBoundInfoData

typedef struct PartitionBoundInfoData PartitionBoundInfoData

RelOptInfo

typedef struct RelOptInfo RelOptInfo

Definition at line 18 of file partbounds.h.

Function Documentation

calculate_partition_bound_for_merge()

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

extern

Definition at line 5098 of file partbounds.c.

{
    PartitionKey key = RelationGetPartitionKey(parent);
    PartitionBoundSpec *bound;
 
    Assert(!spec->is_default);
 
    switch (key->strategy)
    {
        case PARTITION_STRATEGY_RANGE:
            {
                int         i;
                PartitionRangeBound **lower_bounds;
                int         nparts = list_length(partOids);
                List       *bounds = NIL;
 
                lower_bounds = palloc0_array(PartitionRangeBound *, nparts);
 
                /*
                 * Create an array of lower bounds and a list of
                 * PartitionBoundSpec.
                 */
                foreach_oid(partoid, partOids)
                {
                    bound = get_partition_bound_spec(partoid);
                    i = foreach_current_index(partoid);
 
                    lower_bounds[i] = make_one_partition_rbound(key, i, bound->lowerdatums, true);
                    bounds = lappend(bounds, bound);
                }
 
                /* Sort the array of lower bounds. */
                qsort_arg(lower_bounds, nparts, sizeof(PartitionRangeBound *),
                          qsort_partition_rbound_cmp, key);
 
                /* Ranges of partitions should be adjacent. */
                for (i = 1; i < nparts; i++)
                {
                    int         index = lower_bounds[i]->index;
                    int         prev_index = lower_bounds[i - 1]->index;
 
                    check_two_partitions_bounds_range(parent,
                                                      (RangeVar *) list_nth(partNames, prev_index),
                                                      (PartitionBoundSpec *) list_nth(bounds, prev_index),
                                                      (RangeVar *) list_nth(partNames, index),
                                                      (PartitionBoundSpec *) list_nth(bounds, index),
                                                      false,
                                                      true,
                                                      pstate);
                }
 
                /*
                 * The lower bound of the first partition is the lower bound
                 * of the merged partition.
                 */
                spec->lowerdatums =
                    ((PartitionBoundSpec *) list_nth(bounds, lower_bounds[0]->index))->lowerdatums;
 
                /*
                 * The upper bound of the last partition is the upper bound of
                 * the merged partition.
                 */
                spec->upperdatums =
                    ((PartitionBoundSpec *) list_nth(bounds, lower_bounds[nparts - 1]->index))->upperdatums;
 
                pfree(lower_bounds);
                list_free(bounds);
                break;
            }
 
        case PARTITION_STRATEGY_LIST:
            {
                /* Consolidate bounds for all partitions in the list. */
                foreach_oid(partoid, partOids)
                {
                    bound = get_partition_bound_spec(partoid);
                    spec->listdatums = list_concat(spec->listdatums, bound->listdatums);
                }
                break;
            }
 
        default:
            elog(ERROR, "unexpected partition strategy: %d",
                 (int) key->strategy);
    }
}

References Assert, check_two_partitions_bounds_range(), elog, ERROR, fb(), foreach_current_index, foreach_oid, get_partition_bound_spec(), i, lappend(), list_concat(), list_free(), list_length(), list_nth(), PartitionBoundSpec::listdatums, PartitionBoundSpec::lowerdatums, make_one_partition_rbound(), NIL, palloc0_array, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, pfree(), qsort_arg(), qsort_partition_rbound_cmp(), and RelationGetPartitionKey().

Referenced by transformPartitionCmdForMerge().

check_default_partition_contents()

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

extern

Definition at line 3244 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(), fb(), 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, RegisterSnapshot(), RelationGetRelationName, RelationGetRelid, ResetExprContext, 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  )

extern

Definition at line 2889 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)));
    }
}

References Assert, PartitionDescData::boundinfo, DatumGetInt32(), PartitionBoundInfoData::datums, PartitionBoundInfoData::default_index, equal(), ereport, errcode(), errdetail(), errmsg(), ERROR, fb(), get_range_partbound_string(), get_rel_name(), PartitionBoundInfoData::indexes, PartitionBoundInfoData::kind, lfirst_node, linitial, list_nth(), PartitionRangeDatum::location, lower(), make_one_partition_rbound(), PartitionBoundInfoData::ndatums, PartitionBoundInfoData::nindexes, PartitionDescData::nparts, PartitionBoundInfoData::null_index, PartitionDescData::oids, parser_errposition(), partition_bound_accepts_nulls, partition_bound_has_default, partition_hash_bsearch(), partition_list_bsearch(), partition_range_bsearch(), partition_rbound_cmp(), PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, RelationGetPartitionDesc(), RelationGetPartitionKey(), relname, remainder, PartitionBoundInfoData::strategy, upper(), and val.

Referenced by ATExecAttachPartition(), check_partitions_for_split(), and DefineRelation().

check_partitions_for_split()

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

extern

Definition at line 5723 of file partbounds.c.

{
    PartitionKey key;
    char        strategy;
    Oid         defaultPartOid;
    bool        isSplitPartDefault;
    bool        createDefaultPart = false;
    int         default_index = -1;
    int         i;
    SinglePartitionSpec **new_parts;
    SinglePartitionSpec *spsPrev = NULL;
 
    /*
     * nparts counts the number of split partitions, but it exclude the
     * default partition.
     */
    int         nparts = 0;
 
    key = RelationGetPartitionKey(parent);
    strategy = get_partition_strategy(key);
 
    defaultPartOid =
        get_default_oid_from_partdesc(RelationGetPartitionDesc(parent, true));
 
    Assert(strategy == PARTITION_STRATEGY_RANGE ||
           strategy == PARTITION_STRATEGY_LIST);
 
    /*
     * Make an array new_parts with new partitions except the DEFAULT
     * partition.
     */
    new_parts = palloc0_array(SinglePartitionSpec *, list_length(partlist));
 
    /* isSplitPartDefault flag: is split partition a DEFAULT partition? */
    isSplitPartDefault = (defaultPartOid == splitPartOid);
 
    foreach_node(SinglePartitionSpec, sps, partlist)
    {
        if (sps->bound->is_default)
            default_index = foreach_current_index(sps);
        else
            new_parts[nparts++] = sps;
    }
 
    /* An indicator that the DEFAULT partition will be created. */
    if (default_index != -1)
    {
        createDefaultPart = true;
        Assert(nparts == list_length(partlist) - 1);
    }
 
    if (strategy == PARTITION_STRATEGY_RANGE)
    {
        PartitionRangeBound **lower_bounds;
        SinglePartitionSpec **tmp_new_parts;
 
        /*
         * To simplify the check for ranges of new partitions, we need to sort
         * all partitions in ascending order of their bounds (we compare the
         * lower bound only).
         */
        lower_bounds = palloc0_array(PartitionRangeBound *, nparts);
 
        /* Create an array of lower bounds. */
        for (i = 0; i < nparts; i++)
        {
            lower_bounds[i] = make_one_partition_rbound(key, i,
                                                        new_parts[i]->bound->lowerdatums, true);
        }
 
        /* Sort the array of lower bounds. */
        qsort_arg(lower_bounds, nparts, sizeof(PartitionRangeBound *),
                  qsort_partition_rbound_cmp, (void *) key);
 
        /* Reorder the array of partitions. */
        tmp_new_parts = new_parts;
        new_parts = palloc0_array(SinglePartitionSpec *, nparts);
        for (i = 0; i < nparts; i++)
            new_parts[i] = tmp_new_parts[lower_bounds[i]->index];
 
        pfree(tmp_new_parts);
        pfree(lower_bounds);
    }
 
    for (i = 0; i < nparts; i++)
    {
        SinglePartitionSpec *sps = new_parts[i];
 
        if (isSplitPartDefault)
        {
            /*
             * When the split partition is the DEFAULT partition, we can use
             * any free ranges - as when creating a new partition.
             */
            check_new_partition_bound(sps->name->relname, parent, sps->bound,
                                      pstate);
        }
        else
        {
            /*
             * Checks that the bounds of the current partition are inside the
             * bounds of the split partition. For range partitioning: checks
             * that the upper bound of the previous partition is equal to the
             * lower bound of the current partition. For list partitioning:
             * checks that the split partition contains all values of the
             * current partition.
             */
            if (strategy == PARTITION_STRATEGY_RANGE)
            {
                bool        first = (i == 0);
                bool        last = (i == (nparts - 1));
 
                check_partition_bounds_for_split_range(parent, sps->name->relname, sps->bound,
                                                       splitPartOid, first, last,
                                                       createDefaultPart, pstate);
            }
            else
                check_partition_bounds_for_split_list(parent, sps->name->relname,
                                                      sps->bound, splitPartOid, pstate);
        }
 
        /* Ranges of new partitions should not overlap. */
        if (strategy == PARTITION_STRATEGY_RANGE && spsPrev)
            check_two_partitions_bounds_range(parent, spsPrev->name, spsPrev->bound,
                                              sps->name, sps->bound,
                                              createDefaultPart,
                                              false,
                                              pstate);
 
        spsPrev = sps;
    }
 
    if (strategy == PARTITION_STRATEGY_LIST)
    {
        /* Values of new partitions should not overlap. */
        check_partitions_not_overlap_list(parent, new_parts, nparts,
                                          pstate);
 
        /*
         * Need to check that all values of the split partition are contained
         * in the new partitions. Skip this check if the DEFAULT partition
         * exists.
         */
        if (!createDefaultPart)
            check_parent_values_in_new_partitions(parent, splitPartOid,
                                                  new_parts, nparts, pstate);
    }
 
    pfree(new_parts);
}

References Assert, check_new_partition_bound(), check_parent_values_in_new_partitions(), check_partition_bounds_for_split_list(), check_partition_bounds_for_split_range(), check_partitions_not_overlap_list(), check_two_partitions_bounds_range(), fb(), foreach_current_index, foreach_node, get_default_oid_from_partdesc(), get_partition_strategy(), i, list_length(), make_one_partition_rbound(), palloc0_array, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, pfree(), qsort_arg(), qsort_partition_rbound_cmp(), RelationGetPartitionDesc(), and RelationGetPartitionKey().

Referenced by transformPartitionCmdForSplit().

compute_partition_hash_value()

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

extern

Definition at line 4714 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(), fb(), FunctionCall2Coll(), hash(), hash_combine64(), HASH_PARTITION_SEED, i, OidIsValid, UInt64GetDatum(), and values.

Referenced by get_matching_hash_bounds(), and get_partition_for_tuple().

get_hash_partition_greatest_modulus()

int get_hash_partition_greatest_modulus ( PartitionBoundInfo  bound )

extern

Definition at line 3407 of file partbounds.c.

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

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

get_qual_from_partbound()

List * get_qual_from_partbound ( Relation  parent, PartitionBoundSpec *  spec  )

extern

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, fb(), get_qual_for_hash(), get_qual_for_list(), get_qual_for_range(), NIL, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, and RelationGetPartitionKey().

Referenced by ATExecAttachPartition(), generate_partition_qual(), and SplitPartitionMoveRows().

partition_bounds_copy()

PartitionBoundInfo partition_bounds_copy ( PartitionBoundInfo  src, PartitionKey  key  )

extern

Definition at line 995 of file partbounds.c.

{
    PartitionBoundInfo dest;
    int         i;
    int         ndatums;
    int         nindexes;
    int         partnatts;
 
    dest = (PartitionBoundInfo) palloc_object(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 = palloc_array(Datum *, ndatums);
 
    if (src->kind != NULL && ndatums > 0)
    {
        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.
     */
    if (ndatums > 0)
    {
        bool        hash_part = (key->strategy == PARTITION_STRATEGY_HASH);
        int         natts = hash_part ? 2 : partnatts;
        Datum      *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++)
            {
                if (dest->kind == NULL ||
                    dest->kind[i][j] == PARTITION_RANGE_DATUM_VALUE)
                {
                    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];
                    }
                    dest->datums[i][j] = datumCopy(src->datums[i][j],
                                                   byval, typlen);
                }
            }
        }
    }
 
    dest->indexes = palloc_array(int, nindexes);
    memcpy(dest->indexes, src->indexes, sizeof(int) * nindexes);
 
    dest->null_index = src->null_index;
    dest->default_index = src->default_index;
 
    return dest;
}

References Assert, bms_copy(), datumCopy(), PartitionBoundInfoData::datums, PartitionBoundInfoData::default_index, fb(), i, PartitionBoundInfoData::indexes, PartitionBoundInfoData::interleaved_parts, j, PartitionBoundInfoData::kind, PartitionBoundInfoData::ndatums, PartitionBoundInfoData::nindexes, PartitionBoundInfoData::null_index, palloc(), palloc_array, palloc_object, PARTITION_RANGE_DATUM_VALUE, PARTITION_STRATEGY_HASH, PARTITION_STRATEGY_LIST, PARTITION_STRATEGY_RANGE, and PartitionBoundInfoData::strategy.

Referenced by RelationBuildPartitionDesc().

partition_bounds_create()

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

extern

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 = palloc_array(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(), fb(), i, palloc_array, 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  )

extern

Definition at line 889 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(), fb(), i, j, PARTITION_RANGE_DATUM_VALUE, and PARTITION_STRATEGY_HASH.

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  )

extern

Definition at line 1112 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, fb(), 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  )

extern

Definition at line 3730 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, fb(), PartitionBoundInfoData::ndatums, partition_hbound_cmp(), and remainder.

Referenced by check_new_partition_bound().

partition_list_bsearch()

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

extern

Definition at line 3599 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, fb(), FunctionCall2Coll(), PartitionBoundInfoData::ndatums, and value.

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

partition_range_datum_bsearch()

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

extern

Definition at line 3687 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, fb(), PartitionBoundInfoData::kind, PartitionBoundInfoData::ndatums, partition_rbound_datum_cmp(), and values.

Referenced by get_matching_range_bounds(), and get_partition_for_tuple().

partition_rbound_datum_cmp()

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

extern

Definition at line 3548 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(), fb(), 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  )

extern

Definition at line 2845 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, fb(), 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().