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 PartitionBoundInfoData	PartitionBoundInfoData

Functions
int	get_hash_partition_greatest_modulus (PartitionBoundInfo bound)
uint64	compute_partition_hash_value (int partnatts, FmgrInfo *partsupfunc, const Oid *partcollation, const Datum *values, const bool *isnull)
List *	get_qual_from_partbound (Relation parent, PartitionBoundSpec *spec)
PartitionBoundInfo	partition_bounds_create (PartitionBoundSpec **boundspecs, int nparts, PartitionKey key, int **mapping)
bool	partition_bounds_equal (int partnatts, int16 *parttyplen, bool *parttypbyval, PartitionBoundInfo b1, PartitionBoundInfo b2)
PartitionBoundInfo	partition_bounds_copy (PartitionBoundInfo src, PartitionKey key)
PartitionBoundInfo	partition_bounds_merge (int partnatts, FmgrInfo *partsupfunc, Oid *partcollation, struct RelOptInfo *outer_rel, struct RelOptInfo *inner_rel, JoinType jointype, List **outer_parts, List **inner_parts)
bool	partitions_are_ordered (PartitionBoundInfo boundinfo, Bitmapset *live_parts)
void	check_new_partition_bound (char *relname, Relation parent, PartitionBoundSpec *spec, ParseState *pstate)
void	check_default_partition_contents (Relation parent, Relation default_rel, PartitionBoundSpec *new_spec)
int32	partition_rbound_datum_cmp (FmgrInfo *partsupfunc, Oid *partcollation, Datum *rb_datums, PartitionRangeDatumKind *rb_kind, Datum *tuple_datums, int n_tuple_datums)
int	partition_list_bsearch (FmgrInfo *partsupfunc, Oid *partcollation, PartitionBoundInfo boundinfo, Datum value, bool *is_equal)
int	partition_range_datum_bsearch (FmgrInfo *partsupfunc, Oid *partcollation, PartitionBoundInfo boundinfo, int nvalues, Datum *values, bool *is_equal)
int	partition_hash_bsearch (PartitionBoundInfo boundinfo, int modulus, int remainder)

Macro Definition Documentation

partition_bound_accepts_nulls

#define partition_bound_accepts_nulls

(

bi

)

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

Definition at line 98 of file partbounds.h.

partition_bound_has_default

#define partition_bound_has_default

(

bi

)

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

Definition at line 99 of file partbounds.h.

Typedef Documentation

PartitionBoundInfoData

typedef struct PartitionBoundInfoData PartitionBoundInfoData

Function Documentation

check_default_partition_contents()

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

Definition at line 3251 of file partbounds.c.

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

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

Referenced by DefineRelation().

check_new_partition_bound()

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

Definition at line 2896 of file partbounds.c.

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

Referenced by ATExecAttachPartition(), and DefineRelation().

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 4722 of file partbounds.c.

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

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

Referenced by get_matching_hash_bounds(), and get_partition_for_tuple().

get_hash_partition_greatest_modulus()

int get_hash_partition_greatest_modulus

(

PartitionBoundInfo

bound

)

Definition at line 3414 of file partbounds.c.

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

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

get_qual_from_partbound()

List * get_qual_from_partbound	(	Relation	parent,
		PartitionBoundSpec *	spec
	)

Definition at line 249 of file partbounds.c.

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

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

Referenced by ATExecAttachPartition(), and generate_partition_qual().

partition_bounds_copy()

PartitionBoundInfo partition_bounds_copy	(	PartitionBoundInfo	src,
		PartitionKey	key
	)

Definition at line 1002 of file partbounds.c.

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

References Assert, bms_copy(), datumCopy(), PartitionBoundInfoData::datums, PartitionBoundInfoData::default_index, generate_unaccent_rules::dest, i, PartitionBoundInfoData::indexes, PartitionBoundInfoData::interleaved_parts, j, sort-test::key, PartitionBoundInfoData::kind, PartitionBoundInfoData::ndatums, PartitionBoundInfoData::nindexes, PartitionBoundInfoData::null_index, palloc(), 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
	)

Definition at line 299 of file partbounds.c.

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

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

Referenced by RelationBuildPartitionDesc().

partition_bounds_equal()

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

Definition at line 896 of file partbounds.c.

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

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

Referenced by compute_partition_bounds().

partition_bounds_merge()

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

Definition at line 1118 of file partbounds.c.

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

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

Referenced by compute_partition_bounds().

partition_hash_bsearch()

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

Definition at line 3738 of file partbounds.c.

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

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

Referenced by check_new_partition_bound().

partition_list_bsearch()

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

Definition at line 3607 of file partbounds.c.

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

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

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

partition_range_datum_bsearch()

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

Definition at line 3695 of file partbounds.c.

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

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

Referenced by get_matching_range_bounds(), and get_partition_for_tuple().

partition_rbound_datum_cmp()

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

Definition at line 3556 of file partbounds.c.

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

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

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

partitions_are_ordered()

bool partitions_are_ordered	(	PartitionBoundInfo	boundinfo,
		Bitmapset *	live_parts
	)

Definition at line 2852 of file partbounds.c.

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

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

Referenced by build_partition_pathkeys(), and generate_orderedappend_paths().