rangetypes.c File Reference

#include "postgres.h"
#include "common/hashfn.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/miscnodes.h"
#include "nodes/supportnodes.h"
#include "optimizer/clauses.h"
#include "optimizer/cost.h"
#include "optimizer/optimizer.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/lsyscache.h"
#include "utils/rangetypes.h"
#include "utils/sortsupport.h"
#include "utils/timestamp.h"

Include dependency graph for rangetypes.c:

Go to the source code of this file.

Data Structures
struct	RangeIOData

Macros
#define	TYPE_IS_PACKABLE(typlen, typstorage)    ((typlen) == -1 && (typstorage) != TYPSTORAGE_PLAIN)

Typedefs
typedef struct RangeIOData	RangeIOData

Functions
static RangeIOData *	get_range_io_data (FunctionCallInfo fcinfo, Oid rngtypid, IOFuncSelector func)
static int	range_fast_cmp (Datum a, Datum b, SortSupport ssup)
static char	range_parse_flags (const char *flags_str)
static bool	range_parse (const char *string, char *flags, char **lbound_str, char **ubound_str, Node *escontext)
static const char *	range_parse_bound (const char *string, const char *ptr, char **bound_str, bool *infinite, Node *escontext)
static char *	range_deparse (char flags, const char *lbound_str, const char *ubound_str)
static char *	range_bound_escape (const char *value)
static Size	datum_compute_size (Size data_length, Datum val, bool typbyval, char typalign, int16 typlen, char typstorage)
static Pointer	datum_write (Pointer ptr, Datum datum, bool typbyval, char typalign, int16 typlen, char typstorage)
static Node *	find_simplified_clause (PlannerInfo *root, Expr *rangeExpr, Expr *elemExpr)
static Expr *	build_bound_expr (Expr *elemExpr, Datum val, bool isLowerBound, bool isInclusive, TypeCacheEntry *typeCache, Oid opfamily, Oid rng_collation)
Datum	range_in (PG_FUNCTION_ARGS)
Datum	range_out (PG_FUNCTION_ARGS)
Datum	range_recv (PG_FUNCTION_ARGS)
Datum	range_send (PG_FUNCTION_ARGS)
Datum	range_constructor2 (PG_FUNCTION_ARGS)
Datum	range_constructor3 (PG_FUNCTION_ARGS)
Datum	range_lower (PG_FUNCTION_ARGS)
Datum	range_upper (PG_FUNCTION_ARGS)
Datum	range_empty (PG_FUNCTION_ARGS)
Datum	range_lower_inc (PG_FUNCTION_ARGS)
Datum	range_upper_inc (PG_FUNCTION_ARGS)
Datum	range_lower_inf (PG_FUNCTION_ARGS)
Datum	range_upper_inf (PG_FUNCTION_ARGS)
Datum	range_contains_elem (PG_FUNCTION_ARGS)
Datum	elem_contained_by_range (PG_FUNCTION_ARGS)
bool	range_eq_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Datum	range_eq (PG_FUNCTION_ARGS)
bool	range_ne_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Datum	range_ne (PG_FUNCTION_ARGS)
Datum	range_contains (PG_FUNCTION_ARGS)
Datum	range_contained_by (PG_FUNCTION_ARGS)
bool	range_before_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Datum	range_before (PG_FUNCTION_ARGS)
bool	range_after_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Datum	range_after (PG_FUNCTION_ARGS)
bool	bounds_adjacent (TypeCacheEntry *typcache, RangeBound boundA, RangeBound boundB)
bool	range_adjacent_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Datum	range_adjacent (PG_FUNCTION_ARGS)
bool	range_overlaps_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Datum	range_overlaps (PG_FUNCTION_ARGS)
bool	range_overleft_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Datum	range_overleft (PG_FUNCTION_ARGS)
bool	range_overright_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Datum	range_overright (PG_FUNCTION_ARGS)
Datum	range_minus (PG_FUNCTION_ARGS)
RangeType *	range_minus_internal (TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
RangeType *	range_union_internal (TypeCacheEntry *typcache, RangeType *r1, RangeType *r2, bool strict)
Datum	range_union (PG_FUNCTION_ARGS)
Datum	range_merge (PG_FUNCTION_ARGS)
Datum	range_intersect (PG_FUNCTION_ARGS)
RangeType *	range_intersect_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
bool	range_split_internal (TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2, RangeType **output1, RangeType **output2)
Datum	range_intersect_agg_transfn (PG_FUNCTION_ARGS)
Datum	range_cmp (PG_FUNCTION_ARGS)
Datum	range_sortsupport (PG_FUNCTION_ARGS)
Datum	range_lt (PG_FUNCTION_ARGS)
Datum	range_le (PG_FUNCTION_ARGS)
Datum	range_ge (PG_FUNCTION_ARGS)
Datum	range_gt (PG_FUNCTION_ARGS)
Datum	hash_range (PG_FUNCTION_ARGS)
Datum	hash_range_extended (PG_FUNCTION_ARGS)
Datum	int4range_canonical (PG_FUNCTION_ARGS)
Datum	int8range_canonical (PG_FUNCTION_ARGS)
Datum	daterange_canonical (PG_FUNCTION_ARGS)
Datum	int4range_subdiff (PG_FUNCTION_ARGS)
Datum	int8range_subdiff (PG_FUNCTION_ARGS)
Datum	numrange_subdiff (PG_FUNCTION_ARGS)
Datum	daterange_subdiff (PG_FUNCTION_ARGS)
Datum	tsrange_subdiff (PG_FUNCTION_ARGS)
Datum	tstzrange_subdiff (PG_FUNCTION_ARGS)
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)
RangeType *	make_empty_range (TypeCacheEntry *typcache)
Datum	elem_contained_by_range_support (PG_FUNCTION_ARGS)
Datum	range_contains_elem_support (PG_FUNCTION_ARGS)
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_contains_elem_internal (TypeCacheEntry *typcache, const RangeType *r, Datum val)

Macro Definition Documentation

TYPE_IS_PACKABLE

#define TYPE_IS_PACKABLE	(		typlen,
			typstorage
	)		((typlen) == -1 && (typstorage) != TYPSTORAGE_PLAIN)

Definition at line 2737 of file rangetypes.c.

Typedef Documentation

RangeIOData

typedef struct RangeIOData RangeIOData

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

build_bound_expr()

static Expr * build_bound_expr ( Expr *  elemExpr, Datum  val, bool  isLowerBound, bool  isInclusive, TypeCacheEntry *  typeCache, Oid  opfamily, Oid  rng_collation  )

static

Definition at line 2970 of file rangetypes.c.

{
    Oid         elemType = typeCache->type_id;
    int16       elemTypeLen = typeCache->typlen;
    bool        elemByValue = typeCache->typbyval;
    Oid         elemCollation = typeCache->typcollation;
    int16       strategy;
    Oid         oproid;
    Expr       *constExpr;
 
    /* Identify the comparison operator to use */
    if (isLowerBound)
        strategy = isInclusive ? BTGreaterEqualStrategyNumber : BTGreaterStrategyNumber;
    else
        strategy = isInclusive ? BTLessEqualStrategyNumber : BTLessStrategyNumber;
 
    /*
     * We could use exprType(elemExpr) here, if it ever becomes possible that
     * elemExpr is not the exact same type as the range elements.
     */
    oproid = get_opfamily_member(opfamily, elemType, elemType, strategy);
 
    /* We don't really expect failure here, but just in case ... */
    if (!OidIsValid(oproid))
        return NULL;
 
    /* OK, convert "val" to a full-fledged Const node, and make the OpExpr */
    constExpr = (Expr *) makeConst(elemType,
                                   -1,
                                   elemCollation,
                                   elemTypeLen,
                                   val,
                                   false,
                                   elemByValue);
 
    return make_opclause(oproid,
                         BOOLOID,
                         false,
                         elemExpr,
                         constExpr,
                         InvalidOid,
                         rng_collation);
}

References BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, BTLessStrategyNumber, get_opfamily_member(), InvalidOid, make_opclause(), makeConst(), OidIsValid, TypeCacheEntry::typbyval, TypeCacheEntry::typcollation, TypeCacheEntry::type_id, TypeCacheEntry::typlen, and val.

Referenced by find_simplified_clause().

daterange_canonical()

Datum daterange_canonical

(

PG_FUNCTION_ARGS

)

Definition at line 1620 of file rangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    Node       *escontext = fcinfo->context;
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
 
    range_deserialize(typcache, r, &lower, &upper, &empty);
 
    if (empty)
        PG_RETURN_RANGE_P(r);
 
    if (!lower.infinite && !DATE_NOT_FINITE(DatumGetDateADT(lower.val)) &&
        !lower.inclusive)
    {
        DateADT     bnd = DatumGetDateADT(lower.val);
 
        /* Check for overflow -- note we already eliminated PG_INT32_MAX */
        bnd++;
        if (unlikely(!IS_VALID_DATE(bnd)))
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("date out of range")));
        lower.val = DateADTGetDatum(bnd);
        lower.inclusive = true;
    }
 
    if (!upper.infinite && !DATE_NOT_FINITE(DatumGetDateADT(upper.val)) &&
        upper.inclusive)
    {
        DateADT     bnd = DatumGetDateADT(upper.val);
 
        /* Check for overflow -- note we already eliminated PG_INT32_MAX */
        bnd++;
        if (unlikely(!IS_VALID_DATE(bnd)))
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                     errmsg("date out of range")));
        upper.val = DateADTGetDatum(bnd);
        upper.inclusive = false;
    }
 
    PG_RETURN_RANGE_P(range_serialize(typcache, &lower, &upper,
                                      false, escontext));
}

References DATE_NOT_FINITE, DateADTGetDatum(), DatumGetDateADT(), ereturn, errcode(), errmsg(), IS_VALID_DATE, lower(), PG_GETARG_RANGE_P, PG_RETURN_RANGE_P, range_deserialize(), range_get_typcache(), range_serialize(), RangeTypeGetOid, unlikely, and upper().

daterange_subdiff()

Datum daterange_subdiff

(

PG_FUNCTION_ARGS

)

Definition at line 1717 of file rangetypes.c.

{
    int32       v1 = PG_GETARG_INT32(0);
    int32       v2 = PG_GETARG_INT32(1);
 
    PG_RETURN_FLOAT8((float8) v1 - (float8) v2);
}

References PG_GETARG_INT32, and PG_RETURN_FLOAT8.

datum_compute_size()

static Size datum_compute_size ( Size  data_length, Datum  val, bool  typbyval, char  typalign, int16  typlen, char  typstorage  )

static

Definition at line 2745 of file rangetypes.c.

{
    if (TYPE_IS_PACKABLE(typlen, typstorage) &&
        VARATT_CAN_MAKE_SHORT(DatumGetPointer(val)))
    {
        /*
         * we're anticipating converting to a short varlena header, so adjust
         * length and don't count any alignment
         */
        data_length += VARATT_CONVERTED_SHORT_SIZE(DatumGetPointer(val));
    }
    else
    {
        data_length = att_align_datum(data_length, typalign, typlen, val);
        data_length = att_addlength_datum(data_length, typlen, val);
    }
 
    return data_length;
}

References att_addlength_datum, att_align_datum, DatumGetPointer(), typalign, TYPE_IS_PACKABLE, val, VARATT_CAN_MAKE_SHORT(), and VARATT_CONVERTED_SHORT_SIZE().

Referenced by range_serialize().

datum_write()

static Pointer datum_write ( Pointer  ptr, Datum  datum, bool  typbyval, char  typalign, int16  typlen, char  typstorage  )

static

Definition at line 2771 of file rangetypes.c.

{
    Size        data_length;
 
    if (typbyval)
    {
        /* pass-by-value */
        ptr = (char *) att_align_nominal(ptr, typalign);
        store_att_byval(ptr, datum, typlen);
        data_length = typlen;
    }
    else if (typlen == -1)
    {
        /* varlena */
        Pointer     val = DatumGetPointer(datum);
 
        if (VARATT_IS_EXTERNAL(val))
        {
            /*
             * Throw error, because we must never put a toast pointer inside a
             * range object.  Caller should have detoasted it.
             */
            elog(ERROR, "cannot store a toast pointer inside a range");
            data_length = 0;    /* keep compiler quiet */
        }
        else if (VARATT_IS_SHORT(val))
        {
            /* no alignment for short varlenas */
            data_length = VARSIZE_SHORT(val);
            memcpy(ptr, val, data_length);
        }
        else if (TYPE_IS_PACKABLE(typlen, typstorage) &&
                 VARATT_CAN_MAKE_SHORT(val))
        {
            /* convert to short varlena -- no alignment */
            data_length = VARATT_CONVERTED_SHORT_SIZE(val);
            SET_VARSIZE_SHORT(ptr, data_length);
            memcpy(ptr + 1, VARDATA(val), data_length - 1);
        }
        else
        {
            /* full 4-byte header varlena */
            ptr = (char *) att_align_nominal(ptr, typalign);
            data_length = VARSIZE(val);
            memcpy(ptr, val, data_length);
        }
    }
    else if (typlen == -2)
    {
        /* cstring ... never needs alignment */
        Assert(typalign == TYPALIGN_CHAR);
        data_length = strlen(DatumGetCString(datum)) + 1;
        memcpy(ptr, DatumGetPointer(datum), data_length);
    }
    else
    {
        /* fixed-length pass-by-reference */
        ptr = (char *) att_align_nominal(ptr, typalign);
        Assert(typlen > 0);
        data_length = typlen;
        memcpy(ptr, DatumGetPointer(datum), data_length);
    }
 
    ptr += data_length;
 
    return ptr;
}

References Assert(), att_align_nominal, DatumGetCString(), DatumGetPointer(), elog, ERROR, SET_VARSIZE_SHORT(), store_att_byval(), typalign, TYPE_IS_PACKABLE, val, VARATT_CAN_MAKE_SHORT(), VARATT_CONVERTED_SHORT_SIZE(), VARATT_IS_EXTERNAL(), VARATT_IS_SHORT(), VARDATA(), VARSIZE(), and VARSIZE_SHORT().

Referenced by range_serialize().

elem_contained_by_range()

Datum elem_contained_by_range

(

PG_FUNCTION_ARGS

)

Definition at line 557 of file rangetypes.c.

{
    Datum       val = PG_GETARG_DATUM(0);
    RangeType  *r = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
 
    PG_RETURN_BOOL(range_contains_elem_internal(typcache, r, val));
}

References PG_GETARG_DATUM, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_contains_elem_internal(), range_get_typcache(), RangeTypeGetOid, and val.

elem_contained_by_range_support()

Datum elem_contained_by_range_support

(

PG_FUNCTION_ARGS

)

Definition at line 2249 of file rangetypes.c.

{
    Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
    Node       *ret = NULL;
 
    if (IsA(rawreq, SupportRequestSimplify))
    {
        SupportRequestSimplify *req = (SupportRequestSimplify *) rawreq;
        FuncExpr   *fexpr = req->fcall;
        Expr       *leftop,
                   *rightop;
 
        Assert(list_length(fexpr->args) == 2);
        leftop = linitial(fexpr->args);
        rightop = lsecond(fexpr->args);
 
        ret = find_simplified_clause(req->root, rightop, leftop);
    }
 
    PG_RETURN_POINTER(ret);
}

References FuncExpr::args, Assert(), SupportRequestSimplify::fcall, find_simplified_clause(), IsA, linitial, list_length(), lsecond, PG_GETARG_POINTER, PG_RETURN_POINTER, and SupportRequestSimplify::root.

find_simplified_clause()

static Node * find_simplified_clause ( PlannerInfo *  root, Expr *  rangeExpr, Expr *  elemExpr  )

static

Definition at line 2848 of file rangetypes.c.

{
    RangeType  *range;
    TypeCacheEntry *rangetypcache;
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
 
    /* can't do anything unless the range is a non-null constant */
    if (!IsA(rangeExpr, Const) || ((Const *) rangeExpr)->constisnull)
        return NULL;
    range = DatumGetRangeTypeP(((Const *) rangeExpr)->constvalue);
 
    rangetypcache = lookup_type_cache(RangeTypeGetOid(range),
                                      TYPECACHE_RANGE_INFO);
    if (rangetypcache->rngelemtype == NULL)
        elog(ERROR, "type %u is not a range type", RangeTypeGetOid(range));
 
    range_deserialize(rangetypcache, range, &lower, &upper, &empty);
 
    if (empty)
    {
        /* if the range is empty, then there can be no matches */
        return makeBoolConst(false, false);
    }
    else if (lower.infinite && upper.infinite)
    {
        /* the range has infinite bounds, so it matches everything */
        return makeBoolConst(true, false);
    }
    else
    {
        /* at least one bound is available, we have something to work with */
        TypeCacheEntry *elemTypcache = rangetypcache->rngelemtype;
        Oid         opfamily = rangetypcache->rng_opfamily;
        Oid         rng_collation = rangetypcache->rng_collation;
        Expr       *lowerExpr = NULL;
        Expr       *upperExpr = NULL;
 
        if (!lower.infinite && !upper.infinite)
        {
            /*
             * When both bounds are present, we have a problem: the
             * "simplified" clause would need to evaluate the elemExpr twice.
             * That's definitely not okay if the elemExpr is volatile, and
             * it's also unattractive if the elemExpr is expensive.
             */
            QualCost    eval_cost;
 
            if (contain_volatile_functions((Node *) elemExpr))
                return NULL;
 
            /*
             * We define "expensive" as "contains any subplan or more than 10
             * operators".  Note that the subplan search has to be done
             * explicitly, since cost_qual_eval() will barf on unplanned
             * subselects.
             */
            if (contain_subplans((Node *) elemExpr))
                return NULL;
            cost_qual_eval_node(&eval_cost, (Node *) elemExpr, root);
            if (eval_cost.startup + eval_cost.per_tuple >
                10 * cpu_operator_cost)
                return NULL;
        }
 
        /* Okay, try to build boundary comparison expressions */
        if (!lower.infinite)
        {
            lowerExpr = build_bound_expr(elemExpr,
                                         lower.val,
                                         true,
                                         lower.inclusive,
                                         elemTypcache,
                                         opfamily,
                                         rng_collation);
            if (lowerExpr == NULL)
                return NULL;
        }
 
        if (!upper.infinite)
        {
            /* Copy the elemExpr if we need two copies */
            if (!lower.infinite)
                elemExpr = copyObject(elemExpr);
            upperExpr = build_bound_expr(elemExpr,
                                         upper.val,
                                         false,
                                         upper.inclusive,
                                         elemTypcache,
                                         opfamily,
                                         rng_collation);
            if (upperExpr == NULL)
                return NULL;
        }
 
        if (lowerExpr != NULL && upperExpr != NULL)
            return (Node *) make_andclause(list_make2(lowerExpr, upperExpr));
        else if (lowerExpr != NULL)
            return (Node *) lowerExpr;
        else if (upperExpr != NULL)
            return (Node *) upperExpr;
        else
        {
            Assert(false);
            return NULL;
        }
    }
}

References Assert(), build_bound_expr(), contain_subplans(), contain_volatile_functions(), copyObject, cost_qual_eval_node(), cpu_operator_cost, DatumGetRangeTypeP(), elog, ERROR, IsA, list_make2, lookup_type_cache(), lower(), make_andclause(), makeBoolConst(), QualCost::per_tuple, range(), range_deserialize(), RangeTypeGetOid, TypeCacheEntry::rng_collation, TypeCacheEntry::rng_opfamily, TypeCacheEntry::rngelemtype, root, QualCost::startup, TYPECACHE_RANGE_INFO, and upper().

Referenced by elem_contained_by_range_support(), and range_contains_elem_support().

get_range_io_data()

static RangeIOData * get_range_io_data ( FunctionCallInfo  fcinfo, Oid  rngtypid, IOFuncSelector  func  )

static

Definition at line 317 of file rangetypes.c.

{
    RangeIOData *cache = (RangeIOData *) fcinfo->flinfo->fn_extra;
 
    if (cache == NULL || cache->typcache->type_id != rngtypid)
    {
        int16       typlen;
        bool        typbyval;
        char        typalign;
        char        typdelim;
        Oid         typiofunc;
 
        cache = (RangeIOData *) MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                   sizeof(RangeIOData));
        cache->typcache = lookup_type_cache(rngtypid, TYPECACHE_RANGE_INFO);
        if (cache->typcache->rngelemtype == NULL)
            elog(ERROR, "type %u is not a range type", rngtypid);
 
        /* get_type_io_data does more than we need, but is convenient */
        get_type_io_data(cache->typcache->rngelemtype->type_id,
                         func,
                         &typlen,
                         &typbyval,
                         &typalign,
                         &typdelim,
                         &cache->typioparam,
                         &typiofunc);
 
        if (!OidIsValid(typiofunc))
        {
            /* this could only happen for receive or send */
            if (func == IOFunc_receive)
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("no binary input function available for type %s",
                                format_type_be(cache->typcache->rngelemtype->type_id))));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("no binary output function available for type %s",
                                format_type_be(cache->typcache->rngelemtype->type_id))));
        }
        fmgr_info_cxt(typiofunc, &cache->typioproc,
                      fcinfo->flinfo->fn_mcxt);
 
        fcinfo->flinfo->fn_extra = cache;
    }
 
    return cache;
}

References elog, ereport, errcode(), errmsg(), ERROR, FunctionCallInfoBaseData::flinfo, fmgr_info_cxt(), FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, format_type_be(), get_type_io_data(), if(), IOFunc_receive, lookup_type_cache(), MemoryContextAlloc(), OidIsValid, TypeCacheEntry::rngelemtype, typalign, RangeIOData::typcache, TypeCacheEntry::type_id, TYPECACHE_RANGE_INFO, RangeIOData::typioparam, and RangeIOData::typioproc.

Referenced by range_in(), range_out(), range_recv(), and range_send().

hash_range()

Datum hash_range

(

PG_FUNCTION_ARGS

)

Definition at line 1392 of file rangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    uint32      result;
    TypeCacheEntry *typcache;
    TypeCacheEntry *scache;
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
    char        flags;
    uint32      lower_hash;
    uint32      upper_hash;
 
    check_stack_depth();        /* recurses when subtype is a range type */
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
 
    /* deserialize */
    range_deserialize(typcache, r, &lower, &upper, &empty);
    flags = range_get_flags(r);
 
    /*
     * Look up the element type's hash function, if not done already.
     */
    scache = typcache->rngelemtype;
    if (!OidIsValid(scache->hash_proc_finfo.fn_oid))
    {
        scache = lookup_type_cache(scache->type_id, TYPECACHE_HASH_PROC_FINFO);
        if (!OidIsValid(scache->hash_proc_finfo.fn_oid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("could not identify a hash function for type %s",
                            format_type_be(scache->type_id))));
    }
 
    /*
     * Apply the hash function to each bound.
     */
    if (RANGE_HAS_LBOUND(flags))
        lower_hash = DatumGetUInt32(FunctionCall1Coll(&scache->hash_proc_finfo,
                                                      typcache->rng_collation,
                                                      lower.val));
    else
        lower_hash = 0;
 
    if (RANGE_HAS_UBOUND(flags))
        upper_hash = DatumGetUInt32(FunctionCall1Coll(&scache->hash_proc_finfo,
                                                      typcache->rng_collation,
                                                      upper.val));
    else
        upper_hash = 0;
 
    /* Merge hashes of flags and bounds */
    result = hash_bytes_uint32((uint32) flags);
    result ^= lower_hash;
    result = pg_rotate_left32(result, 1);
    result ^= upper_hash;
 
    PG_RETURN_INT32(result);
}

References check_stack_depth(), DatumGetUInt32(), ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCall1Coll(), hash_bytes_uint32(), TypeCacheEntry::hash_proc_finfo, lookup_type_cache(), lower(), OidIsValid, PG_GETARG_RANGE_P, PG_RETURN_INT32, pg_rotate_left32(), range_deserialize(), range_get_flags(), range_get_typcache(), RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, RangeTypeGetOid, TypeCacheEntry::rng_collation, TypeCacheEntry::rngelemtype, TypeCacheEntry::type_id, TYPECACHE_HASH_PROC_FINFO, and upper().

hash_range_extended()

Datum hash_range_extended

(

PG_FUNCTION_ARGS

)

Definition at line 1458 of file rangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    Datum       seed = PG_GETARG_DATUM(1);
    uint64      result;
    TypeCacheEntry *typcache;
    TypeCacheEntry *scache;
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
    char        flags;
    uint64      lower_hash;
    uint64      upper_hash;
 
    check_stack_depth();
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
 
    range_deserialize(typcache, r, &lower, &upper, &empty);
    flags = range_get_flags(r);
 
    scache = typcache->rngelemtype;
    if (!OidIsValid(scache->hash_extended_proc_finfo.fn_oid))
    {
        scache = lookup_type_cache(scache->type_id,
                                   TYPECACHE_HASH_EXTENDED_PROC_FINFO);
        if (!OidIsValid(scache->hash_extended_proc_finfo.fn_oid))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_FUNCTION),
                     errmsg("could not identify a hash function for type %s",
                            format_type_be(scache->type_id))));
    }
 
    if (RANGE_HAS_LBOUND(flags))
        lower_hash = DatumGetUInt64(FunctionCall2Coll(&scache->hash_extended_proc_finfo,
                                                      typcache->rng_collation,
                                                      lower.val,
                                                      seed));
    else
        lower_hash = 0;
 
    if (RANGE_HAS_UBOUND(flags))
        upper_hash = DatumGetUInt64(FunctionCall2Coll(&scache->hash_extended_proc_finfo,
                                                      typcache->rng_collation,
                                                      upper.val,
                                                      seed));
    else
        upper_hash = 0;
 
    /* Merge hashes of flags and bounds */
    result = DatumGetUInt64(hash_uint32_extended((uint32) flags,
                                                 DatumGetInt64(seed)));
    result ^= lower_hash;
    result = ROTATE_HIGH_AND_LOW_32BITS(result);
    result ^= upper_hash;
 
    PG_RETURN_UINT64(result);
}

References check_stack_depth(), DatumGetInt64(), DatumGetUInt64(), ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCall2Coll(), TypeCacheEntry::hash_extended_proc_finfo, hash_uint32_extended(), lookup_type_cache(), lower(), OidIsValid, PG_GETARG_DATUM, PG_GETARG_RANGE_P, PG_RETURN_UINT64, range_deserialize(), range_get_flags(), range_get_typcache(), RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, RangeTypeGetOid, TypeCacheEntry::rng_collation, TypeCacheEntry::rngelemtype, ROTATE_HIGH_AND_LOW_32BITS, TypeCacheEntry::type_id, TYPECACHE_HASH_EXTENDED_PROC_FINFO, and upper().

int4range_canonical()

Datum int4range_canonical

(

PG_FUNCTION_ARGS

)

Definition at line 1526 of file rangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    Node       *escontext = fcinfo->context;
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
 
    range_deserialize(typcache, r, &lower, &upper, &empty);
 
    if (empty)
        PG_RETURN_RANGE_P(r);
 
    if (!lower.infinite && !lower.inclusive)
    {
        int32       bnd = DatumGetInt32(lower.val);
 
        /* Handle possible overflow manually */
        if (unlikely(bnd == PG_INT32_MAX))
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("integer out of range")));
        lower.val = Int32GetDatum(bnd + 1);
        lower.inclusive = true;
    }
 
    if (!upper.infinite && upper.inclusive)
    {
        int32       bnd = DatumGetInt32(upper.val);
 
        /* Handle possible overflow manually */
        if (unlikely(bnd == PG_INT32_MAX))
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("integer out of range")));
        upper.val = Int32GetDatum(bnd + 1);
        upper.inclusive = false;
    }
 
    PG_RETURN_RANGE_P(range_serialize(typcache, &lower, &upper,
                                      false, escontext));
}

References DatumGetInt32(), ereturn, errcode(), errmsg(), Int32GetDatum(), lower(), PG_GETARG_RANGE_P, PG_INT32_MAX, PG_RETURN_RANGE_P, range_deserialize(), range_get_typcache(), range_serialize(), RangeTypeGetOid, unlikely, and upper().

int4range_subdiff()

Datum int4range_subdiff

(

PG_FUNCTION_ARGS

)

Definition at line 1683 of file rangetypes.c.

{
    int32       v1 = PG_GETARG_INT32(0);
    int32       v2 = PG_GETARG_INT32(1);
 
    PG_RETURN_FLOAT8((float8) v1 - (float8) v2);
}

References PG_GETARG_INT32, and PG_RETURN_FLOAT8.

int8range_canonical()

Datum int8range_canonical

(

PG_FUNCTION_ARGS

)

Definition at line 1573 of file rangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    Node       *escontext = fcinfo->context;
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
 
    range_deserialize(typcache, r, &lower, &upper, &empty);
 
    if (empty)
        PG_RETURN_RANGE_P(r);
 
    if (!lower.infinite && !lower.inclusive)
    {
        int64       bnd = DatumGetInt64(lower.val);
 
        /* Handle possible overflow manually */
        if (unlikely(bnd == PG_INT64_MAX))
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("bigint out of range")));
        lower.val = Int64GetDatum(bnd + 1);
        lower.inclusive = true;
    }
 
    if (!upper.infinite && upper.inclusive)
    {
        int64       bnd = DatumGetInt64(upper.val);
 
        /* Handle possible overflow manually */
        if (unlikely(bnd == PG_INT64_MAX))
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("bigint out of range")));
        upper.val = Int64GetDatum(bnd + 1);
        upper.inclusive = false;
    }
 
    PG_RETURN_RANGE_P(range_serialize(typcache, &lower, &upper,
                                      false, escontext));
}

References DatumGetInt64(), ereturn, errcode(), errmsg(), Int64GetDatum(), lower(), PG_GETARG_RANGE_P, PG_INT64_MAX, PG_RETURN_RANGE_P, range_deserialize(), range_get_typcache(), range_serialize(), RangeTypeGetOid, unlikely, and upper().

int8range_subdiff()

Datum int8range_subdiff

(

PG_FUNCTION_ARGS

)

Definition at line 1692 of file rangetypes.c.

{
    int64       v1 = PG_GETARG_INT64(0);
    int64       v2 = PG_GETARG_INT64(1);
 
    PG_RETURN_FLOAT8((float8) v1 - (float8) v2);
}

References PG_GETARG_INT64, and PG_RETURN_FLOAT8.

make_empty_range()

RangeType * make_empty_range

(

TypeCacheEntry *

typcache

)

Definition at line 2227 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 2014 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().

numrange_subdiff()

Datum numrange_subdiff

(

PG_FUNCTION_ARGS

)

Definition at line 1701 of file rangetypes.c.

{
    Datum       v1 = PG_GETARG_DATUM(0);
    Datum       v2 = PG_GETARG_DATUM(1);
    Datum       numresult;
    float8      floatresult;
 
    numresult = DirectFunctionCall2(numeric_sub, v1, v2);
 
    floatresult = DatumGetFloat8(DirectFunctionCall1(numeric_float8,
                                                     numresult));
 
    PG_RETURN_FLOAT8(floatresult);
}

References DatumGetFloat8(), DirectFunctionCall1, DirectFunctionCall2, numeric_float8(), numeric_sub(), PG_GETARG_DATUM, and PG_RETURN_FLOAT8.

range_adjacent()

Datum range_adjacent

(

PG_FUNCTION_ARGS

)

Definition at line 828 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_BOOL(range_adjacent_internal(typcache, r1, r2));
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_adjacent_internal(), range_get_typcache(), and RangeTypeGetOid.

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

Datum range_after

(

PG_FUNCTION_ARGS

)

Definition at line 727 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_BOOL(range_after_internal(typcache, r1, r2));
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_after_internal(), range_get_typcache(), and RangeTypeGetOid.

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

Datum range_before

(

PG_FUNCTION_ARGS

)

Definition at line 689 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_BOOL(range_before_internal(typcache, r1, r2));
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_before_internal(), range_get_typcache(), and RangeTypeGetOid.

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_bound_escape()

static char * range_bound_escape ( const char *  value )

static

Definition at line 2599 of file rangetypes.c.

{
    bool        nq;
    const char *ptr;
    StringInfoData buf;
 
    initStringInfo(&buf);
 
    /* Detect whether we need double quotes for this value */
    nq = (value[0] == '\0');    /* force quotes for empty string */
    for (ptr = value; *ptr; ptr++)
    {
        char        ch = *ptr;
 
        if (ch == '"' || ch == '\\' ||
            ch == '(' || ch == ')' ||
            ch == '[' || ch == ']' ||
            ch == ',' ||
            isspace((unsigned char) ch))
        {
            nq = true;
            break;
        }
    }
 
    /* And emit the string */
    if (nq)
        appendStringInfoChar(&buf, '"');
    for (ptr = value; *ptr; ptr++)
    {
        char        ch = *ptr;
 
        if (ch == '"' || ch == '\\')
            appendStringInfoChar(&buf, ch);
        appendStringInfoChar(&buf, ch);
    }
    if (nq)
        appendStringInfoChar(&buf, '"');
 
    return buf.data;
}

References appendStringInfoChar(), buf, initStringInfo(), and value.

Referenced by range_deparse().

range_cmp()

Datum range_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 1249 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
    int         cmp;
 
    check_stack_depth();        /* recurses when subtype is a range type */
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
    range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
 
    /* For b-tree use, empty ranges sort before all else */
    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);
    }
 
    PG_FREE_IF_COPY(r1, 0);
    PG_FREE_IF_COPY(r2, 1);
 
    PG_RETURN_INT32(cmp);
}

References check_stack_depth(), cmp(), elog, ERROR, PG_FREE_IF_COPY, PG_GETARG_RANGE_P, PG_RETURN_INT32, range_cmp_bounds(), range_deserialize(), range_get_typcache(), and RangeTypeGetOid.

Referenced by range_ge(), range_gt(), range_le(), and range_lt().

range_cmp_bound_values()

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

Definition at line 2152 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 2078 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_fast_cmp(), 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 2191 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_constructor2()

Datum range_constructor2

(

PG_FUNCTION_ARGS

)

Definition at line 377 of file rangetypes.c.

{
    Datum       arg1 = PG_GETARG_DATUM(0);
    Datum       arg2 = PG_GETARG_DATUM(1);
    Oid         rngtypid = get_fn_expr_rettype(fcinfo->flinfo);
    RangeType  *range;
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
 
    typcache = range_get_typcache(fcinfo, rngtypid);
 
    lower.val = PG_ARGISNULL(0) ? (Datum) 0 : arg1;
    lower.infinite = PG_ARGISNULL(0);
    lower.inclusive = true;
    lower.lower = true;
 
    upper.val = PG_ARGISNULL(1) ? (Datum) 0 : arg2;
    upper.infinite = PG_ARGISNULL(1);
    upper.inclusive = false;
    upper.lower = false;
 
    range = make_range(typcache, &lower, &upper, false, NULL);
 
    PG_RETURN_RANGE_P(range);
}

References get_fn_expr_rettype(), lower(), make_range(), PG_ARGISNULL, PG_GETARG_DATUM, PG_RETURN_RANGE_P, range(), range_get_typcache(), and upper().

range_constructor3()

Datum range_constructor3

(

PG_FUNCTION_ARGS

)

Definition at line 406 of file rangetypes.c.

{
    Datum       arg1 = PG_GETARG_DATUM(0);
    Datum       arg2 = PG_GETARG_DATUM(1);
    Oid         rngtypid = get_fn_expr_rettype(fcinfo->flinfo);
    RangeType  *range;
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
    char        flags;
 
    typcache = range_get_typcache(fcinfo, rngtypid);
 
    if (PG_ARGISNULL(2))
        ereport(ERROR,
                (errcode(ERRCODE_DATA_EXCEPTION),
                 errmsg("range constructor flags argument must not be null")));
 
    flags = range_parse_flags(text_to_cstring(PG_GETARG_TEXT_PP(2)));
 
    lower.val = PG_ARGISNULL(0) ? (Datum) 0 : arg1;
    lower.infinite = PG_ARGISNULL(0);
    lower.inclusive = (flags & RANGE_LB_INC) != 0;
    lower.lower = true;
 
    upper.val = PG_ARGISNULL(1) ? (Datum) 0 : arg2;
    upper.infinite = PG_ARGISNULL(1);
    upper.inclusive = (flags & RANGE_UB_INC) != 0;
    upper.lower = false;
 
    range = make_range(typcache, &lower, &upper, false, NULL);
 
    PG_RETURN_RANGE_P(range);
}

References ereport, errcode(), errmsg(), ERROR, get_fn_expr_rettype(), lower(), make_range(), PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_TEXT_PP, PG_RETURN_RANGE_P, range(), range_get_typcache(), RANGE_LB_INC, range_parse_flags(), RANGE_UB_INC, text_to_cstring(), and upper().

range_contained_by()

Datum range_contained_by

(

PG_FUNCTION_ARGS

)

Definition at line 651 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_BOOL(range_contained_by_internal(typcache, r1, r2));
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_contained_by_internal(), range_get_typcache(), and RangeTypeGetOid.

range_contained_by_internal()

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

Definition at line 2680 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()

Datum range_contains

(

PG_FUNCTION_ARGS

)

Definition at line 638 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_BOOL(range_contains_internal(typcache, r1, r2));
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_contains_internal(), range_get_typcache(), and RangeTypeGetOid.

range_contains_elem()

Datum range_contains_elem

(

PG_FUNCTION_ARGS

)

Definition at line 544 of file rangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    Datum       val = PG_GETARG_DATUM(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
 
    PG_RETURN_BOOL(range_contains_elem_internal(typcache, r, val));
}

References PG_GETARG_DATUM, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_contains_elem_internal(), range_get_typcache(), RangeTypeGetOid, and val.

range_contains_elem_internal()

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

Definition at line 2689 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_elem_support()

Datum range_contains_elem_support

(

PG_FUNCTION_ARGS

)

Definition at line 2275 of file rangetypes.c.

{
    Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
    Node       *ret = NULL;
 
    if (IsA(rawreq, SupportRequestSimplify))
    {
        SupportRequestSimplify *req = (SupportRequestSimplify *) rawreq;
        FuncExpr   *fexpr = req->fcall;
        Expr       *leftop,
                   *rightop;
 
        Assert(list_length(fexpr->args) == 2);
        leftop = linitial(fexpr->args);
        rightop = lsecond(fexpr->args);
 
        ret = find_simplified_clause(req->root, leftop, rightop);
    }
 
    PG_RETURN_POINTER(ret);
}

References FuncExpr::args, Assert(), SupportRequestSimplify::fcall, find_simplified_clause(), IsA, linitial, list_length(), lsecond, PG_GETARG_POINTER, PG_RETURN_POINTER, and SupportRequestSimplify::root.

range_contains_internal()

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

Definition at line 2648 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_deparse()

static char * range_deparse ( char  flags, const char *  lbound_str, const char *  ubound_str  )

static

Definition at line 2569 of file rangetypes.c.

{
    StringInfoData buf;
 
    if (flags & RANGE_EMPTY)
        return pstrdup(RANGE_EMPTY_LITERAL);
 
    initStringInfo(&buf);
 
    appendStringInfoChar(&buf, (flags & RANGE_LB_INC) ? '[' : '(');
 
    if (RANGE_HAS_LBOUND(flags))
        appendStringInfoString(&buf, range_bound_escape(lbound_str));
 
    appendStringInfoChar(&buf, ',');
 
    if (RANGE_HAS_UBOUND(flags))
        appendStringInfoString(&buf, range_bound_escape(ubound_str));
 
    appendStringInfoChar(&buf, (flags & RANGE_UB_INC) ? ']' : ')');
 
    return buf.data;
}

References appendStringInfoChar(), appendStringInfoString(), buf, initStringInfo(), pstrdup(), range_bound_escape(), RANGE_EMPTY, RANGE_EMPTY_LITERAL, RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, RANGE_LB_INC, and RANGE_UB_INC.

Referenced by range_out().

range_deserialize()

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

Definition at line 1918 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_fast_cmp(), 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_empty()

Datum range_empty

(

PG_FUNCTION_ARGS

)

Definition at line 491 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    char        flags = range_get_flags(r1);
 
    PG_RETURN_BOOL(flags & RANGE_EMPTY);
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, RANGE_EMPTY, and range_get_flags().

range_eq()

Datum range_eq

(

PG_FUNCTION_ARGS

)

Definition at line 605 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_BOOL(range_eq_internal(typcache, r1, r2));
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_eq_internal(), range_get_typcache(), and RangeTypeGetOid.

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_fast_cmp()

static int range_fast_cmp ( Datum  a, Datum  b, SortSupport  ssup  )

static

Definition at line 1307 of file rangetypes.c.

{
    RangeType  *range_a = DatumGetRangeTypeP(a);
    RangeType  *range_b = DatumGetRangeTypeP(b);
    TypeCacheEntry *typcache;
    RangeBound  lower1,
                lower2;
    RangeBound  upper1,
                upper2;
    bool        empty1,
                empty2;
    int         cmp;
 
    /* cache the range info between calls */
    if (ssup->ssup_extra == NULL)
    {
        Assert(RangeTypeGetOid(range_a) == RangeTypeGetOid(range_b));
        ssup->ssup_extra =
            lookup_type_cache(RangeTypeGetOid(range_a), TYPECACHE_RANGE_INFO);
    }
    typcache = ssup->ssup_extra;
 
    range_deserialize(typcache, range_a, &lower1, &upper1, &empty1);
    range_deserialize(typcache, range_b, &lower2, &upper2, &empty2);
 
    /* For b-tree use, empty ranges sort before all else */
    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);
    }
 
    if ((Pointer) range_a != DatumGetPointer(a))
        pfree(range_a);
    if ((Pointer) range_b != DatumGetPointer(b))
        pfree(range_b);
 
    return cmp;
}

References a, Assert(), b, cmp(), DatumGetPointer(), DatumGetRangeTypeP(), lookup_type_cache(), pfree(), range_cmp_bounds(), range_deserialize(), RangeTypeGetOid, SortSupportData::ssup_extra, and TYPECACHE_RANGE_INFO.

Referenced by range_sortsupport().

range_ge()

Datum range_ge

(

PG_FUNCTION_ARGS

)

Definition at line 1373 of file rangetypes.c.

{
    int         cmp = DatumGetInt32(range_cmp(fcinfo));
 
    PG_RETURN_BOOL(cmp >= 0);
}

References cmp(), DatumGetInt32(), PG_RETURN_BOOL, and range_cmp().

range_get_flags()

char range_get_flags

(

const RangeType *

range

)

Definition at line 1985 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 1765 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_gt()

Datum range_gt

(

PG_FUNCTION_ARGS

)

Definition at line 1381 of file rangetypes.c.

{
    int         cmp = DatumGetInt32(range_cmp(fcinfo));
 
    PG_RETURN_BOOL(cmp > 0);
}

References cmp(), DatumGetInt32(), PG_RETURN_BOOL, and range_cmp().

range_in()

Datum range_in

(

PG_FUNCTION_ARGS

)

Definition at line 90 of file rangetypes.c.

{
    char       *input_str = PG_GETARG_CSTRING(0);
    Oid         rngtypoid = PG_GETARG_OID(1);
    Oid         typmod = PG_GETARG_INT32(2);
    Node       *escontext = fcinfo->context;
    RangeType  *range;
    RangeIOData *cache;
    char        flags;
    char       *lbound_str;
    char       *ubound_str;
    RangeBound  lower;
    RangeBound  upper;
 
    check_stack_depth();        /* recurses when subtype is a range type */
 
    cache = get_range_io_data(fcinfo, rngtypoid, IOFunc_input);
 
    /* parse */
    if (!range_parse(input_str, &flags, &lbound_str, &ubound_str, escontext))
        PG_RETURN_NULL();
 
    /* call element type's input function */
    if (RANGE_HAS_LBOUND(flags))
        if (!InputFunctionCallSafe(&cache->typioproc, lbound_str,
                                   cache->typioparam, typmod,
                                   escontext, &lower.val))
            PG_RETURN_NULL();
    if (RANGE_HAS_UBOUND(flags))
        if (!InputFunctionCallSafe(&cache->typioproc, ubound_str,
                                   cache->typioparam, typmod,
                                   escontext, &upper.val))
            PG_RETURN_NULL();
 
    lower.infinite = (flags & RANGE_LB_INF) != 0;
    lower.inclusive = (flags & RANGE_LB_INC) != 0;
    lower.lower = true;
    upper.infinite = (flags & RANGE_UB_INF) != 0;
    upper.inclusive = (flags & RANGE_UB_INC) != 0;
    upper.lower = false;
 
    /* serialize and canonicalize */
    range = make_range(cache->typcache, &lower, &upper,
                       flags & RANGE_EMPTY, escontext);
 
    PG_RETURN_RANGE_P(range);
}

References check_stack_depth(), get_range_io_data(), InputFunctionCallSafe(), IOFunc_input, lower(), make_range(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_RANGE_P, range(), RANGE_EMPTY, RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, RANGE_LB_INC, RANGE_LB_INF, range_parse(), RANGE_UB_INC, RANGE_UB_INF, RangeIOData::typcache, RangeIOData::typioparam, RangeIOData::typioproc, and upper().

range_intersect()

Datum range_intersect

(

PG_FUNCTION_ARGS

)

Definition at line 1127 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_RANGE_P(range_intersect_internal(typcache, r1, r2));
}

References elog, ERROR, PG_GETARG_RANGE_P, PG_RETURN_RANGE_P, range_get_typcache(), range_intersect_internal(), and RangeTypeGetOid.

range_intersect_agg_transfn()

Datum range_intersect_agg_transfn

(

PG_FUNCTION_ARGS

)

Definition at line 1219 of file rangetypes.c.

{
    MemoryContext aggContext;
    Oid         rngtypoid;
    TypeCacheEntry *typcache;
    RangeType  *result;
    RangeType  *current;
 
    if (!AggCheckCallContext(fcinfo, &aggContext))
        elog(ERROR, "range_intersect_agg_transfn called in non-aggregate context");
 
    rngtypoid = get_fn_expr_argtype(fcinfo->flinfo, 1);
    if (!type_is_range(rngtypoid))
        elog(ERROR, "range_intersect_agg must be called with a range");
 
    typcache = range_get_typcache(fcinfo, rngtypoid);
 
    /* strictness ensures these are non-null */
    result = PG_GETARG_RANGE_P(0);
    current = PG_GETARG_RANGE_P(1);
 
    result = range_intersect_internal(typcache, result, current);
    PG_RETURN_RANGE_P(result);
}

References AggCheckCallContext(), elog, ERROR, get_fn_expr_argtype(), PG_GETARG_RANGE_P, PG_RETURN_RANGE_P, range_get_typcache(), range_intersect_internal(), and type_is_range().

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_le()

Datum range_le

(

PG_FUNCTION_ARGS

)

Definition at line 1365 of file rangetypes.c.

{
    int         cmp = DatumGetInt32(range_cmp(fcinfo));
 
    PG_RETURN_BOOL(cmp <= 0);
}

References cmp(), DatumGetInt32(), PG_RETURN_BOOL, and range_cmp().

range_lower()

Datum range_lower

(

PG_FUNCTION_ARGS

)

Definition at line 446 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    range_deserialize(typcache, r1, &lower, &upper, &empty);
 
    /* Return NULL if there's no finite lower bound */
    if (empty || lower.infinite)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(lower.val);
}

References lower(), PG_GETARG_RANGE_P, PG_RETURN_DATUM, PG_RETURN_NULL, range_deserialize(), range_get_typcache(), RangeTypeGetOid, and upper().

range_lower_inc()

Datum range_lower_inc

(

PG_FUNCTION_ARGS

)

Definition at line 501 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    char        flags = range_get_flags(r1);
 
    PG_RETURN_BOOL(flags & RANGE_LB_INC);
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_get_flags(), and RANGE_LB_INC.

range_lower_inf()

Datum range_lower_inf

(

PG_FUNCTION_ARGS

)

Definition at line 521 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    char        flags = range_get_flags(r1);
 
    PG_RETURN_BOOL(flags & RANGE_LB_INF);
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_get_flags(), and RANGE_LB_INF.

range_lt()

Datum range_lt

(

PG_FUNCTION_ARGS

)

Definition at line 1357 of file rangetypes.c.

{
    int         cmp = DatumGetInt32(range_cmp(fcinfo));
 
    PG_RETURN_BOOL(cmp < 0);
}

References cmp(), DatumGetInt32(), PG_RETURN_BOOL, and range_cmp().

range_merge()

Datum range_merge

(

PG_FUNCTION_ARGS

)

Definition at line 1114 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_RANGE_P(range_union_internal(typcache, r1, r2, false));
}

References PG_GETARG_RANGE_P, PG_RETURN_RANGE_P, range_get_typcache(), range_union_internal(), and RangeTypeGetOid.

range_minus()

Datum range_minus

(

PG_FUNCTION_ARGS

)

Definition at line 972 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    RangeType  *ret;
    TypeCacheEntry *typcache;
 
    /* Different types should be prevented by ANYRANGE matching rules */
    if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
        elog(ERROR, "range types do not match");
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    ret = range_minus_internal(typcache, r1, r2);
    if (ret)
        PG_RETURN_RANGE_P(ret);
    else
        PG_RETURN_NULL();
}

References elog, ERROR, PG_GETARG_RANGE_P, PG_RETURN_NULL, PG_RETURN_RANGE_P, range_get_typcache(), range_minus_internal(), and RangeTypeGetOid.

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

Datum range_ne

(

PG_FUNCTION_ARGS

)

Definition at line 625 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_BOOL(range_ne_internal(typcache, r1, r2));
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_get_typcache(), range_ne_internal(), and RangeTypeGetOid.

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_out()

Datum range_out

(

PG_FUNCTION_ARGS

)

Definition at line 139 of file rangetypes.c.

{
    RangeType  *range = PG_GETARG_RANGE_P(0);
    char       *output_str;
    RangeIOData *cache;
    char        flags;
    char       *lbound_str = NULL;
    char       *ubound_str = NULL;
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
 
    check_stack_depth();        /* recurses when subtype is a range type */
 
    cache = get_range_io_data(fcinfo, RangeTypeGetOid(range), IOFunc_output);
 
    /* deserialize */
    range_deserialize(cache->typcache, range, &lower, &upper, &empty);
    flags = range_get_flags(range);
 
    /* call element type's output function */
    if (RANGE_HAS_LBOUND(flags))
        lbound_str = OutputFunctionCall(&cache->typioproc, lower.val);
    if (RANGE_HAS_UBOUND(flags))
        ubound_str = OutputFunctionCall(&cache->typioproc, upper.val);
 
    /* construct result string */
    output_str = range_deparse(flags, lbound_str, ubound_str);
 
    PG_RETURN_CSTRING(output_str);
}

References check_stack_depth(), get_range_io_data(), IOFunc_output, lower(), OutputFunctionCall(), PG_GETARG_RANGE_P, PG_RETURN_CSTRING, range(), range_deparse(), range_deserialize(), range_get_flags(), RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, RangeTypeGetOid, RangeIOData::typcache, RangeIOData::typioproc, and upper().

Referenced by anycompatiblerange_out(), and anyrange_out().

range_overlaps()

Datum range_overlaps

(

PG_FUNCTION_ARGS

)

Definition at line 874 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_BOOL(range_overlaps_internal(typcache, r1, r2));
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_get_typcache(), range_overlaps_internal(), and RangeTypeGetOid.

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

Datum range_overleft

(

PG_FUNCTION_ARGS

)

Definition at line 915 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_BOOL(range_overleft_internal(typcache, r1, r2));
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_get_typcache(), range_overleft_internal(), and RangeTypeGetOid.

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

Datum range_overright

(

PG_FUNCTION_ARGS

)

Definition at line 956 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_BOOL(range_overright_internal(typcache, r1, r2));
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_get_typcache(), range_overright_internal(), and RangeTypeGetOid.

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_parse()

static bool range_parse ( const char *  string, char *  flags, char **  lbound_str, char **  ubound_str, Node *  escontext  )

static

Definition at line 2384 of file rangetypes.c.

{
    const char *ptr = string;
    bool        infinite;
 
    *flags = 0;
 
    /* consume whitespace */
    while (*ptr != '\0' && isspace((unsigned char) *ptr))
        ptr++;
 
    /* check for empty range */
    if (pg_strncasecmp(ptr, RANGE_EMPTY_LITERAL,
                       strlen(RANGE_EMPTY_LITERAL)) == 0)
    {
        *flags = RANGE_EMPTY;
        *lbound_str = NULL;
        *ubound_str = NULL;
 
        ptr += strlen(RANGE_EMPTY_LITERAL);
 
        /* the rest should be whitespace */
        while (*ptr != '\0' && isspace((unsigned char) *ptr))
            ptr++;
 
        /* should have consumed everything */
        if (*ptr != '\0')
            ereturn(escontext, false,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed range literal: \"%s\"",
                            string),
                     errdetail("Junk after \"empty\" key word.")));
 
        return true;
    }
 
    if (*ptr == '[')
    {
        *flags |= RANGE_LB_INC;
        ptr++;
    }
    else if (*ptr == '(')
        ptr++;
    else
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed range literal: \"%s\"",
                        string),
                 errdetail("Missing left parenthesis or bracket.")));
 
    ptr = range_parse_bound(string, ptr, lbound_str, &infinite, escontext);
    if (ptr == NULL)
        return false;
    if (infinite)
        *flags |= RANGE_LB_INF;
 
    if (*ptr == ',')
        ptr++;
    else
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed range literal: \"%s\"",
                        string),
                 errdetail("Missing comma after lower bound.")));
 
    ptr = range_parse_bound(string, ptr, ubound_str, &infinite, escontext);
    if (ptr == NULL)
        return false;
    if (infinite)
        *flags |= RANGE_UB_INF;
 
    if (*ptr == ']')
    {
        *flags |= RANGE_UB_INC;
        ptr++;
    }
    else if (*ptr == ')')
        ptr++;
    else                        /* must be a comma */
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed range literal: \"%s\"",
                        string),
                 errdetail("Too many commas.")));
 
    /* consume whitespace */
    while (*ptr != '\0' && isspace((unsigned char) *ptr))
        ptr++;
 
    if (*ptr != '\0')
        ereturn(escontext, false,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed range literal: \"%s\"",
                        string),
                 errdetail("Junk after right parenthesis or bracket.")));
 
    return true;
}

References ereturn, errcode(), errdetail(), errmsg(), pg_strncasecmp(), RANGE_EMPTY, RANGE_EMPTY_LITERAL, RANGE_LB_INC, RANGE_LB_INF, range_parse_bound(), RANGE_UB_INC, and RANGE_UB_INF.

Referenced by range_in().

range_parse_bound()

static const char * range_parse_bound ( const char *  string, const char *  ptr, char **  bound_str, bool *  infinite, Node *  escontext  )

static

Definition at line 2500 of file rangetypes.c.

{
    StringInfoData buf;
 
    /* Check for null: completely empty input means null */
    if (*ptr == ',' || *ptr == ')' || *ptr == ']')
    {
        *bound_str = NULL;
        *infinite = true;
    }
    else
    {
        /* Extract string for this bound */
        bool        inquote = false;
 
        initStringInfo(&buf);
        while (inquote || !(*ptr == ',' || *ptr == ')' || *ptr == ']'))
        {
            char        ch = *ptr++;
 
            if (ch == '\0')
                ereturn(escontext, NULL,
                        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                         errmsg("malformed range literal: \"%s\"",
                                string),
                         errdetail("Unexpected end of input.")));
            if (ch == '\\')
            {
                if (*ptr == '\0')
                    ereturn(escontext, NULL,
                            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                             errmsg("malformed range literal: \"%s\"",
                                    string),
                             errdetail("Unexpected end of input.")));
                appendStringInfoChar(&buf, *ptr++);
            }
            else if (ch == '"')
            {
                if (!inquote)
                    inquote = true;
                else if (*ptr == '"')
                {
                    /* doubled quote within quote sequence */
                    appendStringInfoChar(&buf, *ptr++);
                }
                else
                    inquote = false;
            }
            else
                appendStringInfoChar(&buf, ch);
        }
 
        *bound_str = buf.data;
        *infinite = false;
    }
 
    return ptr;
}

References appendStringInfoChar(), buf, ereturn, errcode(), errdetail(), errmsg(), and initStringInfo().

Referenced by range_parse().

range_parse_flags()

static char range_parse_flags ( const char *  flags_str )

static

Definition at line 2309 of file rangetypes.c.

{
    char        flags = 0;
 
    if (flags_str[0] == '\0' ||
        flags_str[1] == '\0' ||
        flags_str[2] != '\0')
        ereport(ERROR,
                (errcode(ERRCODE_SYNTAX_ERROR),
                 errmsg("invalid range bound flags"),
                 errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
 
    switch (flags_str[0])
    {
        case '[':
            flags |= RANGE_LB_INC;
            break;
        case '(':
            break;
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("invalid range bound flags"),
                     errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
    }
 
    switch (flags_str[1])
    {
        case ']':
            flags |= RANGE_UB_INC;
            break;
        case ')':
            break;
        default:
            ereport(ERROR,
                    (errcode(ERRCODE_SYNTAX_ERROR),
                     errmsg("invalid range bound flags"),
                     errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
    }
 
    return flags;
}

References ereport, errcode(), errhint(), errmsg(), ERROR, RANGE_LB_INC, and RANGE_UB_INC.

Referenced by range_constructor3().

range_recv()

Datum range_recv

(

PG_FUNCTION_ARGS

)

Definition at line 179 of file rangetypes.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    Oid         rngtypoid = PG_GETARG_OID(1);
    int32       typmod = PG_GETARG_INT32(2);
    RangeType  *range;
    RangeIOData *cache;
    char        flags;
    RangeBound  lower;
    RangeBound  upper;
 
    check_stack_depth();        /* recurses when subtype is a range type */
 
    cache = get_range_io_data(fcinfo, rngtypoid, IOFunc_receive);
 
    /* receive the flags... */
    flags = (unsigned char) pq_getmsgbyte(buf);
 
    /*
     * Mask out any unsupported flags, particularly RANGE_xB_NULL which would
     * confuse following tests.  Note that range_serialize will take care of
     * cleaning up any inconsistencies in the remaining flags.
     */
    flags &= (RANGE_EMPTY |
              RANGE_LB_INC |
              RANGE_LB_INF |
              RANGE_UB_INC |
              RANGE_UB_INF);
 
    /* receive the bounds ... */
    if (RANGE_HAS_LBOUND(flags))
    {
        uint32      bound_len = pq_getmsgint(buf, 4);
        const char *bound_data = pq_getmsgbytes(buf, bound_len);
        StringInfoData bound_buf;
 
        initStringInfo(&bound_buf);
        appendBinaryStringInfo(&bound_buf, bound_data, bound_len);
 
        lower.val = ReceiveFunctionCall(&cache->typioproc,
                                        &bound_buf,
                                        cache->typioparam,
                                        typmod);
        pfree(bound_buf.data);
    }
    else
        lower.val = (Datum) 0;
 
    if (RANGE_HAS_UBOUND(flags))
    {
        uint32      bound_len = pq_getmsgint(buf, 4);
        const char *bound_data = pq_getmsgbytes(buf, bound_len);
        StringInfoData bound_buf;
 
        initStringInfo(&bound_buf);
        appendBinaryStringInfo(&bound_buf, bound_data, bound_len);
 
        upper.val = ReceiveFunctionCall(&cache->typioproc,
                                        &bound_buf,
                                        cache->typioparam,
                                        typmod);
        pfree(bound_buf.data);
    }
    else
        upper.val = (Datum) 0;
 
    pq_getmsgend(buf);
 
    /* finish constructing RangeBound representation */
    lower.infinite = (flags & RANGE_LB_INF) != 0;
    lower.inclusive = (flags & RANGE_LB_INC) != 0;
    lower.lower = true;
    upper.infinite = (flags & RANGE_UB_INF) != 0;
    upper.inclusive = (flags & RANGE_UB_INC) != 0;
    upper.lower = false;
 
    /* serialize and canonicalize */
    range = make_range(cache->typcache, &lower, &upper,
                       flags & RANGE_EMPTY, NULL);
 
    PG_RETURN_RANGE_P(range);
}

References appendBinaryStringInfo(), buf, check_stack_depth(), StringInfoData::data, get_range_io_data(), initStringInfo(), IOFunc_receive, lower(), make_range(), pfree(), PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_RANGE_P, pq_getmsgbyte(), pq_getmsgbytes(), pq_getmsgend(), pq_getmsgint(), range(), RANGE_EMPTY, RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, RANGE_LB_INC, RANGE_LB_INF, RANGE_UB_INC, RANGE_UB_INF, ReceiveFunctionCall(), RangeIOData::typcache, RangeIOData::typioparam, RangeIOData::typioproc, and upper().

range_send()

Datum range_send

(

PG_FUNCTION_ARGS

)

Definition at line 263 of file rangetypes.c.

{
    RangeType  *range = PG_GETARG_RANGE_P(0);
    StringInfo  buf = makeStringInfo();
    RangeIOData *cache;
    char        flags;
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
 
    check_stack_depth();        /* recurses when subtype is a range type */
 
    cache = get_range_io_data(fcinfo, RangeTypeGetOid(range), IOFunc_send);
 
    /* deserialize */
    range_deserialize(cache->typcache, range, &lower, &upper, &empty);
    flags = range_get_flags(range);
 
    /* construct output */
    pq_begintypsend(buf);
 
    pq_sendbyte(buf, flags);
 
    if (RANGE_HAS_LBOUND(flags))
    {
        bytea      *bound = SendFunctionCall(&cache->typioproc, lower.val);
        uint32      bound_len = VARSIZE(bound) - VARHDRSZ;
        char       *bound_data = VARDATA(bound);
 
        pq_sendint32(buf, bound_len);
        pq_sendbytes(buf, bound_data, bound_len);
    }
 
    if (RANGE_HAS_UBOUND(flags))
    {
        bytea      *bound = SendFunctionCall(&cache->typioproc, upper.val);
        uint32      bound_len = VARSIZE(bound) - VARHDRSZ;
        char       *bound_data = VARDATA(bound);
 
        pq_sendint32(buf, bound_len);
        pq_sendbytes(buf, bound_data, bound_len);
    }
 
    PG_RETURN_BYTEA_P(pq_endtypsend(buf));
}

References buf, check_stack_depth(), get_range_io_data(), IOFunc_send, lower(), makeStringInfo(), PG_GETARG_RANGE_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendbyte(), pq_sendbytes(), pq_sendint32(), range(), range_deserialize(), range_get_flags(), RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, RangeTypeGetOid, SendFunctionCall(), RangeIOData::typcache, RangeIOData::typioproc, upper(), VARDATA(), VARHDRSZ, and VARSIZE().

range_serialize()

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

Definition at line 1789 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 1999 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_sortsupport()

Datum range_sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 1295 of file rangetypes.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
 
    ssup->comparator = range_fast_cmp;
    ssup->ssup_extra = NULL;
 
    PG_RETURN_VOID();
}

References SortSupportData::comparator, PG_GETARG_POINTER, PG_RETURN_VOID, range_fast_cmp(), and SortSupportData::ssup_extra.

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

Datum range_union

(

PG_FUNCTION_ARGS

)

Definition at line 1098 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    RangeType  *r2 = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    PG_RETURN_RANGE_P(range_union_internal(typcache, r1, r2, true));
}

References PG_GETARG_RANGE_P, PG_RETURN_RANGE_P, range_get_typcache(), range_union_internal(), and RangeTypeGetOid.

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 &&
        !range_overlaps_internal(typcache, r1, r2) &&
        !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 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().

range_upper()

Datum range_upper

(

PG_FUNCTION_ARGS

)

Definition at line 467 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
    bool        empty;
 
    typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
 
    range_deserialize(typcache, r1, &lower, &upper, &empty);
 
    /* Return NULL if there's no finite upper bound */
    if (empty || upper.infinite)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(upper.val);
}

References lower(), PG_GETARG_RANGE_P, PG_RETURN_DATUM, PG_RETURN_NULL, range_deserialize(), range_get_typcache(), RangeTypeGetOid, and upper().

range_upper_inc()

Datum range_upper_inc

(

PG_FUNCTION_ARGS

)

Definition at line 511 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    char        flags = range_get_flags(r1);
 
    PG_RETURN_BOOL(flags & RANGE_UB_INC);
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_get_flags(), and RANGE_UB_INC.

range_upper_inf()

Datum range_upper_inf

(

PG_FUNCTION_ARGS

)

Definition at line 531 of file rangetypes.c.

{
    RangeType  *r1 = PG_GETARG_RANGE_P(0);
    char        flags = range_get_flags(r1);
 
    PG_RETURN_BOOL(flags & RANGE_UB_INF);
}

References PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_get_flags(), and RANGE_UB_INF.

tsrange_subdiff()

Datum tsrange_subdiff

(

PG_FUNCTION_ARGS

)

Definition at line 1726 of file rangetypes.c.

{
    Timestamp   v1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   v2 = PG_GETARG_TIMESTAMP(1);
    float8      result;
 
    result = ((float8) v1 - (float8) v2) / USECS_PER_SEC;
    PG_RETURN_FLOAT8(result);
}

References PG_GETARG_TIMESTAMP, PG_RETURN_FLOAT8, and USECS_PER_SEC.

tstzrange_subdiff()

Datum tstzrange_subdiff

(

PG_FUNCTION_ARGS

)

Definition at line 1737 of file rangetypes.c.

{
    Timestamp   v1 = PG_GETARG_TIMESTAMP(0);
    Timestamp   v2 = PG_GETARG_TIMESTAMP(1);
    float8      result;
 
    result = ((float8) v1 - (float8) v2) / USECS_PER_SEC;
    PG_RETURN_FLOAT8(result);
}

References PG_GETARG_TIMESTAMP, PG_RETURN_FLOAT8, and USECS_PER_SEC.