rangetypes.h File Reference

#include "utils/typcache.h"

Include dependency graph for rangetypes.h:

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

Go to the source code of this file.

Data Structures
struct	RangeType
struct	RangeBound

Macros
#define	RANGE_EMPTY_LITERAL   "empty"
#define	RangeTypeGetOid(r)   ((r)->rangetypid)
#define	RANGE_EMPTY   0x01 /* range is empty */
#define	RANGE_LB_INC   0x02 /* lower bound is inclusive */
#define	RANGE_UB_INC   0x04 /* upper bound is inclusive */
#define	RANGE_LB_INF   0x08 /* lower bound is -infinity */
#define	RANGE_UB_INF   0x10 /* upper bound is +infinity */
#define	RANGE_LB_NULL   0x20 /* lower bound is null (NOT USED) */
#define	RANGE_UB_NULL   0x40 /* upper bound is null (NOT USED) */
#define	RANGE_CONTAIN_EMPTY
#define	RANGE_HAS_LBOUND(flags)
#define	RANGE_HAS_UBOUND(flags)
#define	RangeIsEmpty(r)   ((range_get_flags(r) & RANGE_EMPTY) != 0)
#define	RangeIsOrContainsEmpty(r)    ((range_get_flags(r) & (RANGE_EMPTY | RANGE_CONTAIN_EMPTY)) != 0)
#define	PG_GETARG_RANGE_P(n)   DatumGetRangeTypeP(PG_GETARG_DATUM(n))
#define	PG_GETARG_RANGE_P_COPY(n)   DatumGetRangeTypePCopy(PG_GETARG_DATUM(n))
#define	PG_RETURN_RANGE_P(x)   return RangeTypePGetDatum(x)
#define	RANGESTRAT_BEFORE   RTLeftStrategyNumber
#define	RANGESTRAT_OVERLEFT   RTOverLeftStrategyNumber
#define	RANGESTRAT_OVERLAPS   RTOverlapStrategyNumber
#define	RANGESTRAT_OVERRIGHT   RTOverRightStrategyNumber
#define	RANGESTRAT_AFTER   RTRightStrategyNumber
#define	RANGESTRAT_ADJACENT   RTSameStrategyNumber
#define	RANGESTRAT_CONTAINS   RTContainsStrategyNumber
#define	RANGESTRAT_CONTAINED_BY   RTContainedByStrategyNumber
#define	RANGESTRAT_CONTAINS_ELEM   RTContainsElemStrategyNumber
#define	RANGESTRAT_EQ   RTEqualStrategyNumber

Functions
static RangeType *	DatumGetRangeTypeP (Datum X)
static RangeType *	DatumGetRangeTypePCopy (Datum X)
static Datum	RangeTypePGetDatum (const RangeType *X)
bool	range_contains_elem_internal (TypeCacheEntry *typcache, const RangeType *r, Datum val)
bool	range_eq_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
bool	range_ne_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
bool	range_contains_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
bool	range_contained_by_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
bool	range_before_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
bool	range_after_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
bool	range_adjacent_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
bool	range_overlaps_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
bool	range_overleft_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
bool	range_overright_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
RangeType *	range_union_internal (TypeCacheEntry *typcache, RangeType *r1, RangeType *r2, bool strict)
RangeType *	range_minus_internal (TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
RangeType *	range_intersect_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
TypeCacheEntry *	range_get_typcache (FunctionCallInfo fcinfo, Oid rngtypid)
RangeType *	range_serialize (TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper, bool empty, struct Node *escontext)
void	range_deserialize (TypeCacheEntry *typcache, const RangeType *range, RangeBound *lower, RangeBound *upper, bool *empty)
char	range_get_flags (const RangeType *range)
void	range_set_contain_empty (RangeType *range)
RangeType *	make_range (TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper, bool empty, struct Node *escontext)
int	range_cmp_bounds (TypeCacheEntry *typcache, const RangeBound *b1, const RangeBound *b2)
int	range_cmp_bound_values (TypeCacheEntry *typcache, const RangeBound *b1, const RangeBound *b2)
int	range_compare (const void *key1, const void *key2, void *arg)
bool	bounds_adjacent (TypeCacheEntry *typcache, RangeBound boundA, RangeBound boundB)
RangeType *	make_empty_range (TypeCacheEntry *typcache)
bool	range_split_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2, RangeType **output1, RangeType **output2)

Macro Definition Documentation

PG_GETARG_RANGE_P

#define PG_GETARG_RANGE_P

(

n

)

DatumGetRangeTypeP(PG_GETARG_DATUM(n))

Definition at line 90 of file rangetypes.h.

PG_GETARG_RANGE_P_COPY

#define PG_GETARG_RANGE_P_COPY

(

n

)

DatumGetRangeTypePCopy(PG_GETARG_DATUM(n))

Definition at line 91 of file rangetypes.h.

PG_RETURN_RANGE_P

#define PG_RETURN_RANGE_P

(

x

)

return RangeTypePGetDatum(x)

Definition at line 92 of file rangetypes.h.

RANGE_CONTAIN_EMPTY

#define RANGE_CONTAIN_EMPTY

Value:

                                     0x80   /* marks a GiST internal-page entry whose
                                     * subtree contains some empty ranges */

Definition at line 45 of file rangetypes.h.

RANGE_EMPTY

#define RANGE_EMPTY   0x01 /* range is empty */

Definition at line 38 of file rangetypes.h.

RANGE_EMPTY_LITERAL

#define RANGE_EMPTY_LITERAL   "empty"

Definition at line 32 of file rangetypes.h.

RANGE_HAS_LBOUND

#define RANGE_HAS_LBOUND

(

flags

)

Value:

                                              (!((flags) & (RANGE_EMPTY | \
                                              RANGE_LB_NULL | \
                                              RANGE_LB_INF)))

Definition at line 47 of file rangetypes.h.

RANGE_HAS_UBOUND

#define RANGE_HAS_UBOUND

(

flags

)

Value:

                                              (!((flags) & (RANGE_EMPTY | \
                                              RANGE_UB_NULL | \
                                              RANGE_UB_INF)))

Definition at line 51 of file rangetypes.h.

RANGE_LB_INC

#define RANGE_LB_INC   0x02 /* lower bound is inclusive */

Definition at line 39 of file rangetypes.h.

RANGE_LB_INF

#define RANGE_LB_INF   0x08 /* lower bound is -infinity */

Definition at line 41 of file rangetypes.h.

RANGE_LB_NULL

#define RANGE_LB_NULL   0x20 /* lower bound is null (NOT USED) */

Definition at line 43 of file rangetypes.h.

RANGE_UB_INC

#define RANGE_UB_INC   0x04 /* upper bound is inclusive */

Definition at line 40 of file rangetypes.h.

RANGE_UB_INF

#define RANGE_UB_INF   0x10 /* upper bound is +infinity */

Definition at line 42 of file rangetypes.h.

RANGE_UB_NULL

#define RANGE_UB_NULL   0x40 /* upper bound is null (NOT USED) */

Definition at line 44 of file rangetypes.h.

RangeIsEmpty

#define RangeIsEmpty

(

r

)

((range_get_flags(r) & RANGE_EMPTY) != 0)

Definition at line 55 of file rangetypes.h.

RangeIsOrContainsEmpty

#define RangeIsOrContainsEmpty

(

r

)

((range_get_flags(r) & (RANGE_EMPTY | RANGE_CONTAIN_EMPTY)) != 0)

Definition at line 56 of file rangetypes.h.

RANGESTRAT_ADJACENT

#define RANGESTRAT_ADJACENT   RTSameStrategyNumber

Definition at line 101 of file rangetypes.h.

RANGESTRAT_AFTER

#define RANGESTRAT_AFTER   RTRightStrategyNumber

Definition at line 100 of file rangetypes.h.

RANGESTRAT_BEFORE

#define RANGESTRAT_BEFORE   RTLeftStrategyNumber

Definition at line 96 of file rangetypes.h.

RANGESTRAT_CONTAINED_BY

#define RANGESTRAT_CONTAINED_BY   RTContainedByStrategyNumber

Definition at line 103 of file rangetypes.h.

RANGESTRAT_CONTAINS

#define RANGESTRAT_CONTAINS   RTContainsStrategyNumber

Definition at line 102 of file rangetypes.h.

RANGESTRAT_CONTAINS_ELEM

#define RANGESTRAT_CONTAINS_ELEM   RTContainsElemStrategyNumber

Definition at line 104 of file rangetypes.h.

RANGESTRAT_EQ

#define RANGESTRAT_EQ   RTEqualStrategyNumber

Definition at line 105 of file rangetypes.h.

RANGESTRAT_OVERLAPS

#define RANGESTRAT_OVERLAPS   RTOverlapStrategyNumber

Definition at line 98 of file rangetypes.h.

RANGESTRAT_OVERLEFT

#define RANGESTRAT_OVERLEFT   RTOverLeftStrategyNumber

Definition at line 97 of file rangetypes.h.

RANGESTRAT_OVERRIGHT

#define RANGESTRAT_OVERRIGHT   RTOverRightStrategyNumber

Definition at line 99 of file rangetypes.h.

RangeTypeGetOid

#define RangeTypeGetOid

(

r

)

((r)->rangetypid)

Definition at line 35 of file rangetypes.h.

Function Documentation

bounds_adjacent()

bool bounds_adjacent	(	TypeCacheEntry *	typcache,
		RangeBound	boundA,
		RangeBound	boundB
	)

Definition at line 757 of file rangetypes.c.

{
    int         cmp;
 
    Assert(!boundA.lower && boundB.lower);
 
    cmp = range_cmp_bound_values(typcache, &boundA, &boundB);
    if (cmp < 0)
    {
        RangeType  *r;
 
        /*
         * Bounds do not overlap; see if there are points in between.
         */
 
        /* in a continuous subtype, there are assumed to be points between */
        if (!OidIsValid(typcache->rng_canonical_finfo.fn_oid))
            return false;
 
        /*
         * The bounds are of a discrete range type; so make a range A..B and
         * see if it's empty.
         */
 
        /* flip the inclusion flags */
        boundA.inclusive = !boundA.inclusive;
        boundB.inclusive = !boundB.inclusive;
        /* change upper/lower labels to avoid Assert failures */
        boundA.lower = true;
        boundB.lower = false;
        r = make_range(typcache, &boundA, &boundB, false, NULL);
        return RangeIsEmpty(r);
    }
    else if (cmp == 0)
        return boundA.inclusive != boundB.inclusive;
    else
        return false;           /* bounds overlap */
}

References Assert, cmp(), FmgrInfo::fn_oid, RangeBound::inclusive, RangeBound::lower, make_range(), OidIsValid, range_cmp_bound_values(), RangeIsEmpty, and TypeCacheEntry::rng_canonical_finfo.

Referenced by adjacent_cmp_bounds(), multirange_adjacent_multirange(), range_adjacent_internal(), and range_adjacent_multirange_internal().

DatumGetRangeTypeP()

static RangeType* DatumGetRangeTypeP ( Datum  X )

inlinestatic

Definition at line 73 of file rangetypes.h.

{
    return (RangeType *) PG_DETOAST_DATUM(X);

References PG_DETOAST_DATUM.

Referenced by calc_hist_selectivity(), compute_range_stats(), find_simplified_clause(), make_range(), multirange_constructor2(), multirange_gist_consistent(), multirange_in(), multirange_recv(), multirangesel(), range_agg_finalfn(), range_gist_class_split(), range_gist_consistent(), range_gist_double_sorting_split(), range_gist_fallback_split(), range_gist_penalty(), range_gist_picksplit(), range_gist_single_sorting_split(), range_gist_union(), rangesel(), spg_range_quad_choose(), spg_range_quad_inner_consistent(), spg_range_quad_leaf_consistent(), and spg_range_quad_picksplit().

DatumGetRangeTypePCopy()

static RangeType* DatumGetRangeTypePCopy ( Datum  X )

inlinestatic

Definition at line 79 of file rangetypes.h.

{
    return (RangeType *) PG_DETOAST_DATUM_COPY(X);

References PG_DETOAST_DATUM_COPY.

make_empty_range()

RangeType* make_empty_range

(

TypeCacheEntry *

typcache

)

Definition at line 2165 of file rangetypes.c.

{
    RangeBound  lower;
    RangeBound  upper;
 
    lower.val = (Datum) 0;
    lower.infinite = false;
    lower.inclusive = false;
    lower.lower = true;
 
    upper.val = (Datum) 0;
    upper.infinite = false;
    upper.inclusive = false;
    upper.lower = false;
 
    return make_range(typcache, &lower, &upper, true, NULL);
}

References lower(), make_range(), and upper().

Referenced by multirange_agg_transfn(), multirange_get_union_range(), range_intersect_internal(), range_merge_from_multirange(), and range_minus_internal().

make_range()

RangeType* make_range	(	TypeCacheEntry *	typcache,
		RangeBound *	lower,
		RangeBound *	upper,
		bool	empty,
		struct Node *	escontext
	)

Definition at line 1952 of file rangetypes.c.

{
    RangeType  *range;
 
    range = range_serialize(typcache, lower, upper, empty, escontext);
 
    if (SOFT_ERROR_OCCURRED(escontext))
        return NULL;
 
    /* no need to call canonical on empty ranges ... */
    if (OidIsValid(typcache->rng_canonical_finfo.fn_oid) &&
        !RangeIsEmpty(range))
    {
        /* Do this the hard way so that we can pass escontext */
        LOCAL_FCINFO(fcinfo, 1);
        Datum       result;
 
        InitFunctionCallInfoData(*fcinfo, &typcache->rng_canonical_finfo, 1,
                                 InvalidOid, escontext, NULL);
 
        fcinfo->args[0].value = RangeTypePGetDatum(range);
        fcinfo->args[0].isnull = false;
 
        result = FunctionCallInvoke(fcinfo);
 
        if (SOFT_ERROR_OCCURRED(escontext))
            return NULL;
 
        /* Should not get a null result if there was no error */
        if (fcinfo->isnull)
            elog(ERROR, "function %u returned NULL",
                 typcache->rng_canonical_finfo.fn_oid);
 
        range = DatumGetRangeTypeP(result);
    }
 
    return range;
}

References DatumGetRangeTypeP(), elog, ERROR, FmgrInfo::fn_oid, FunctionCallInvoke, InitFunctionCallInfoData, InvalidOid, LOCAL_FCINFO, lower(), OidIsValid, range(), range_serialize(), RangeIsEmpty, RangeTypePGetDatum(), TypeCacheEntry::rng_canonical_finfo, SOFT_ERROR_OCCURRED, and upper().

Referenced by bounds_adjacent(), make_empty_range(), multirange_get_union_range(), range_constructor2(), range_constructor3(), range_in(), range_intersect_internal(), range_merge_from_multirange(), range_minus_internal(), range_recv(), range_split_internal(), range_super_union(), and range_union_internal().

range_adjacent_internal()

bool range_adjacent_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 798 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    /* An empty range is not adjacent to any other range */
    if (empty1 || empty2)
        return false;
 
    /*
     * Given two ranges A..B and C..D, the ranges are adjacent if and only if
     * B is adjacent to C, or D is adjacent to A.
     */
    return (bounds_adjacent(typcache, upper1, lower2) ||
            bounds_adjacent(typcache, upper2, lower1));
}

References bounds_adjacent(), elog, ERROR, range_deserialize(), and RangeTypeGetOid.

Referenced by multirange_canonicalize(), range_adjacent(), range_gist_consistent_int_range(), range_gist_consistent_leaf_range(), range_union_internal(), and spg_range_quad_leaf_consistent().

range_after_internal()

bool range_after_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 702 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    /* An empty range is neither before nor after any other range */
    if (empty1 || empty2)
        return false;
 
    return (range_cmp_bounds(typcache, &lower1, &upper2) > 0);
}

References elog, ERROR, range_cmp_bounds(), range_deserialize(), and RangeTypeGetOid.

Referenced by range_after(), range_gist_consistent_int_range(), range_gist_consistent_leaf_range(), and spg_range_quad_leaf_consistent().

range_before_internal()

bool range_before_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 664 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    /* An empty range is neither before nor after any other range */
    if (empty1 || empty2)
        return false;
 
    return (range_cmp_bounds(typcache, &upper1, &lower2) < 0);
}

References elog, ERROR, range_cmp_bounds(), range_deserialize(), and RangeTypeGetOid.

Referenced by multirange_canonicalize(), multirange_intersect_internal(), multirange_minus_internal(), range_before(), range_gist_consistent_int_range(), range_gist_consistent_leaf_range(), and spg_range_quad_leaf_consistent().

range_cmp_bound_values()

int range_cmp_bound_values	(	TypeCacheEntry *	typcache,
		const RangeBound *	b1,
		const RangeBound *	b2
	)

Definition at line 2090 of file rangetypes.c.

{
    /*
     * First, handle cases involving infinity, which don't require invoking
     * the comparison proc.
     */
    if (b1->infinite && b2->infinite)
    {
        /*
         * Both are infinity, so they are equal unless one is lower and the
         * other not.
         */
        if (b1->lower == b2->lower)
            return 0;
        else
            return b1->lower ? -1 : 1;
    }
    else if (b1->infinite)
        return b1->lower ? -1 : 1;
    else if (b2->infinite)
        return b2->lower ? 1 : -1;
 
    /*
     * Both boundaries are finite, so compare the held values.
     */
    return DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
                                           typcache->rng_collation,
                                           b1->val, b2->val));
}

References DatumGetInt32(), FunctionCall2Coll(), RangeBound::infinite, RangeBound::lower, TypeCacheEntry::rng_cmp_proc_finfo, TypeCacheEntry::rng_collation, and RangeBound::val.

Referenced by bounds_adjacent(), and range_serialize().

range_cmp_bounds()

int range_cmp_bounds	(	TypeCacheEntry *	typcache,
		const RangeBound *	b1,
		const RangeBound *	b2
	)

Definition at line 2016 of file rangetypes.c.

{
    int32       result;
 
    /*
     * First, handle cases involving infinity, which don't require invoking
     * the comparison proc.
     */
    if (b1->infinite && b2->infinite)
    {
        /*
         * Both are infinity, so they are equal unless one is lower and the
         * other not.
         */
        if (b1->lower == b2->lower)
            return 0;
        else
            return b1->lower ? -1 : 1;
    }
    else if (b1->infinite)
        return b1->lower ? -1 : 1;
    else if (b2->infinite)
        return b2->lower ? 1 : -1;
 
    /*
     * Both boundaries are finite, so compare the held values.
     */
    result = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
                                             typcache->rng_collation,
                                             b1->val, b2->val));
 
    /*
     * If the comparison is anything other than equal, we're done. If they
     * compare equal though, we still have to consider whether the boundaries
     * are inclusive or exclusive.
     */
    if (result == 0)
    {
        if (!b1->inclusive && !b2->inclusive)
        {
            /* both are exclusive */
            if (b1->lower == b2->lower)
                return 0;
            else
                return b1->lower ? 1 : -1;
        }
        else if (!b1->inclusive)
            return b1->lower ? 1 : -1;
        else if (!b2->inclusive)
            return b2->lower ? -1 : 1;
        else
        {
            /*
             * Both are inclusive and the values held are equal, so they are
             * equal regardless of whether they are upper or lower boundaries,
             * or a mix.
             */
            return 0;
        }
    }
 
    return result;
}

References DatumGetInt32(), FunctionCall2Coll(), RangeBound::inclusive, RangeBound::infinite, RangeBound::lower, TypeCacheEntry::rng_cmp_proc_finfo, TypeCacheEntry::rng_collation, and RangeBound::val.

Referenced by adjacent_cmp_bounds(), adjacent_inner_consistent(), bound_cmp(), calc_hist_selectivity_contained(), getQuadrant(), interval_cmp_lower(), interval_cmp_upper(), multirange_before_multirange_internal(), multirange_cmp(), multirange_contains_multirange_internal(), multirange_eq_internal(), multirange_overlaps_multirange_internal(), multirange_overleft_multirange(), multirange_overleft_range(), multirange_overright_multirange(), multirange_overright_range(), multirange_range_contains_bsearch_comparison(), multirange_range_overlaps_bsearch_comparison(), multirange_union_range_equal(), range_after_internal(), range_after_multirange_internal(), range_before_internal(), range_before_multirange_internal(), range_bound_qsort_cmp(), range_bounds_contains(), range_bounds_overlaps(), range_cmp(), range_compare(), range_contains_internal(), range_eq_internal(), range_gist_double_sorting_split(), range_gist_penalty(), range_intersect_internal(), range_minus_internal(), range_overlaps_internal(), range_overleft_internal(), range_overleft_multirange_internal(), range_overright_internal(), range_overright_multirange_internal(), range_split_internal(), range_super_union(), range_union_internal(), rbound_bsearch(), single_bound_cmp(), and spg_range_quad_inner_consistent().

range_compare()

int range_compare	(	const void *	key1,
		const void *	key2,
		void *	arg
	)

Definition at line 2129 of file rangetypes.c.

{
    RangeType  *r1 = *(RangeType **) key1;
    RangeType  *r2 = *(RangeType **) key2;
    TypeCacheEntry *typcache = (TypeCacheEntry *) arg;
    RangeBound  lower1;
    RangeBound  upper1;
    RangeBound  lower2;
    RangeBound  upper2;
    bool        empty1;
    bool        empty2;
    int         cmp;
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    if (empty1 && empty2)
        cmp = 0;
    else if (empty1)
        cmp = -1;
    else if (empty2)
        cmp = 1;
    else
    {
        cmp = range_cmp_bounds(typcache, &lower1, &lower2);
        if (cmp == 0)
            cmp = range_cmp_bounds(typcache, &upper1, &upper2);
    }
 
    return cmp;
}

References arg, cmp(), range_cmp_bounds(), and range_deserialize().

Referenced by multirange_canonicalize().

range_contained_by_internal()

bool range_contained_by_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 2618 of file rangetypes.c.

{
    return range_contains_internal(typcache, r2, r1);
}

References range_contains_internal().

Referenced by range_contained_by(), range_gist_consistent_leaf_range(), and spg_range_quad_leaf_consistent().

range_contains_elem_internal()

bool range_contains_elem_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r,
		Datum	val
	)

Definition at line 2627 of file rangetypes.c.

{
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
    int32       cmp;
 
    range_deserialize(typcache, r, &lower, &upper, &empty);
 
    if (empty)
        return false;
 
    if (!lower.infinite)
    {
        cmp = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
                                              typcache->rng_collation,
                                              lower.val, val));
        if (cmp > 0)
            return false;
        if (cmp == 0 && !lower.inclusive)
            return false;
    }
 
    if (!upper.infinite)
    {
        cmp = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
                                              typcache->rng_collation,
                                              upper.val, val));
        if (cmp < 0)
            return false;
        if (cmp == 0 && !upper.inclusive)
            return false;
    }
 
    return true;
}

References cmp(), DatumGetInt32(), FunctionCall2Coll(), lower(), range_deserialize(), TypeCacheEntry::rng_cmp_proc_finfo, TypeCacheEntry::rng_collation, upper(), and val.

Referenced by elem_contained_by_range(), range_contains_elem(), range_gist_consistent_int_element(), range_gist_consistent_leaf_element(), and spg_range_quad_leaf_consistent().

range_contains_internal()

bool range_contains_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 2586 of file rangetypes.c.

{
    RangeBound  lower1;
    RangeBound  upper1;
    bool        empty1;
    RangeBound  lower2;
    RangeBound  upper2;
    bool        empty2;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    /* If either range is empty, the answer is easy */
    if (empty2)
        return true;
    else if (empty1)
        return false;
 
    /* Else we must have lower1 <= lower2 and upper1 >= upper2 */
    if (range_cmp_bounds(typcache, &lower1, &lower2) > 0)
        return false;
    if (range_cmp_bounds(typcache, &upper1, &upper2) < 0)
        return false;
 
    return true;
}

References elog, ERROR, range_cmp_bounds(), range_deserialize(), and RangeTypeGetOid.

Referenced by range_contained_by_internal(), range_contains(), range_gist_consistent_int_range(), range_gist_consistent_leaf_range(), and spg_range_quad_leaf_consistent().

range_deserialize()

void range_deserialize	(	TypeCacheEntry *	typcache,
		const RangeType *	range,
		RangeBound *	lower,
		RangeBound *	upper,
		bool *	empty
	)

Definition at line 1856 of file rangetypes.c.

{
    char        flags;
    int16       typlen;
    bool        typbyval;
    char        typalign;
    Pointer     ptr;
    Datum       lbound;
    Datum       ubound;
 
    /* assert caller passed the right typcache entry */
    Assert(RangeTypeGetOid(range) == typcache->type_id);
 
    /* fetch the flag byte from datum's last byte */
    flags = *((const char *) range + VARSIZE(range) - 1);
 
    /* fetch information about range's element type */
    typlen = typcache->rngelemtype->typlen;
    typbyval = typcache->rngelemtype->typbyval;
    typalign = typcache->rngelemtype->typalign;
 
    /* initialize data pointer just after the range OID */
    ptr = (Pointer) (range + 1);
 
    /* fetch lower bound, if any */
    if (RANGE_HAS_LBOUND(flags))
    {
        /* att_align_pointer cannot be necessary here */
        lbound = fetch_att(ptr, typbyval, typlen);
        ptr = (Pointer) att_addlength_pointer(ptr, typlen, ptr);
    }
    else
        lbound = (Datum) 0;
 
    /* fetch upper bound, if any */
    if (RANGE_HAS_UBOUND(flags))
    {
        ptr = (Pointer) att_align_pointer(ptr, typalign, typlen, ptr);
        ubound = fetch_att(ptr, typbyval, typlen);
        /* no need for att_addlength_pointer */
    }
    else
        ubound = (Datum) 0;
 
    /* emit results */
 
    *empty = (flags & RANGE_EMPTY) != 0;
 
    lower->val = lbound;
    lower->infinite = (flags & RANGE_LB_INF) != 0;
    lower->inclusive = (flags & RANGE_LB_INC) != 0;
    lower->lower = true;
 
    upper->val = ubound;
    upper->infinite = (flags & RANGE_UB_INF) != 0;
    upper->inclusive = (flags & RANGE_UB_INC) != 0;
    upper->lower = false;
}

References Assert, att_addlength_pointer, att_align_pointer, fetch_att(), lower(), range(), RANGE_EMPTY, RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, RANGE_LB_INC, RANGE_LB_INF, RANGE_UB_INC, RANGE_UB_INF, RangeTypeGetOid, TypeCacheEntry::rngelemtype, typalign, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TypeCacheEntry::typlen, upper(), and VARSIZE.

Referenced by calc_hist_selectivity(), compute_range_stats(), daterange_canonical(), find_simplified_clause(), getQuadrant(), hash_range(), hash_range_extended(), int4range_canonical(), int8range_canonical(), multirange_contains_range_internal(), multirange_overleft_range(), multirange_overright_range(), multirange_union_range_equal(), range_adjacent_internal(), range_adjacent_multirange_internal(), range_after_internal(), range_after_multirange_internal(), range_before_internal(), range_before_multirange_internal(), range_cmp(), range_compare(), range_contains_elem_internal(), range_contains_internal(), range_contains_multirange_internal(), range_eq_internal(), range_gist_double_sorting_split(), range_gist_penalty(), range_gist_single_sorting_split(), range_intersect_internal(), range_lower(), range_minus_internal(), range_out(), range_overlaps_internal(), range_overlaps_multirange_internal(), range_overleft_internal(), range_overleft_multirange_internal(), range_overright_internal(), range_overright_multirange_internal(), range_send(), range_split_internal(), range_super_union(), range_union_internal(), range_upper(), spg_range_quad_inner_consistent(), and spg_range_quad_picksplit().

range_eq_internal()

bool range_eq_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 573 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    if (empty1 && empty2)
        return true;
    if (empty1 != empty2)
        return false;
 
    if (range_cmp_bounds(typcache, &lower1, &lower2) != 0)
        return false;
 
    if (range_cmp_bounds(typcache, &upper1, &upper2) != 0)
        return false;
 
    return true;
}

References elog, ERROR, range_cmp_bounds(), range_deserialize(), and RangeTypeGetOid.

Referenced by range_eq(), range_gist_consistent_leaf_range(), range_gist_same(), range_ne_internal(), and spg_range_quad_leaf_consistent().

range_get_flags()

char range_get_flags

(

const RangeType *

range

)

Definition at line 1923 of file rangetypes.c.

{
    /* fetch the flag byte from datum's last byte */
    return *((char *) range + VARSIZE(range) - 1);
}

References range(), and VARSIZE.

Referenced by get_gist_range_class(), hash_range(), hash_range_extended(), range_empty(), range_gist_same(), range_lower_inc(), range_lower_inf(), range_out(), range_send(), range_super_union(), range_upper_inc(), and range_upper_inf().

range_get_typcache()

TypeCacheEntry* range_get_typcache	(	FunctionCallInfo	fcinfo,
		Oid	rngtypid
	)

Definition at line 1703 of file rangetypes.c.

{
    TypeCacheEntry *typcache = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
 
    if (typcache == NULL ||
        typcache->type_id != rngtypid)
    {
        typcache = lookup_type_cache(rngtypid, TYPECACHE_RANGE_INFO);
        if (typcache->rngelemtype == NULL)
            elog(ERROR, "type %u is not a range type", rngtypid);
        fcinfo->flinfo->fn_extra = (void *) typcache;
    }
 
    return typcache;
}

References elog, ERROR, FunctionCallInfoBaseData::flinfo, FmgrInfo::fn_extra, if(), lookup_type_cache(), TypeCacheEntry::rngelemtype, TypeCacheEntry::type_id, and TYPECACHE_RANGE_INFO.

Referenced by daterange_canonical(), elem_contained_by_range(), hash_range(), hash_range_extended(), int4range_canonical(), int8range_canonical(), multirange_gist_consistent(), range_adjacent(), range_after(), range_before(), range_cmp(), range_constructor2(), range_constructor3(), range_contained_by(), range_contains(), range_contains_elem(), range_eq(), range_gist_consistent(), range_gist_penalty(), range_gist_picksplit(), range_gist_same(), range_gist_union(), range_intersect(), range_intersect_agg_transfn(), range_lower(), range_merge(), range_minus(), range_ne(), range_overlaps(), range_overleft(), range_overright(), range_typanalyze(), range_union(), range_upper(), rangesel(), spg_range_quad_choose(), spg_range_quad_inner_consistent(), spg_range_quad_leaf_consistent(), and spg_range_quad_picksplit().

range_intersect_internal()

RangeType* range_intersect_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 1143 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
    RangeBound *result_lower;
    RangeBound *result_upper;
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    if (empty1 || empty2 || !range_overlaps_internal(typcache, r1, r2))
        return make_empty_range(typcache);
 
    if (range_cmp_bounds(typcache, &lower1, &lower2) >= 0)
        result_lower = &lower1;
    else
        result_lower = &lower2;
 
    if (range_cmp_bounds(typcache, &upper1, &upper2) <= 0)
        result_upper = &upper1;
    else
        result_upper = &upper2;
 
    return make_range(typcache, result_lower, result_upper, false, NULL);
}

References make_empty_range(), make_range(), range_cmp_bounds(), range_deserialize(), and range_overlaps_internal().

Referenced by multirange_intersect_internal(), range_intersect(), and range_intersect_agg_transfn().

range_minus_internal()

RangeType* range_minus_internal	(	TypeCacheEntry *	typcache,
		RangeType *	r1,
		RangeType *	r2
	)

Definition at line 993 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
    int         cmp_l1l2,
                cmp_l1u2,
                cmp_u1l2,
                cmp_u1u2;
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    /* if either is empty, r1 is the correct answer */
    if (empty1 || empty2)
        return r1;
 
    cmp_l1l2 = range_cmp_bounds(typcache, &lower1, &lower2);
    cmp_l1u2 = range_cmp_bounds(typcache, &lower1, &upper2);
    cmp_u1l2 = range_cmp_bounds(typcache, &upper1, &lower2);
    cmp_u1u2 = range_cmp_bounds(typcache, &upper1, &upper2);
 
    if (cmp_l1l2 < 0 && cmp_u1u2 > 0)
        ereport(ERROR,
                (errcode(ERRCODE_DATA_EXCEPTION),
                 errmsg("result of range difference would not be contiguous")));
 
    if (cmp_l1u2 > 0 || cmp_u1l2 < 0)
        return r1;
 
    if (cmp_l1l2 >= 0 && cmp_u1u2 <= 0)
        return make_empty_range(typcache);
 
    if (cmp_l1l2 <= 0 && cmp_u1l2 >= 0 && cmp_u1u2 <= 0)
    {
        lower2.inclusive = !lower2.inclusive;
        lower2.lower = false;   /* it will become the upper bound */
        return make_range(typcache, &lower1, &lower2, false, NULL);
    }
 
    if (cmp_l1l2 >= 0 && cmp_u1u2 >= 0 && cmp_l1u2 <= 0)
    {
        upper2.inclusive = !upper2.inclusive;
        upper2.lower = true;    /* it will become the lower bound */
        return make_range(typcache, &upper2, &upper1, false, NULL);
    }
 
    elog(ERROR, "unexpected case in range_minus");
    return NULL;
}

References elog, ereport, errcode(), errmsg(), ERROR, RangeBound::inclusive, RangeBound::lower, make_empty_range(), make_range(), range_cmp_bounds(), and range_deserialize().

Referenced by multirange_minus_internal(), and range_minus().

range_ne_internal()

bool range_ne_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 618 of file rangetypes.c.

{
    return (!range_eq_internal(typcache, r1, r2));
}

References range_eq_internal().

Referenced by range_ne().

range_overlaps_internal()

bool range_overlaps_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 841 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    /* An empty range does not overlap any other range */
    if (empty1 || empty2)
        return false;
 
    if (range_cmp_bounds(typcache, &lower1, &lower2) >= 0 &&
        range_cmp_bounds(typcache, &lower1, &upper2) <= 0)
        return true;
 
    if (range_cmp_bounds(typcache, &lower2, &lower1) >= 0 &&
        range_cmp_bounds(typcache, &lower2, &upper1) <= 0)
        return true;
 
    return false;
}

References elog, ERROR, range_cmp_bounds(), range_deserialize(), and RangeTypeGetOid.

Referenced by multirange_intersect_internal(), multirange_minus_internal(), range_gist_consistent_int_range(), range_gist_consistent_leaf_range(), range_intersect_internal(), range_overlaps(), range_union_internal(), and spg_range_quad_leaf_consistent().

range_overleft_internal()

bool range_overleft_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 887 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    /* An empty range is neither before nor after any other range */
    if (empty1 || empty2)
        return false;
 
    if (range_cmp_bounds(typcache, &upper1, &upper2) <= 0)
        return true;
 
    return false;
}

References elog, ERROR, range_cmp_bounds(), range_deserialize(), and RangeTypeGetOid.

Referenced by multirange_intersect_internal(), range_gist_consistent_int_range(), range_gist_consistent_leaf_range(), range_overleft(), and spg_range_quad_leaf_consistent().

range_overright_internal()

bool range_overright_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2
	)

Definition at line 928 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    /* An empty range is neither before nor after any other range */
    if (empty1 || empty2)
        return false;
 
    if (range_cmp_bounds(typcache, &lower1, &lower2) >= 0)
        return true;
 
    return false;
}

References elog, ERROR, range_cmp_bounds(), range_deserialize(), and RangeTypeGetOid.

Referenced by range_gist_consistent_int_range(), range_gist_consistent_leaf_range(), range_overright(), and spg_range_quad_leaf_consistent().

range_serialize()

RangeType* range_serialize	(	TypeCacheEntry *	typcache,
		RangeBound *	lower,
		RangeBound *	upper,
		bool	empty,
		struct Node *	escontext
	)

Definition at line 1727 of file rangetypes.c.

{
    RangeType  *range;
    int         cmp;
    Size        msize;
    Pointer     ptr;
    int16       typlen;
    bool        typbyval;
    char        typalign;
    char        typstorage;
    char        flags = 0;
 
    /*
     * Verify range is not invalid on its face, and construct flags value,
     * preventing any non-canonical combinations such as infinite+inclusive.
     */
    Assert(lower->lower);
    Assert(!upper->lower);
 
    if (empty)
        flags |= RANGE_EMPTY;
    else
    {
        cmp = range_cmp_bound_values(typcache, lower, upper);
 
        /* error check: if lower bound value is above upper, it's wrong */
        if (cmp > 0)
            ereturn(escontext, NULL,
                    (errcode(ERRCODE_DATA_EXCEPTION),
                     errmsg("range lower bound must be less than or equal to range upper bound")));
 
        /* if bounds are equal, and not both inclusive, range is empty */
        if (cmp == 0 && !(lower->inclusive && upper->inclusive))
            flags |= RANGE_EMPTY;
        else
        {
            /* infinite boundaries are never inclusive */
            if (lower->infinite)
                flags |= RANGE_LB_INF;
            else if (lower->inclusive)
                flags |= RANGE_LB_INC;
            if (upper->infinite)
                flags |= RANGE_UB_INF;
            else if (upper->inclusive)
                flags |= RANGE_UB_INC;
        }
    }
 
    /* Fetch information about range's element type */
    typlen = typcache->rngelemtype->typlen;
    typbyval = typcache->rngelemtype->typbyval;
    typalign = typcache->rngelemtype->typalign;
    typstorage = typcache->rngelemtype->typstorage;
 
    /* Count space for varlena header and range type's OID */
    msize = sizeof(RangeType);
    Assert(msize == MAXALIGN(msize));
 
    /* Count space for bounds */
    if (RANGE_HAS_LBOUND(flags))
    {
        /*
         * Make sure item to be inserted is not toasted.  It is essential that
         * we not insert an out-of-line toast value pointer into a range
         * object, for the same reasons that arrays and records can't contain
         * them.  It would work to store a compressed-in-line value, but we
         * prefer to decompress and then let compression be applied to the
         * whole range object if necessary.  But, unlike arrays, we do allow
         * short-header varlena objects to stay as-is.
         */
        if (typlen == -1)
            lower->val = PointerGetDatum(PG_DETOAST_DATUM_PACKED(lower->val));
 
        msize = datum_compute_size(msize, lower->val, typbyval, typalign,
                                   typlen, typstorage);
    }
 
    if (RANGE_HAS_UBOUND(flags))
    {
        /* Make sure item to be inserted is not toasted */
        if (typlen == -1)
            upper->val = PointerGetDatum(PG_DETOAST_DATUM_PACKED(upper->val));
 
        msize = datum_compute_size(msize, upper->val, typbyval, typalign,
                                   typlen, typstorage);
    }
 
    /* Add space for flag byte */
    msize += sizeof(char);
 
    /* Note: zero-fill is required here, just as in heap tuples */
    range = (RangeType *) palloc0(msize);
    SET_VARSIZE(range, msize);
 
    /* Now fill in the datum */
    range->rangetypid = typcache->type_id;
 
    ptr = (char *) (range + 1);
 
    if (RANGE_HAS_LBOUND(flags))
    {
        Assert(lower->lower);
        ptr = datum_write(ptr, lower->val, typbyval, typalign, typlen,
                          typstorage);
    }
 
    if (RANGE_HAS_UBOUND(flags))
    {
        Assert(!upper->lower);
        ptr = datum_write(ptr, upper->val, typbyval, typalign, typlen,
                          typstorage);
    }
 
    *((char *) ptr) = flags;
 
    return range;
}

References Assert, cmp(), datum_compute_size(), datum_write(), ereturn, errcode(), errmsg(), lower(), MAXALIGN, palloc0(), PG_DETOAST_DATUM_PACKED, PointerGetDatum(), range(), range_cmp_bound_values(), RANGE_EMPTY, RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, RANGE_LB_INC, RANGE_LB_INF, RANGE_UB_INC, RANGE_UB_INF, TypeCacheEntry::rngelemtype, SET_VARSIZE, typalign, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, TypeCacheEntry::typlen, TypeCacheEntry::typstorage, and upper().

Referenced by compute_range_stats(), daterange_canonical(), int4range_canonical(), int8range_canonical(), make_range(), multirangesel(), rangesel(), and spg_range_quad_picksplit().

range_set_contain_empty()

void range_set_contain_empty

(

RangeType *

range

)

Definition at line 1937 of file rangetypes.c.

{
    char       *flagsp;
 
    /* flag byte is datum's last byte */
    flagsp = (char *) range + VARSIZE(range) - 1;
 
    *flagsp |= RANGE_CONTAIN_EMPTY;
}

References range(), RANGE_CONTAIN_EMPTY, and VARSIZE.

Referenced by range_super_union().

range_split_internal()

bool range_split_internal	(	TypeCacheEntry *	typcache,
		const RangeType *	r1,
		const RangeType *	r2,
		RangeType **	output1,
		RangeType **	output2
	)

Definition at line 1182 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    if (range_cmp_bounds(typcache, &lower1, &lower2) < 0 &&
        range_cmp_bounds(typcache, &upper1, &upper2) > 0)
    {
        /*
         * Need to invert inclusive/exclusive for the lower2 and upper2
         * points. They can't be infinite though. We're allowed to overwrite
         * these RangeBounds since they only exist locally.
         */
        lower2.inclusive = !lower2.inclusive;
        lower2.lower = false;
        upper2.inclusive = !upper2.inclusive;
        upper2.lower = true;
 
        *output1 = make_range(typcache, &lower1, &lower2, false, NULL);
        *output2 = make_range(typcache, &upper2, &upper1, false, NULL);
        return true;
    }
 
    return false;
}

References RangeBound::inclusive, RangeBound::lower, make_range(), range_cmp_bounds(), and range_deserialize().

Referenced by multirange_minus_internal().

range_union_internal()

RangeType* range_union_internal	(	TypeCacheEntry *	typcache,
		RangeType *	r1,
		RangeType *	r2,
		bool	strict
	)

Definition at line 1052 of file rangetypes.c.

{
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
    RangeBound *result_lower;
    RangeBound *result_upper;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    /* if either is empty, the other is the correct answer */
    if (empty1)
        return r2;
    if (empty2)
        return r1;
 
    if (strict &&
        !DatumGetBool(range_overlaps_internal(typcache, r1, r2)) &&
        !DatumGetBool(range_adjacent_internal(typcache, r1, r2)))
        ereport(ERROR,
                (errcode(ERRCODE_DATA_EXCEPTION),
                 errmsg("result of range union would not be contiguous")));
 
    if (range_cmp_bounds(typcache, &lower1, &lower2) < 0)
        result_lower = &lower1;
    else
        result_lower = &lower2;
 
    if (range_cmp_bounds(typcache, &upper1, &upper2) > 0)
        result_upper = &upper1;
    else
        result_upper = &upper2;
 
    return make_range(typcache, result_lower, result_upper, false, NULL);
}

References DatumGetBool(), elog, ereport, errcode(), errmsg(), ERROR, make_range(), range_adjacent_internal(), range_cmp_bounds(), range_deserialize(), range_overlaps_internal(), and RangeTypeGetOid.

Referenced by multirange_canonicalize(), range_merge(), and range_union().

RangeTypePGetDatum()

static Datum RangeTypePGetDatum ( const RangeType *  X )

inlinestatic

Definition at line 85 of file rangetypes.h.

{
    return PointerGetDatum(X);

References PointerGetDatum().

Referenced by make_range(), multirange_agg_transfn(), multirange_gist_compress(), multirange_out(), multirange_send(), multirange_unnest(), range_gist_class_split(), range_gist_fallback_split(), range_gist_single_sorting_split(), spg_range_quad_choose(), and spg_range_quad_picksplit().