#include "utils/typcache.h"

Include dependency graph for rangetypes.h:

This graph shows which files directly or indirectly include 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.

75 {

76 return (RangeType *) PG_DETOAST_DATUM(X);

PG_DETOAST_DATUM

#define PG_DETOAST_DATUM(datum)

Definition: fmgr.h:240

References PG_DETOAST_DATUM.

Referenced by calc_hist_selectivity(), compute_range_stats(), ExecWithoutOverlapsNotEmpty(), 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.

81 {

82 return (RangeType *) PG_DETOAST_DATUM_COPY(X);

PG_DETOAST_DATUM_COPY

#define PG_DETOAST_DATUM_COPY(datum)

Definition: fmgr.h:242

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 = 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.

87 {

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

Data Structures

Macros

Functions

Macro Definition Documentation

◆ PG_GETARG_RANGE_P

◆ PG_GETARG_RANGE_P_COPY

◆ PG_RETURN_RANGE_P

◆ RANGE_CONTAIN_EMPTY

◆ RANGE_EMPTY

◆ RANGE_EMPTY_LITERAL

◆ RANGE_HAS_LBOUND

◆ RANGE_HAS_UBOUND

◆ RANGE_LB_INC

◆ RANGE_LB_INF

◆ RANGE_LB_NULL

◆ RANGE_UB_INC

◆ RANGE_UB_INF

◆ RANGE_UB_NULL

◆ RangeIsEmpty

◆ RangeIsOrContainsEmpty

◆ RANGESTRAT_ADJACENT

◆ RANGESTRAT_AFTER

◆ RANGESTRAT_BEFORE

◆ RANGESTRAT_CONTAINED_BY

◆ RANGESTRAT_CONTAINS

◆ RANGESTRAT_CONTAINS_ELEM

◆ RANGESTRAT_EQ

◆ RANGESTRAT_OVERLAPS

◆ RANGESTRAT_OVERLEFT

◆ RANGESTRAT_OVERRIGHT

◆ RangeTypeGetOid

Function Documentation

◆ bounds_adjacent()

◆ DatumGetRangeTypeP()

◆ DatumGetRangeTypePCopy()

◆ make_empty_range()

◆ make_range()

◆ range_adjacent_internal()

◆ range_after_internal()

◆ range_before_internal()

◆ range_cmp_bound_values()

◆ range_cmp_bounds()

◆ range_compare()

◆ range_contained_by_internal()

◆ range_contains_elem_internal()

◆ range_contains_internal()

◆ range_deserialize()

◆ range_eq_internal()

◆ range_get_flags()

◆ range_get_typcache()

◆ range_intersect_internal()

◆ range_minus_internal()

◆ range_ne_internal()

◆ range_overlaps_internal()

◆ range_overleft_internal()

◆ range_overright_internal()

◆ range_serialize()

◆ range_set_contain_empty()

◆ range_split_internal()

◆ range_union_internal()

◆ RangeTypePGetDatum()