#include "postgres.h"
#include "access/tupmacs.h"
#include "common/hashfn.h"
#include "funcapi.h"
#include "lib/stringinfo.h"
#include "libpq/pqformat.h"
#include "nodes/nodes.h"
#include "port/pg_bitutils.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/lsyscache.h"
#include "utils/multirangetypes.h"
#include "utils/rangetypes.h"

Include dependency graph for multirangetypes.c:

Data Structures
struct	MultirangeIOData

Macros
#define	MultirangeGetItemsPtr(mr)

#define	MultirangeGetFlagsPtr(mr)

#define	MultirangeGetBoundariesPtr(mr, align)

#define	MULTIRANGE_ITEM_OFF_BIT 0x80000000

#define	MULTIRANGE_ITEM_GET_OFFLEN(item) ((item) & 0x7FFFFFFF)

#define	MULTIRANGE_ITEM_HAS_OFF(item) ((item) & MULTIRANGE_ITEM_OFF_BIT)

#define	MULTIRANGE_ITEM_OFFSET_STRIDE 4

Typedefs
typedef struct MultirangeIOData	MultirangeIOData

typedef int(*	multirange_bsearch_comparison) (TypeCacheEntry typcache, RangeBound lower, RangeBound upper, void key, bool *match)

Enumerations
enum	MultirangeParseState { MULTIRANGE_BEFORE_RANGE , MULTIRANGE_IN_RANGE , MULTIRANGE_IN_RANGE_ESCAPED , MULTIRANGE_IN_RANGE_QUOTED , MULTIRANGE_IN_RANGE_QUOTED_ESCAPED , MULTIRANGE_AFTER_RANGE , MULTIRANGE_FINISHED }

Functions
static MultirangeIOData *	get_multirange_io_data (FunctionCallInfo fcinfo, Oid mltrngtypid, IOFuncSelector func)

static int32	multirange_canonicalize (TypeCacheEntry rangetyp, int32 input_range_count, RangeType *ranges)

Datum	multirange_in (PG_FUNCTION_ARGS)

Datum	multirange_out (PG_FUNCTION_ARGS)

Datum	multirange_recv (PG_FUNCTION_ARGS)

Datum	multirange_send (PG_FUNCTION_ARGS)

TypeCacheEntry *	multirange_get_typcache (FunctionCallInfo fcinfo, Oid mltrngtypid)

static Size	multirange_size_estimate (TypeCacheEntry rangetyp, int32 range_count, RangeType *ranges)

static void	write_multirange_data (MultirangeType multirange, TypeCacheEntry rangetyp, int32 range_count, RangeType **ranges)

MultirangeType *	make_multirange (Oid mltrngtypoid, TypeCacheEntry rangetyp, int32 range_count, RangeType *ranges)

static uint32	multirange_get_bounds_offset (const MultirangeType *multirange, int32 i)

RangeType *	multirange_get_range (TypeCacheEntry rangetyp, const MultirangeType multirange, int i)

void	multirange_get_bounds (TypeCacheEntry rangetyp, const MultirangeType multirange, uint32 i, RangeBound lower, RangeBound upper)

RangeType *	multirange_get_union_range (TypeCacheEntry rangetyp, const MultirangeType mr)

void	multirange_deserialize (TypeCacheEntry rangetyp, const MultirangeType multirange, int32 range_count, RangeType **ranges)

MultirangeType *	make_empty_multirange (Oid mltrngtypoid, TypeCacheEntry *rangetyp)

static bool	range_bounds_overlaps (TypeCacheEntry typcache, RangeBound lower1, RangeBound upper1, RangeBound lower2, RangeBound *upper2)

static bool	range_bounds_contains (TypeCacheEntry typcache, RangeBound lower1, RangeBound upper1, RangeBound lower2, RangeBound *upper2)

static bool	multirange_bsearch_match (TypeCacheEntry typcache, const MultirangeType mr, void *key, multirange_bsearch_comparison cmp_func)

Datum	multirange_constructor2 (PG_FUNCTION_ARGS)

Datum	multirange_constructor1 (PG_FUNCTION_ARGS)

Datum	multirange_constructor0 (PG_FUNCTION_ARGS)

Datum	multirange_union (PG_FUNCTION_ARGS)

Datum	multirange_minus (PG_FUNCTION_ARGS)

MultirangeType *	multirange_minus_internal (Oid mltrngtypoid, TypeCacheEntry rangetyp, int32 range_count1, RangeType ranges1, int32 range_count2, RangeType *ranges2)

Datum	multirange_intersect (PG_FUNCTION_ARGS)

MultirangeType *	multirange_intersect_internal (Oid mltrngtypoid, TypeCacheEntry rangetyp, int32 range_count1, RangeType ranges1, int32 range_count2, RangeType *ranges2)

Datum	range_agg_transfn (PG_FUNCTION_ARGS)

Datum	range_agg_finalfn (PG_FUNCTION_ARGS)

Datum	multirange_agg_transfn (PG_FUNCTION_ARGS)

Datum	multirange_intersect_agg_transfn (PG_FUNCTION_ARGS)

Datum	multirange_lower (PG_FUNCTION_ARGS)

Datum	multirange_upper (PG_FUNCTION_ARGS)

Datum	multirange_empty (PG_FUNCTION_ARGS)

Datum	multirange_lower_inc (PG_FUNCTION_ARGS)

Datum	multirange_upper_inc (PG_FUNCTION_ARGS)

Datum	multirange_lower_inf (PG_FUNCTION_ARGS)

Datum	multirange_upper_inf (PG_FUNCTION_ARGS)

Datum	multirange_contains_elem (PG_FUNCTION_ARGS)

Datum	elem_contained_by_multirange (PG_FUNCTION_ARGS)

static int	multirange_elem_bsearch_comparison (TypeCacheEntry typcache, RangeBound lower, RangeBound upper, void key, bool *match)

bool	multirange_contains_elem_internal (TypeCacheEntry rangetyp, const MultirangeType mr, Datum val)

Datum	multirange_contains_range (PG_FUNCTION_ARGS)

Datum	range_contains_multirange (PG_FUNCTION_ARGS)

Datum	range_contained_by_multirange (PG_FUNCTION_ARGS)

Datum	multirange_contained_by_range (PG_FUNCTION_ARGS)

static int	multirange_range_contains_bsearch_comparison (TypeCacheEntry typcache, RangeBound lower, RangeBound upper, void key, bool *match)

bool	multirange_contains_range_internal (TypeCacheEntry rangetyp, const MultirangeType mr, const RangeType *r)

bool	range_contains_multirange_internal (TypeCacheEntry rangetyp, const RangeType r, const MultirangeType *mr)

bool	multirange_eq_internal (TypeCacheEntry rangetyp, const MultirangeType mr1, const MultirangeType *mr2)

Datum	multirange_eq (PG_FUNCTION_ARGS)

bool	multirange_ne_internal (TypeCacheEntry rangetyp, const MultirangeType mr1, const MultirangeType *mr2)

Datum	multirange_ne (PG_FUNCTION_ARGS)

Datum	range_overlaps_multirange (PG_FUNCTION_ARGS)

Datum	multirange_overlaps_range (PG_FUNCTION_ARGS)

Datum	multirange_overlaps_multirange (PG_FUNCTION_ARGS)

static int	multirange_range_overlaps_bsearch_comparison (TypeCacheEntry typcache, RangeBound lower, RangeBound upper, void key, bool *match)

bool	range_overlaps_multirange_internal (TypeCacheEntry rangetyp, const RangeType r, const MultirangeType *mr)

bool	multirange_overlaps_multirange_internal (TypeCacheEntry rangetyp, const MultirangeType mr1, const MultirangeType *mr2)

bool	range_overleft_multirange_internal (TypeCacheEntry rangetyp, const RangeType r, const MultirangeType *mr)

Datum	range_overleft_multirange (PG_FUNCTION_ARGS)

Datum	multirange_overleft_range (PG_FUNCTION_ARGS)

Datum	multirange_overleft_multirange (PG_FUNCTION_ARGS)

bool	range_overright_multirange_internal (TypeCacheEntry rangetyp, const RangeType r, const MultirangeType *mr)

Datum	range_overright_multirange (PG_FUNCTION_ARGS)

Datum	multirange_overright_range (PG_FUNCTION_ARGS)

Datum	multirange_overright_multirange (PG_FUNCTION_ARGS)

Datum	multirange_contains_multirange (PG_FUNCTION_ARGS)

Datum	multirange_contained_by_multirange (PG_FUNCTION_ARGS)

bool	multirange_contains_multirange_internal (TypeCacheEntry rangetyp, const MultirangeType mr1, const MultirangeType *mr2)

Datum	range_before_multirange (PG_FUNCTION_ARGS)

Datum	multirange_before_range (PG_FUNCTION_ARGS)

Datum	multirange_before_multirange (PG_FUNCTION_ARGS)

Datum	range_after_multirange (PG_FUNCTION_ARGS)

Datum	multirange_after_range (PG_FUNCTION_ARGS)

Datum	multirange_after_multirange (PG_FUNCTION_ARGS)

bool	range_before_multirange_internal (TypeCacheEntry rangetyp, const RangeType r, const MultirangeType *mr)

bool	multirange_before_multirange_internal (TypeCacheEntry rangetyp, const MultirangeType mr1, const MultirangeType *mr2)

bool	range_after_multirange_internal (TypeCacheEntry rangetyp, const RangeType r, const MultirangeType *mr)

bool	range_adjacent_multirange_internal (TypeCacheEntry rangetyp, const RangeType r, const MultirangeType *mr)

Datum	range_adjacent_multirange (PG_FUNCTION_ARGS)

Datum	multirange_adjacent_range (PG_FUNCTION_ARGS)

Datum	multirange_adjacent_multirange (PG_FUNCTION_ARGS)

Datum	multirange_cmp (PG_FUNCTION_ARGS)

Datum	multirange_lt (PG_FUNCTION_ARGS)

Datum	multirange_le (PG_FUNCTION_ARGS)

Datum	multirange_ge (PG_FUNCTION_ARGS)

Datum	multirange_gt (PG_FUNCTION_ARGS)

Datum	range_merge_from_multirange (PG_FUNCTION_ARGS)

Datum	multirange_unnest (PG_FUNCTION_ARGS)

Datum	hash_multirange (PG_FUNCTION_ARGS)

Datum	hash_multirange_extended (PG_FUNCTION_ARGS)

Macro Definition Documentation

◆ MULTIRANGE_ITEM_GET_OFFLEN

#define MULTIRANGE_ITEM_GET_OFFLEN ( item ) ((item) & 0x7FFFFFFF)

Definition at line 81 of file multirangetypes.c.

◆ MULTIRANGE_ITEM_HAS_OFF

#define MULTIRANGE_ITEM_HAS_OFF ( item ) ((item) & MULTIRANGE_ITEM_OFF_BIT)

Definition at line 82 of file multirangetypes.c.

◆ MULTIRANGE_ITEM_OFF_BIT

#define MULTIRANGE_ITEM_OFF_BIT 0x80000000

Definition at line 80 of file multirangetypes.c.

◆ MULTIRANGE_ITEM_OFFSET_STRIDE

#define MULTIRANGE_ITEM_OFFSET_STRIDE 4

Definition at line 83 of file multirangetypes.c.

◆ MultirangeGetBoundariesPtr

#define MultirangeGetBoundariesPtr	(	mr,
		align
	)

Value:

    ((Pointer) (mr) + \
    att_align_nominal(sizeof(MultirangeType) + \
        ((mr)->rangeCount - 1) * sizeof(uint32) + \
        (mr)->rangeCount * sizeof(uint8), (align)))

Definition at line 75 of file multirangetypes.c.

◆ MultirangeGetFlagsPtr

#define MultirangeGetFlagsPtr ( mr )

Value:

((uint8 *) ((Pointer) (mr) + \

sizeof(MultirangeType) + ((mr)->rangeCount - 1) * sizeof(uint32)))

Definition at line 73 of file multirangetypes.c.

◆ MultirangeGetItemsPtr

#define MultirangeGetItemsPtr ( mr )

Value:

((uint32 *) ((Pointer) (mr) + \

sizeof(MultirangeType)))

Definition at line 71 of file multirangetypes.c.

Typedef Documentation

◆ multirange_bsearch_comparison

typedef int(* multirange_bsearch_comparison) (TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper, void *key, bool *match)

Definition at line 85 of file multirangetypes.c.

◆ MultirangeIOData

typedef struct MultirangeIOData MultirangeIOData

Enumeration Type Documentation

◆ MultirangeParseState

enum MultirangeParseState

Enumerator
MULTIRANGE_BEFORE_RANGE
MULTIRANGE_IN_RANGE
MULTIRANGE_IN_RANGE_ESCAPED
MULTIRANGE_IN_RANGE_QUOTED
MULTIRANGE_IN_RANGE_QUOTED_ESCAPED
MULTIRANGE_AFTER_RANGE
MULTIRANGE_FINISHED

Definition at line 56 of file multirangetypes.c.

{
    MULTIRANGE_BEFORE_RANGE,
    MULTIRANGE_IN_RANGE,
    MULTIRANGE_IN_RANGE_ESCAPED,
    MULTIRANGE_IN_RANGE_QUOTED,
    MULTIRANGE_IN_RANGE_QUOTED_ESCAPED,
    MULTIRANGE_AFTER_RANGE,
    MULTIRANGE_FINISHED,
} MultirangeParseState;

Function Documentation

◆ elem_contained_by_multirange()

Datum elem_contained_by_multirange ( PG_FUNCTION_ARGS )

Definition at line 1659 of file multirangetypes.c.

{
    Datum       val = PG_GETARG_DATUM(0);
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(multirange_contains_elem_internal(typcache->rngtype, mr, val));
}

References multirange_contains_elem_internal(), multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_DATUM, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, TypeCacheEntry::rngtype, and val.

◆ get_multirange_io_data()

static MultirangeIOData * get_multirange_io_data	(	FunctionCallInfo	fcinfo,
		Oid	mltrngtypid,
		IOFuncSelector	func
	)

static

Definition at line 417 of file multirangetypes.c.

{
    MultirangeIOData *cache = (MultirangeIOData *) fcinfo->flinfo->fn_extra;
 
    if (cache == NULL || cache->typcache->type_id != mltrngtypid)
    {
        Oid         typiofunc;
        int16       typlen;
        bool        typbyval;
        char        typalign;
        char        typdelim;
 
        cache = (MultirangeIOData *) MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
                                                        sizeof(MultirangeIOData));
        cache->typcache = lookup_type_cache(mltrngtypid, TYPECACHE_MULTIRANGE_INFO);
        if (cache->typcache->rngtype == NULL)
            elog(ERROR, "type %u is not a multirange type", mltrngtypid);
 
        /* get_type_io_data does more than we need, but is convenient */
        get_type_io_data(cache->typcache->rngtype->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->rngtype->type_id))));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_UNDEFINED_FUNCTION),
                         errmsg("no binary output function available for type %s",
                                format_type_be(cache->typcache->rngtype->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::rngtype, typalign, MultirangeIOData::typcache, TypeCacheEntry::type_id, TYPECACHE_MULTIRANGE_INFO, MultirangeIOData::typioparam, and MultirangeIOData::typioproc.

Referenced by multirange_in(), multirange_out(), multirange_recv(), and multirange_send().

◆ hash_multirange()

Datum hash_multirange ( PG_FUNCTION_ARGS )

Definition at line 2787 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    uint32      result = 1;
    TypeCacheEntry *typcache,
               *scache;
    int32       range_count,
                i;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
    scache = typcache->rngtype->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))));
    }
 
    range_count = mr->rangeCount;
    for (i = 0; i < range_count; i++)
    {
        RangeBound  lower,
                    upper;
        uint8       flags = MultirangeGetFlagsPtr(mr)[i];
        uint32      lower_hash;
        uint32      upper_hash;
        uint32      range_hash;
 
        multirange_get_bounds(typcache->rngtype, mr, i, &lower, &upper);
 
        if (RANGE_HAS_LBOUND(flags))
            lower_hash = DatumGetUInt32(FunctionCall1Coll(&scache->hash_proc_finfo,
                                                          typcache->rngtype->rng_collation,
                                                          lower.val));
        else
            lower_hash = 0;
 
        if (RANGE_HAS_UBOUND(flags))
            upper_hash = DatumGetUInt32(FunctionCall1Coll(&scache->hash_proc_finfo,
                                                          typcache->rngtype->rng_collation,
                                                          upper.val));
        else
            upper_hash = 0;
 
        /* Merge hashes of flags and bounds */
        range_hash = hash_bytes_uint32((uint32) flags);
        range_hash ^= lower_hash;
        range_hash = pg_rotate_left32(range_hash, 1);
        range_hash ^= upper_hash;
 
        /*
         * Use the same approach as hash_array to combine the individual
         * elements' hash values:
         */
        result = (result << 5) - result + range_hash;
    }
 
    PG_FREE_IF_COPY(mr, 0);
 
    PG_RETURN_UINT32(result);
}

References DatumGetUInt32(), ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCall1Coll(), hash_bytes_uint32(), TypeCacheEntry::hash_proc_finfo, i, lookup_type_cache(), lower(), multirange_get_bounds(), multirange_get_typcache(), MultirangeGetFlagsPtr, MultirangeTypeGetOid, OidIsValid, PG_FREE_IF_COPY, PG_GETARG_MULTIRANGE_P, PG_RETURN_UINT32, pg_rotate_left32(), RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, MultirangeType::rangeCount, TypeCacheEntry::rng_collation, TypeCacheEntry::rngelemtype, TypeCacheEntry::rngtype, TypeCacheEntry::type_id, TYPECACHE_HASH_PROC_FINFO, and upper().

◆ hash_multirange_extended()

Datum hash_multirange_extended ( PG_FUNCTION_ARGS )

Definition at line 2858 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    Datum       seed = PG_GETARG_DATUM(1);
    uint64      result = 1;
    TypeCacheEntry *typcache,
               *scache;
    int32       range_count,
                i;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
    scache = typcache->rngtype->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))));
    }
 
    range_count = mr->rangeCount;
    for (i = 0; i < range_count; i++)
    {
        RangeBound  lower,
                    upper;
        uint8       flags = MultirangeGetFlagsPtr(mr)[i];
        uint64      lower_hash;
        uint64      upper_hash;
        uint64      range_hash;
 
        multirange_get_bounds(typcache->rngtype, mr, i, &lower, &upper);
 
        if (RANGE_HAS_LBOUND(flags))
            lower_hash = DatumGetUInt64(FunctionCall2Coll(&scache->hash_extended_proc_finfo,
                                                          typcache->rngtype->rng_collation,
                                                          lower.val,
                                                          seed));
        else
            lower_hash = 0;
 
        if (RANGE_HAS_UBOUND(flags))
            upper_hash = DatumGetUInt64(FunctionCall2Coll(&scache->hash_extended_proc_finfo,
                                                          typcache->rngtype->rng_collation,
                                                          upper.val,
                                                          seed));
        else
            upper_hash = 0;
 
        /* Merge hashes of flags and bounds */
        range_hash = DatumGetUInt64(hash_uint32_extended((uint32) flags,
                                                         DatumGetInt64(seed)));
        range_hash ^= lower_hash;
        range_hash = ROTATE_HIGH_AND_LOW_32BITS(range_hash);
        range_hash ^= upper_hash;
 
        /*
         * Use the same approach as hash_array to combine the individual
         * elements' hash values:
         */
        result = (result << 5) - result + range_hash;
    }
 
    PG_FREE_IF_COPY(mr, 0);
 
    PG_RETURN_UINT64(result);
}

References DatumGetInt64(), DatumGetUInt64(), ereport, errcode(), errmsg(), ERROR, FmgrInfo::fn_oid, format_type_be(), FunctionCall2Coll(), TypeCacheEntry::hash_extended_proc_finfo, hash_uint32_extended(), i, lookup_type_cache(), lower(), multirange_get_bounds(), multirange_get_typcache(), MultirangeGetFlagsPtr, MultirangeTypeGetOid, OidIsValid, PG_FREE_IF_COPY, PG_GETARG_DATUM, PG_GETARG_MULTIRANGE_P, PG_RETURN_UINT64, RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, MultirangeType::rangeCount, TypeCacheEntry::rng_collation, TypeCacheEntry::rngelemtype, TypeCacheEntry::rngtype, ROTATE_HIGH_AND_LOW_32BITS, TypeCacheEntry::type_id, TYPECACHE_HASH_EXTENDED_PROC_FINFO, and upper().

◆ make_empty_multirange()

MultirangeType * make_empty_multirange	(	Oid	mltrngtypoid,
		TypeCacheEntry *	rangetyp
	)

Definition at line 849 of file multirangetypes.c.

{
    return make_multirange(mltrngtypoid, rangetyp, 0, NULL);
}

References make_multirange().

Referenced by multirange_intersect().

◆ make_multirange()

MultirangeType * make_multirange	(	Oid	mltrngtypoid,
		TypeCacheEntry *	rangetyp,
		int32	range_count,
		RangeType **	ranges
	)

Definition at line 647 of file multirangetypes.c.

{
    MultirangeType *multirange;
    Size        size;
 
    /* Sort and merge input ranges. */
    range_count = multirange_canonicalize(rangetyp, range_count, ranges);
 
    /* Note: zero-fill is required here, just as in heap tuples */
    size = multirange_size_estimate(rangetyp, range_count, ranges);
    multirange = palloc0(size);
    SET_VARSIZE(multirange, size);
 
    /* Now fill in the datum */
    multirange->multirangetypid = mltrngtypoid;
    multirange->rangeCount = range_count;
 
    write_multirange_data(multirange, rangetyp, range_count, ranges);
 
    return multirange;
}

References multirange_canonicalize(), multirange_size_estimate(), MultirangeType::multirangetypid, palloc0(), MultirangeType::rangeCount, SET_VARSIZE(), and write_multirange_data().

Referenced by make_empty_multirange(), multirange_constructor0(), multirange_constructor1(), multirange_constructor2(), multirange_in(), multirange_intersect_internal(), multirange_minus_internal(), multirange_recv(), multirange_union(), multirangesel(), and range_agg_finalfn().

◆ multirange_adjacent_multirange()

Datum multirange_adjacent_multirange ( PG_FUNCTION_ARGS )

Definition at line 2534 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
    int32       range_count1;
    int32       range_count2;
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
 
    if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
        PG_RETURN_BOOL(false);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    range_count1 = mr1->rangeCount;
    range_count2 = mr2->rangeCount;
    multirange_get_bounds(typcache->rngtype, mr1, range_count1 - 1,
                          &lower1, &upper1);
    multirange_get_bounds(typcache->rngtype, mr2, 0,
                          &lower2, &upper2);
    if (bounds_adjacent(typcache->rngtype, upper1, lower2))
        PG_RETURN_BOOL(true);
 
    if (range_count1 > 1)
        multirange_get_bounds(typcache->rngtype, mr1, 0,
                              &lower1, &upper1);
    if (range_count2 > 1)
        multirange_get_bounds(typcache->rngtype, mr2, range_count2 - 1,
                              &lower2, &upper2);
    if (bounds_adjacent(typcache->rngtype, upper2, lower1))
        PG_RETURN_BOOL(true);
    PG_RETURN_BOOL(false);
}

References bounds_adjacent(), multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, MultirangeType::rangeCount, and TypeCacheEntry::rngtype.

◆ multirange_adjacent_range()

Datum multirange_adjacent_range ( PG_FUNCTION_ARGS )

Definition at line 2519 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    RangeType  *r = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
        PG_RETURN_BOOL(false);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_adjacent_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_adjacent_multirange_internal(), RangeIsEmpty, and TypeCacheEntry::rngtype.

◆ multirange_after_multirange()

Datum multirange_after_multirange ( PG_FUNCTION_ARGS )

Definition at line 2389 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    PG_RETURN_BOOL(multirange_before_multirange_internal(typcache->rngtype, mr2, mr1));
}

References multirange_before_multirange_internal(), multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, and TypeCacheEntry::rngtype.

◆ multirange_after_range()

Datum multirange_after_range ( PG_FUNCTION_ARGS )

Definition at line 2377 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    RangeType  *r = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_before_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_before_multirange_internal(), and TypeCacheEntry::rngtype.

◆ multirange_agg_transfn()

Datum multirange_agg_transfn ( PG_FUNCTION_ARGS )

Definition at line 1413 of file multirangetypes.c.

{
    MemoryContext aggContext;
    Oid         mltrngtypoid;
    TypeCacheEntry *typcache;
    TypeCacheEntry *rngtypcache;
    ArrayBuildState *state;
 
    if (!AggCheckCallContext(fcinfo, &aggContext))
        elog(ERROR, "multirange_agg_transfn called in non-aggregate context");
 
    mltrngtypoid = get_fn_expr_argtype(fcinfo->flinfo, 1);
    if (!type_is_multirange(mltrngtypoid))
        elog(ERROR, "range_agg must be called with a multirange");
 
    typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
    rngtypcache = typcache->rngtype;
 
    if (PG_ARGISNULL(0))
        state = initArrayResult(rngtypcache->type_id, aggContext, false);
    else
        state = (ArrayBuildState *) PG_GETARG_POINTER(0);
 
    /* skip NULLs */
    if (!PG_ARGISNULL(1))
    {
        MultirangeType *current;
        int32       range_count;
        RangeType **ranges;
 
        current = PG_GETARG_MULTIRANGE_P(1);
        multirange_deserialize(rngtypcache, current, &range_count, &ranges);
        if (range_count == 0)
        {
            /*
             * Add an empty range so we get an empty result (not a null
             * result).
             */
            accumArrayResult(state,
                             RangeTypePGetDatum(make_empty_range(rngtypcache)),
                             false, rngtypcache->type_id, aggContext);
        }
        else
        {
            for (int32 i = 0; i < range_count; i++)
                accumArrayResult(state, RangeTypePGetDatum(ranges[i]), false, rngtypcache->type_id, aggContext);
        }
    }
 
    PG_RETURN_POINTER(state);
}

References accumArrayResult(), AggCheckCallContext(), elog, ERROR, get_fn_expr_argtype(), i, initArrayResult(), make_empty_range(), multirange_deserialize(), multirange_get_typcache(), PG_ARGISNULL, PG_GETARG_MULTIRANGE_P, PG_GETARG_POINTER, PG_RETURN_POINTER, RangeTypePGetDatum(), TypeCacheEntry::rngtype, TypeCacheEntry::type_id, and type_is_multirange().

◆ multirange_before_multirange()

Datum multirange_before_multirange ( PG_FUNCTION_ARGS )

Definition at line 2352 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    PG_RETURN_BOOL(multirange_before_multirange_internal(typcache->rngtype, mr1, mr2));
}

References multirange_before_multirange_internal(), multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, and TypeCacheEntry::rngtype.

◆ multirange_before_multirange_internal()

bool multirange_before_multirange_internal	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	mr1,
		const MultirangeType *	mr2
	)

Definition at line 2424 of file multirangetypes.c.

{
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
 
    if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
        return false;
 
    multirange_get_bounds(rangetyp, mr1, mr1->rangeCount - 1,
                          &lower1, &upper1);
    multirange_get_bounds(rangetyp, mr2, 0,
                          &lower2, &upper2);
 
    return (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0);
}

References multirange_get_bounds(), MultirangeIsEmpty, range_cmp_bounds(), and MultirangeType::rangeCount.

Referenced by multirange_after_multirange(), and multirange_before_multirange().

◆ multirange_before_range()

Datum multirange_before_range ( PG_FUNCTION_ARGS )

Definition at line 2340 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    RangeType  *r = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_after_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_after_multirange_internal(), and TypeCacheEntry::rngtype.

◆ multirange_bsearch_match()

static bool multirange_bsearch_match	(	TypeCacheEntry *	typcache,
		const MultirangeType *	mr,
		void *	key,
		multirange_bsearch_comparison	cmp_func
	)

static

Definition at line 899 of file multirangetypes.c.

{
    uint32      l,
                u,
                idx;
    int         comparison;
    bool        match = false;
 
    l = 0;
    u = mr->rangeCount;
    while (l < u)
    {
        RangeBound  lower,
                    upper;
 
        idx = (l + u) / 2;
        multirange_get_bounds(typcache, mr, idx, &lower, &upper);
        comparison = (*cmp_func) (typcache, &lower, &upper, key, &match);
 
        if (comparison < 0)
            u = idx;
        else if (comparison > 0)
            l = idx + 1;
        else
            return match;
    }
 
    return false;
}

References idx(), sort-test::key, lower(), multirange_get_bounds(), MultirangeType::rangeCount, and upper().

Referenced by multirange_contains_elem_internal(), multirange_contains_range_internal(), and range_overlaps_multirange_internal().

◆ multirange_canonicalize()

static int32 multirange_canonicalize	(	TypeCacheEntry *	rangetyp,
		int32	input_range_count,
		RangeType **	ranges
	)

static

Definition at line 478 of file multirangetypes.c.

{
    RangeType  *lastRange = NULL;
    RangeType  *currentRange;
    int32       i;
    int32       output_range_count = 0;
 
    /* Sort the ranges so we can find the ones that overlap/meet. */
    qsort_arg(ranges, input_range_count, sizeof(RangeType *), range_compare,
              rangetyp);
 
    /* Now merge where possible: */
    for (i = 0; i < input_range_count; i++)
    {
        currentRange = ranges[i];
        if (RangeIsEmpty(currentRange))
            continue;
 
        if (lastRange == NULL)
        {
            ranges[output_range_count++] = lastRange = currentRange;
            continue;
        }
 
        /*
         * range_adjacent_internal gives true if *either* A meets B or B meets
         * A, which is not quite want we want, but we rely on the sorting
         * above to rule out B meets A ever happening.
         */
        if (range_adjacent_internal(rangetyp, lastRange, currentRange))
        {
            /* The two ranges touch (without overlap), so merge them: */
            ranges[output_range_count - 1] = lastRange =
                range_union_internal(rangetyp, lastRange, currentRange, false);
        }
        else if (range_before_internal(rangetyp, lastRange, currentRange))
        {
            /* There's a gap, so make a new entry: */
            lastRange = ranges[output_range_count] = currentRange;
            output_range_count++;
        }
        else
        {
            /* They must overlap, so merge them: */
            ranges[output_range_count - 1] = lastRange =
                range_union_internal(rangetyp, lastRange, currentRange, true);
        }
    }
 
    return output_range_count;
}

References i, qsort_arg(), range_adjacent_internal(), range_before_internal(), range_compare(), range_union_internal(), and RangeIsEmpty.

Referenced by make_multirange().

◆ multirange_cmp()

Datum multirange_cmp ( PG_FUNCTION_ARGS )

Definition at line 2575 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    int32       range_count_1;
    int32       range_count_2;
    int32       range_count_max;
    int32       i;
    TypeCacheEntry *typcache;
    int         cmp = 0;        /* If both are empty we'll use this. */
 
    /* Different types should be prevented by ANYMULTIRANGE matching rules */
    if (MultirangeTypeGetOid(mr1) != MultirangeTypeGetOid(mr2))
        elog(ERROR, "multirange types do not match");
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    range_count_1 = mr1->rangeCount;
    range_count_2 = mr2->rangeCount;
 
    /* Loop over source data */
    range_count_max = Max(range_count_1, range_count_2);
    for (i = 0; i < range_count_max; i++)
    {
        RangeBound  lower1,
                    upper1,
                    lower2,
                    upper2;
 
        /*
         * If one multirange is shorter, it's as if it had empty ranges at the
         * end to extend its length. An empty range compares earlier than any
         * other range, so the shorter multirange comes before the longer.
         * This is the same behavior as in other types, e.g. in strings 'aaa'
         * < 'aaaaaa'.
         */
        if (i >= range_count_1)
        {
            cmp = -1;
            break;
        }
        if (i >= range_count_2)
        {
            cmp = 1;
            break;
        }
 
        multirange_get_bounds(typcache->rngtype, mr1, i, &lower1, &upper1);
        multirange_get_bounds(typcache->rngtype, mr2, i, &lower2, &upper2);
 
        cmp = range_cmp_bounds(typcache->rngtype, &lower1, &lower2);
        if (cmp == 0)
            cmp = range_cmp_bounds(typcache->rngtype, &upper1, &upper2);
        if (cmp != 0)
            break;
    }
 
    PG_FREE_IF_COPY(mr1, 0);
    PG_FREE_IF_COPY(mr2, 1);
 
    PG_RETURN_INT32(cmp);
}

References cmp(), elog, ERROR, i, Max, multirange_get_bounds(), multirange_get_typcache(), MultirangeTypeGetOid, PG_FREE_IF_COPY, PG_GETARG_MULTIRANGE_P, PG_RETURN_INT32, range_cmp_bounds(), MultirangeType::rangeCount, and TypeCacheEntry::rngtype.

Referenced by multirange_ge(), multirange_gt(), multirange_le(), and multirange_lt().

◆ multirange_constructor0()

Datum multirange_constructor0 ( PG_FUNCTION_ARGS )

Definition at line 1060 of file multirangetypes.c.

{
    Oid         mltrngtypid;
    TypeCacheEntry *typcache;
    TypeCacheEntry *rangetyp;
 
    /* This should always be called without arguments */
    if (PG_NARGS() != 0)
        elog(ERROR,
             "niladic multirange constructor must not receive arguments");
 
    mltrngtypid = get_fn_expr_rettype(fcinfo->flinfo);
    typcache = multirange_get_typcache(fcinfo, mltrngtypid);
    rangetyp = typcache->rngtype;
 
    PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, 0, NULL));
}

References elog, ERROR, get_fn_expr_rettype(), make_multirange(), multirange_get_typcache(), PG_NARGS, PG_RETURN_MULTIRANGE_P, and TypeCacheEntry::rngtype.

◆ multirange_constructor1()

Datum multirange_constructor1 ( PG_FUNCTION_ARGS )

Definition at line 1024 of file multirangetypes.c.

{
    Oid         mltrngtypid = get_fn_expr_rettype(fcinfo->flinfo);
    Oid         rngtypid;
    TypeCacheEntry *typcache;
    TypeCacheEntry *rangetyp;
    RangeType  *range;
 
    typcache = multirange_get_typcache(fcinfo, mltrngtypid);
    rangetyp = typcache->rngtype;
 
    /*
     * This check should be guaranteed by our signature, but let's do it just
     * in case.
     */
 
    if (PG_ARGISNULL(0))
        elog(ERROR,
             "multirange values cannot contain null members");
 
    range = PG_GETARG_RANGE_P(0);
 
    /* Make sure the range type matches. */
    rngtypid = RangeTypeGetOid(range);
    if (rngtypid != rangetyp->type_id)
        elog(ERROR, "type %u does not match constructor type", rngtypid);
 
    PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, 1, &range));
}

References elog, ERROR, get_fn_expr_rettype(), make_multirange(), multirange_get_typcache(), PG_ARGISNULL, PG_GETARG_RANGE_P, PG_RETURN_MULTIRANGE_P, range(), RangeTypeGetOid, TypeCacheEntry::rngtype, and TypeCacheEntry::type_id.

◆ multirange_constructor2()

Datum multirange_constructor2 ( PG_FUNCTION_ARGS )

Definition at line 942 of file multirangetypes.c.

{
    Oid         mltrngtypid = get_fn_expr_rettype(fcinfo->flinfo);
    Oid         rngtypid;
    TypeCacheEntry *typcache;
    TypeCacheEntry *rangetyp;
    ArrayType  *rangeArray;
    int         range_count;
    Datum      *elements;
    bool       *nulls;
    RangeType **ranges;
    int         dims;
    int         i;
 
    typcache = multirange_get_typcache(fcinfo, mltrngtypid);
    rangetyp = typcache->rngtype;
 
    /*
     * A no-arg invocation should call multirange_constructor0 instead, but
     * returning an empty range is what that does.
     */
 
    if (PG_NARGS() == 0)
        PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, 0, NULL));
 
    /*
     * This check should be guaranteed by our signature, but let's do it just
     * in case.
     */
 
    if (PG_ARGISNULL(0))
        elog(ERROR,
             "multirange values cannot contain null members");
 
    rangeArray = PG_GETARG_ARRAYTYPE_P(0);
 
    dims = ARR_NDIM(rangeArray);
    if (dims > 1)
        ereport(ERROR,
                (errcode(ERRCODE_CARDINALITY_VIOLATION),
                 errmsg("multiranges cannot be constructed from multidimensional arrays")));
 
    rngtypid = ARR_ELEMTYPE(rangeArray);
    if (rngtypid != rangetyp->type_id)
        elog(ERROR, "type %u does not match constructor type", rngtypid);
 
    /*
     * Be careful: we can still be called with zero ranges, like this:
     * `int4multirange(variadic '{}'::int4range[])
     */
    if (dims == 0)
    {
        range_count = 0;
        ranges = NULL;
    }
    else
    {
        deconstruct_array(rangeArray, rngtypid, rangetyp->typlen, rangetyp->typbyval,
                          rangetyp->typalign, &elements, &nulls, &range_count);
 
        ranges = palloc0(range_count * sizeof(RangeType *));
        for (i = 0; i < range_count; i++)
        {
            if (nulls[i])
                ereport(ERROR,
                        (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
                         errmsg("multirange values cannot contain null members")));
 
            /* make_multirange will do its own copy */
            ranges[i] = DatumGetRangeTypeP(elements[i]);
        }
    }
 
    PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, range_count, ranges));
}

References ARR_ELEMTYPE, ARR_NDIM, DatumGetRangeTypeP(), deconstruct_array(), elog, ereport, errcode(), errmsg(), ERROR, get_fn_expr_rettype(), i, make_multirange(), multirange_get_typcache(), palloc0(), PG_ARGISNULL, PG_GETARG_ARRAYTYPE_P, PG_NARGS, PG_RETURN_MULTIRANGE_P, TypeCacheEntry::rngtype, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::type_id, and TypeCacheEntry::typlen.

◆ multirange_contained_by_multirange()

Datum multirange_contained_by_multirange ( PG_FUNCTION_ARGS )

Definition at line 2251 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    PG_RETURN_BOOL(multirange_contains_multirange_internal(typcache->rngtype, mr2, mr1));
}

References multirange_contains_multirange_internal(), multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, and TypeCacheEntry::rngtype.

◆ multirange_contained_by_range()

Datum multirange_contained_by_range ( PG_FUNCTION_ARGS )

Definition at line 1759 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    RangeType  *r = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_contains_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_contains_multirange_internal(), and TypeCacheEntry::rngtype.

◆ multirange_contains_elem()

Datum multirange_contains_elem ( PG_FUNCTION_ARGS )

Definition at line 1646 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    Datum       val = PG_GETARG_DATUM(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(multirange_contains_elem_internal(typcache->rngtype, mr, val));
}

References multirange_contains_elem_internal(), multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_DATUM, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, TypeCacheEntry::rngtype, and val.

◆ multirange_contains_elem_internal()

bool multirange_contains_elem_internal	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	mr,
		Datum	val
	)

Definition at line 1708 of file multirangetypes.c.

{
    if (MultirangeIsEmpty(mr))
        return false;
 
    return multirange_bsearch_match(rangetyp, mr, &val,
                                    multirange_elem_bsearch_comparison);
}

References multirange_bsearch_match(), multirange_elem_bsearch_comparison(), MultirangeIsEmpty, and val.

Referenced by elem_contained_by_multirange(), and multirange_contains_elem().

◆ multirange_contains_multirange()

Datum multirange_contains_multirange ( PG_FUNCTION_ARGS )

Definition at line 2238 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    PG_RETURN_BOOL(multirange_contains_multirange_internal(typcache->rngtype, mr1, mr2));
}

References multirange_contains_multirange_internal(), multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, and TypeCacheEntry::rngtype.

◆ multirange_contains_multirange_internal()

bool multirange_contains_multirange_internal	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	mr1,
		const MultirangeType *	mr2
	)

Definition at line 2266 of file multirangetypes.c.

{
    int32       range_count1 = mr1->rangeCount;
    int32       range_count2 = mr2->rangeCount;
    int         i1,
                i2;
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
 
    /*
     * We follow the same logic for empties as ranges: - an empty multirange
     * contains an empty range/multirange. - an empty multirange can't contain
     * any other range/multirange. - an empty multirange is contained by any
     * other range/multirange.
     */
 
    if (range_count2 == 0)
        return true;
    if (range_count1 == 0)
        return false;
 
    /*
     * Every range in mr2 must be contained by some range in mr1. To avoid
     * O(n^2) we walk through both ranges in tandem.
     */
    i1 = 0;
    multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
    for (i2 = 0; i2 < range_count2; i2++)
    {
        multirange_get_bounds(rangetyp, mr2, i2, &lower2, &upper2);
 
        /* Discard r1s while r1 << r2 */
        while (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0)
        {
            if (++i1 >= range_count1)
                return false;
            multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
        }
 
        /*
         * If r1 @> r2, go to the next r2, otherwise return false (since every
         * r1[n] and r1[n+1] must have a gap). Note this will give weird
         * answers if you don't canonicalize, e.g. with a custom
         * int2multirange {[1,1], [2,2]} there is a "gap". But that is
         * consistent with other range operators, e.g. '[1,1]'::int2range -|-
         * '[2,2]'::int2range is false.
         */
        if (!range_bounds_contains(rangetyp, &lower1, &upper1,
                                   &lower2, &upper2))
            return false;
    }
 
    /* All ranges in mr2 are satisfied */
    return true;
}

References multirange_get_bounds(), range_bounds_contains(), range_cmp_bounds(), and MultirangeType::rangeCount.

Referenced by multirange_contained_by_multirange(), and multirange_contains_multirange().

◆ multirange_contains_range()

Datum multirange_contains_range ( PG_FUNCTION_ARGS )

Definition at line 1722 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    RangeType  *r = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(multirange_contains_range_internal(typcache->rngtype, mr, r));
}

References multirange_contains_range_internal(), multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, and TypeCacheEntry::rngtype.

◆ multirange_contains_range_internal()

bool multirange_contains_range_internal	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	mr,
		const RangeType *	r
	)

Definition at line 1802 of file multirangetypes.c.

{
    RangeBound  bounds[2];
    bool        empty;
 
    /*
     * Every multirange contains an infinite number of empty ranges, even an
     * empty one.
     */
    if (RangeIsEmpty(r))
        return true;
 
    if (MultirangeIsEmpty(mr))
        return false;
 
    range_deserialize(rangetyp, r, &bounds[0], &bounds[1], &empty);
    Assert(!empty);
 
    return multirange_bsearch_match(rangetyp, mr, bounds,
                                    multirange_range_contains_bsearch_comparison);
}

References Assert(), multirange_bsearch_match(), multirange_range_contains_bsearch_comparison(), MultirangeIsEmpty, range_deserialize(), and RangeIsEmpty.

Referenced by multirange_contains_range(), range_contained_by_multirange(), and range_gist_consistent_leaf_multirange().

◆ multirange_deserialize()

void multirange_deserialize	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	multirange,
		int32 *	range_count,
		RangeType ***	ranges
	)

Definition at line 827 of file multirangetypes.c.

{
    *range_count = multirange->rangeCount;
 
    /* Convert each ShortRangeType into a RangeType */
    if (*range_count > 0)
    {
        int         i;
 
        *ranges = palloc(*range_count * sizeof(RangeType *));
        for (i = 0; i < *range_count; i++)
            (*ranges)[i] = multirange_get_range(rangetyp, multirange, i);
    }
    else
    {
        *ranges = NULL;
    }
}

References i, multirange_get_range(), palloc(), and MultirangeType::rangeCount.

Referenced by multirange_agg_transfn(), multirange_intersect(), multirange_intersect_agg_transfn(), multirange_minus(), multirange_out(), multirange_send(), and multirange_union().

◆ multirange_elem_bsearch_comparison()

static int multirange_elem_bsearch_comparison	(	TypeCacheEntry *	typcache,
		RangeBound *	lower,
		RangeBound *	upper,
		void *	key,
		bool *	match
	)

static

Definition at line 1675 of file multirangetypes.c.

{
    Datum       val = *((Datum *) key);
    int         cmp;
 
    if (!lower->infinite)
    {
        cmp = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
                                              typcache->rng_collation,
                                              lower->val, val));
        if (cmp > 0 || (cmp == 0 && !lower->inclusive))
            return -1;
    }
 
    if (!upper->infinite)
    {
        cmp = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
                                              typcache->rng_collation,
                                              upper->val, val));
        if (cmp < 0 || (cmp == 0 && !upper->inclusive))
            return 1;
    }
 
    *match = true;
    return 0;
}

References cmp(), DatumGetInt32(), FunctionCall2Coll(), sort-test::key, lower(), TypeCacheEntry::rng_cmp_proc_finfo, TypeCacheEntry::rng_collation, upper(), and val.

Referenced by multirange_contains_elem_internal().

◆ multirange_empty()

Datum multirange_empty ( PG_FUNCTION_ARGS )

Definition at line 1557 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
 
    PG_RETURN_BOOL(MultirangeIsEmpty(mr));
}

References MultirangeIsEmpty, PG_GETARG_MULTIRANGE_P, and PG_RETURN_BOOL.

◆ multirange_eq()

Datum multirange_eq ( PG_FUNCTION_ARGS )

Definition at line 1902 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    PG_RETURN_BOOL(multirange_eq_internal(typcache->rngtype, mr1, mr2));
}

References multirange_eq_internal(), multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, and TypeCacheEntry::rngtype.

◆ multirange_eq_internal()

bool multirange_eq_internal	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	mr1,
		const MultirangeType *	mr2
	)

Definition at line 1865 of file multirangetypes.c.

{
    int32       range_count_1;
    int32       range_count_2;
    int32       i;
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
 
    /* Different types should be prevented by ANYMULTIRANGE matching rules */
    if (MultirangeTypeGetOid(mr1) != MultirangeTypeGetOid(mr2))
        elog(ERROR, "multirange types do not match");
 
    range_count_1 = mr1->rangeCount;
    range_count_2 = mr2->rangeCount;
 
    if (range_count_1 != range_count_2)
        return false;
 
    for (i = 0; i < range_count_1; i++)
    {
        multirange_get_bounds(rangetyp, mr1, i, &lower1, &upper1);
        multirange_get_bounds(rangetyp, mr2, i, &lower2, &upper2);
 
        if (range_cmp_bounds(rangetyp, &lower1, &lower2) != 0 ||
            range_cmp_bounds(rangetyp, &upper1, &upper2) != 0)
            return false;
    }
 
    return true;
}

References elog, ERROR, i, multirange_get_bounds(), MultirangeTypeGetOid, range_cmp_bounds(), and MultirangeType::rangeCount.

Referenced by multirange_eq(), and multirange_ne_internal().

◆ multirange_ge()

Datum multirange_ge ( PG_FUNCTION_ARGS )

Definition at line 2656 of file multirangetypes.c.

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

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

◆ multirange_get_bounds()

void multirange_get_bounds	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	multirange,
		uint32	i,
		RangeBound *	lower,
		RangeBound *	upper
	)

Definition at line 745 of file multirangetypes.c.

{
    uint32      offset;
    uint8       flags;
    Pointer     ptr;
    int16       typlen = rangetyp->rngelemtype->typlen;
    char        typalign = rangetyp->rngelemtype->typalign;
    bool        typbyval = rangetyp->rngelemtype->typbyval;
    Datum       lbound;
    Datum       ubound;
 
    Assert(i < multirange->rangeCount);
 
    offset = multirange_get_bounds_offset(multirange, i);
    flags = MultirangeGetFlagsPtr(multirange)[i];
    ptr = MultirangeGetBoundariesPtr(multirange, typalign) + offset;
 
    /* multirange can't contain empty ranges */
    Assert((flags & RANGE_EMPTY) == 0);
 
    /* 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 */
    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(), i, lower(), multirange_get_bounds_offset(), MultirangeGetBoundariesPtr, MultirangeGetFlagsPtr, RANGE_EMPTY, RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, RANGE_LB_INC, RANGE_LB_INF, RANGE_UB_INC, RANGE_UB_INF, TypeCacheEntry::rngelemtype, typalign, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::typlen, and upper().

Referenced by calc_hist_selectivity(), compute_range_stats(), hash_multirange(), hash_multirange_extended(), multirange_adjacent_multirange(), multirange_before_multirange_internal(), multirange_bsearch_match(), multirange_cmp(), multirange_contains_multirange_internal(), multirange_eq_internal(), multirange_get_union_range(), multirange_lower(), multirange_lower_inc(), multirange_lower_inf(), multirange_overlaps_multirange_internal(), multirange_overleft_multirange(), multirange_overleft_range(), multirange_overright_multirange(), multirange_overright_range(), multirange_union_range_equal(), multirange_upper(), multirange_upper_inc(), multirange_upper_inf(), range_adjacent_multirange_internal(), range_after_multirange_internal(), range_before_multirange_internal(), range_contains_multirange_internal(), range_merge_from_multirange(), range_overleft_multirange_internal(), and range_overright_multirange_internal().

◆ multirange_get_bounds_offset()

static uint32 multirange_get_bounds_offset	(	const MultirangeType *	multirange,
		int32	i
	)

static

Definition at line 674 of file multirangetypes.c.

{
    uint32     *items = MultirangeGetItemsPtr(multirange);
    uint32      offset = 0;
 
    /*
     * Summarize lengths till we meet an offset.
     */
    while (i > 0)
    {
        offset += MULTIRANGE_ITEM_GET_OFFLEN(items[i - 1]);
        if (MULTIRANGE_ITEM_HAS_OFF(items[i - 1]))
            break;
        i--;
    }
    return offset;
}

References i, items, MULTIRANGE_ITEM_GET_OFFLEN, MULTIRANGE_ITEM_HAS_OFF, and MultirangeGetItemsPtr.

Referenced by multirange_get_bounds(), and multirange_get_range().

◆ multirange_get_range()

RangeType * multirange_get_range	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	multirange,
		int	i
	)

Definition at line 696 of file multirangetypes.c.

{
    uint32      offset;
    uint8       flags;
    Pointer     begin,
                ptr;
    int16       typlen = rangetyp->rngelemtype->typlen;
    char        typalign = rangetyp->rngelemtype->typalign;
    uint32      len;
    RangeType  *range;
 
    Assert(i < multirange->rangeCount);
 
    offset = multirange_get_bounds_offset(multirange, i);
    flags = MultirangeGetFlagsPtr(multirange)[i];
    ptr = begin = MultirangeGetBoundariesPtr(multirange, typalign) + offset;
 
    /*
     * Calculate the size of bound values.  In principle, we could get offset
     * of the next range bound values and calculate accordingly.  But range
     * bound values are aligned, so we have to walk the values to get the
     * exact size.
     */
    if (RANGE_HAS_LBOUND(flags))
        ptr = (Pointer) att_addlength_pointer(ptr, typlen, ptr);
    if (RANGE_HAS_UBOUND(flags))
    {
        ptr = (Pointer) att_align_pointer(ptr, typalign, typlen, ptr);
        ptr = (Pointer) att_addlength_pointer(ptr, typlen, ptr);
    }
    len = (ptr - begin) + sizeof(RangeType) + sizeof(uint8);
 
    range = palloc0(len);
    SET_VARSIZE(range, len);
    range->rangetypid = rangetyp->type_id;
 
    memcpy(range + 1, begin, ptr - begin);
    *((uint8 *) (range + 1) + (ptr - begin)) = flags;
 
    return range;
}

References Assert(), att_addlength_pointer, att_align_pointer, i, len, multirange_get_bounds_offset(), MultirangeGetBoundariesPtr, MultirangeGetFlagsPtr, palloc0(), range(), RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, TypeCacheEntry::rngelemtype, SET_VARSIZE(), typalign, TypeCacheEntry::typalign, TypeCacheEntry::type_id, and TypeCacheEntry::typlen.

Referenced by multirange_deserialize(), multirange_unnest(), and range_merge_from_multirange().

◆ multirange_get_typcache()

TypeCacheEntry * multirange_get_typcache	(	FunctionCallInfo	fcinfo,
		Oid	mltrngtypid
	)

Definition at line 549 of file multirangetypes.c.

{
    TypeCacheEntry *typcache = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
 
    if (typcache == NULL ||
        typcache->type_id != mltrngtypid)
    {
        typcache = lookup_type_cache(mltrngtypid, TYPECACHE_MULTIRANGE_INFO);
        if (typcache->rngtype == NULL)
            elog(ERROR, "type %u is not a multirange type", mltrngtypid);
        fcinfo->flinfo->fn_extra = typcache;
    }
 
    return typcache;
}

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

◆ multirange_get_union_range()

RangeType * multirange_get_union_range	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	mr
	)

Definition at line 803 of file multirangetypes.c.

{
    RangeBound  lower,
                upper,
                tmp;
 
    if (MultirangeIsEmpty(mr))
        return make_empty_range(rangetyp);
 
    multirange_get_bounds(rangetyp, mr, 0, &lower, &tmp);
    multirange_get_bounds(rangetyp, mr, mr->rangeCount - 1, &tmp, &upper);
 
    return make_range(rangetyp, &lower, &upper, false, NULL);
}

References lower(), make_empty_range(), make_range(), multirange_get_bounds(), MultirangeIsEmpty, MultirangeType::rangeCount, and upper().

Referenced by multirange_gist_compress().

◆ multirange_gt()

Datum multirange_gt ( PG_FUNCTION_ARGS )

Definition at line 2664 of file multirangetypes.c.

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

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

◆ multirange_in()

Datum multirange_in ( PG_FUNCTION_ARGS )

Definition at line 117 of file multirangetypes.c.

{
    char       *input_str = PG_GETARG_CSTRING(0);
    Oid         mltrngtypoid = PG_GETARG_OID(1);
    Oid         typmod = PG_GETARG_INT32(2);
    Node       *escontext = fcinfo->context;
    TypeCacheEntry *rangetyp;
    int32       ranges_seen = 0;
    int32       range_count = 0;
    int32       range_capacity = 8;
    RangeType  *range;
    RangeType **ranges = palloc(range_capacity * sizeof(RangeType *));
    MultirangeIOData *cache;
    MultirangeType *ret;
    MultirangeParseState parse_state;
    const char *ptr = input_str;
    const char *range_str_begin = NULL;
    int32       range_str_len;
    char       *range_str;
    Datum       range_datum;
 
    cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_input);
    rangetyp = cache->typcache->rngtype;
 
    /* consume whitespace */
    while (*ptr != '\0' && isspace((unsigned char) *ptr))
        ptr++;
 
    if (*ptr == '{')
        ptr++;
    else
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed multirange literal: \"%s\"",
                        input_str),
                 errdetail("Missing left brace.")));
 
    /* consume ranges */
    parse_state = MULTIRANGE_BEFORE_RANGE;
    for (; parse_state != MULTIRANGE_FINISHED; ptr++)
    {
        char        ch = *ptr;
 
        if (ch == '\0')
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("malformed multirange literal: \"%s\"",
                            input_str),
                     errdetail("Unexpected end of input.")));
 
        /* skip whitespace */
        if (isspace((unsigned char) ch))
            continue;
 
        switch (parse_state)
        {
            case MULTIRANGE_BEFORE_RANGE:
                if (ch == '[' || ch == '(')
                {
                    range_str_begin = ptr;
                    parse_state = MULTIRANGE_IN_RANGE;
                }
                else if (ch == '}' && ranges_seen == 0)
                    parse_state = MULTIRANGE_FINISHED;
                else if (pg_strncasecmp(ptr, RANGE_EMPTY_LITERAL,
                                        strlen(RANGE_EMPTY_LITERAL)) == 0)
                {
                    ranges_seen++;
                    /* nothing to do with an empty range */
                    ptr += strlen(RANGE_EMPTY_LITERAL) - 1;
                    parse_state = MULTIRANGE_AFTER_RANGE;
                }
                else
                    ereturn(escontext, (Datum) 0,
                            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                             errmsg("malformed multirange literal: \"%s\"",
                                    input_str),
                             errdetail("Expected range start.")));
                break;
            case MULTIRANGE_IN_RANGE:
                if (ch == ']' || ch == ')')
                {
                    range_str_len = ptr - range_str_begin + 1;
                    range_str = pnstrdup(range_str_begin, range_str_len);
                    if (range_capacity == range_count)
                    {
                        range_capacity *= 2;
                        ranges = (RangeType **)
                            repalloc(ranges, range_capacity * sizeof(RangeType *));
                    }
                    ranges_seen++;
                    if (!InputFunctionCallSafe(&cache->typioproc,
                                               range_str,
                                               cache->typioparam,
                                               typmod,
                                               escontext,
                                               &range_datum))
                        PG_RETURN_NULL();
                    range = DatumGetRangeTypeP(range_datum);
                    if (!RangeIsEmpty(range))
                        ranges[range_count++] = range;
                    parse_state = MULTIRANGE_AFTER_RANGE;
                }
                else
                {
                    if (ch == '"')
                        parse_state = MULTIRANGE_IN_RANGE_QUOTED;
                    else if (ch == '\\')
                        parse_state = MULTIRANGE_IN_RANGE_ESCAPED;
 
                    /*
                     * We will include this character into range_str once we
                     * find the end of the range value.
                     */
                }
                break;
            case MULTIRANGE_IN_RANGE_ESCAPED:
 
                /*
                 * We will include this character into range_str once we find
                 * the end of the range value.
                 */
                parse_state = MULTIRANGE_IN_RANGE;
                break;
            case MULTIRANGE_IN_RANGE_QUOTED:
                if (ch == '"')
                    if (*(ptr + 1) == '"')
                    {
                        /* two quote marks means an escaped quote mark */
                        ptr++;
                    }
                    else
                        parse_state = MULTIRANGE_IN_RANGE;
                else if (ch == '\\')
                    parse_state = MULTIRANGE_IN_RANGE_QUOTED_ESCAPED;
 
                /*
                 * We will include this character into range_str once we find
                 * the end of the range value.
                 */
                break;
            case MULTIRANGE_AFTER_RANGE:
                if (ch == ',')
                    parse_state = MULTIRANGE_BEFORE_RANGE;
                else if (ch == '}')
                    parse_state = MULTIRANGE_FINISHED;
                else
                    ereturn(escontext, (Datum) 0,
                            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                             errmsg("malformed multirange literal: \"%s\"",
                                    input_str),
                             errdetail("Expected comma or end of multirange.")));
                break;
            case MULTIRANGE_IN_RANGE_QUOTED_ESCAPED:
 
                /*
                 * We will include this character into range_str once we find
                 * the end of the range value.
                 */
                parse_state = MULTIRANGE_IN_RANGE_QUOTED;
                break;
            default:
                elog(ERROR, "unknown parse state: %d", parse_state);
        }
    }
 
    /* consume whitespace */
    while (*ptr != '\0' && isspace((unsigned char) *ptr))
        ptr++;
 
    if (*ptr != '\0')
        ereturn(escontext, (Datum) 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("malformed multirange literal: \"%s\"",
                        input_str),
                 errdetail("Junk after closing right brace.")));
 
    ret = make_multirange(mltrngtypoid, rangetyp, range_count, ranges);
    PG_RETURN_MULTIRANGE_P(ret);
}

References DatumGetRangeTypeP(), elog, ereturn, errcode(), errdetail(), errmsg(), ERROR, get_multirange_io_data(), InputFunctionCallSafe(), IOFunc_input, make_multirange(), MULTIRANGE_AFTER_RANGE, MULTIRANGE_BEFORE_RANGE, MULTIRANGE_FINISHED, MULTIRANGE_IN_RANGE, MULTIRANGE_IN_RANGE_ESCAPED, MULTIRANGE_IN_RANGE_QUOTED, MULTIRANGE_IN_RANGE_QUOTED_ESCAPED, palloc(), PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_MULTIRANGE_P, PG_RETURN_NULL, pg_strncasecmp(), pnstrdup(), range(), RANGE_EMPTY_LITERAL, RangeIsEmpty, repalloc(), TypeCacheEntry::rngtype, MultirangeIOData::typcache, MultirangeIOData::typioparam, and MultirangeIOData::typioproc.

◆ multirange_intersect()

Datum multirange_intersect ( PG_FUNCTION_ARGS )

Definition at line 1231 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    Oid         mltrngtypoid = MultirangeTypeGetOid(mr1);
    TypeCacheEntry *typcache;
    TypeCacheEntry *rangetyp;
    int32       range_count1;
    int32       range_count2;
    RangeType **ranges1;
    RangeType **ranges2;
 
    typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
    rangetyp = typcache->rngtype;
 
    if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
        PG_RETURN_MULTIRANGE_P(make_empty_multirange(mltrngtypoid, rangetyp));
 
    multirange_deserialize(rangetyp, mr1, &range_count1, &ranges1);
    multirange_deserialize(rangetyp, mr2, &range_count2, &ranges2);
 
    PG_RETURN_MULTIRANGE_P(multirange_intersect_internal(mltrngtypoid,
                                                         rangetyp,
                                                         range_count1,
                                                         ranges1,
                                                         range_count2,
                                                         ranges2));
}

References make_empty_multirange(), multirange_deserialize(), multirange_get_typcache(), multirange_intersect_internal(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_MULTIRANGE_P, and TypeCacheEntry::rngtype.

◆ multirange_intersect_agg_transfn()

Datum multirange_intersect_agg_transfn ( PG_FUNCTION_ARGS )

Definition at line 1466 of file multirangetypes.c.

{
    MemoryContext aggContext;
    Oid         mltrngtypoid;
    TypeCacheEntry *typcache;
    MultirangeType *result;
    MultirangeType *current;
    int32       range_count1;
    int32       range_count2;
    RangeType **ranges1;
    RangeType **ranges2;
 
    if (!AggCheckCallContext(fcinfo, &aggContext))
        elog(ERROR, "multirange_intersect_agg_transfn called in non-aggregate context");
 
    mltrngtypoid = get_fn_expr_argtype(fcinfo->flinfo, 1);
    if (!type_is_multirange(mltrngtypoid))
        elog(ERROR, "range_intersect_agg must be called with a multirange");
 
    typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
 
    /* strictness ensures these are non-null */
    result = PG_GETARG_MULTIRANGE_P(0);
    current = PG_GETARG_MULTIRANGE_P(1);
 
    multirange_deserialize(typcache->rngtype, result, &range_count1, &ranges1);
    multirange_deserialize(typcache->rngtype, current, &range_count2, &ranges2);
 
    result = multirange_intersect_internal(mltrngtypoid,
                                           typcache->rngtype,
                                           range_count1,
                                           ranges1,
                                           range_count2,
                                           ranges2);
    PG_RETURN_MULTIRANGE_P(result);
}

References AggCheckCallContext(), elog, ERROR, get_fn_expr_argtype(), multirange_deserialize(), multirange_get_typcache(), multirange_intersect_internal(), PG_GETARG_MULTIRANGE_P, PG_RETURN_MULTIRANGE_P, TypeCacheEntry::rngtype, and type_is_multirange().

◆ multirange_intersect_internal()

MultirangeType * multirange_intersect_internal	(	Oid	mltrngtypoid,
		TypeCacheEntry *	rangetyp,
		int32	range_count1,
		RangeType **	ranges1,
		int32	range_count2,
		RangeType **	ranges2
	)

Definition at line 1261 of file multirangetypes.c.

{
    RangeType  *r1;
    RangeType  *r2;
    RangeType **ranges3;
    int32       range_count3;
    int32       i1;
    int32       i2;
 
    if (range_count1 == 0 || range_count2 == 0)
        return make_multirange(mltrngtypoid, rangetyp, 0, NULL);
 
    /*-----------------------------------------------
     * Worst case is a stitching pattern like this:
     *
     * mr1: --- --- --- ---
     * mr2:   --- --- ---
     * mr3:   - - - - - -
     *
     * That seems to be range_count1 + range_count2 - 1,
     * but one extra won't hurt.
     *-----------------------------------------------
     */
    ranges3 = palloc0((range_count1 + range_count2) * sizeof(RangeType *));
    range_count3 = 0;
 
    /*
     * For each range in mr1, keep intersecting until the ranges in mr2 have
     * passed it. The parallel progress through mr1 and mr2 is similar to
     * multirange_minus_multirange_internal, but we don't have to assign back
     * to r1.
     */
    r2 = ranges2[0];
    for (i1 = 0, i2 = 0; i1 < range_count1; i1++)
    {
        r1 = ranges1[i1];
 
        /* Discard r2s while r2 << r1 */
        while (r2 != NULL && range_before_internal(rangetyp, r2, r1))
        {
            r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
        }
 
        while (r2 != NULL)
        {
            if (range_overlaps_internal(rangetyp, r1, r2))
            {
                /* Keep the overlapping part */
                ranges3[range_count3++] = range_intersect_internal(rangetyp, r1, r2);
 
                /* If we "used up" all of r2, go to the next one... */
                if (range_overleft_internal(rangetyp, r2, r1))
                    r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
 
                /* ...otherwise go to the next r1 */
                else
                    break;
            }
            else
                /* We're past r1, so move to the next one */
                break;
        }
 
        /* If we're out of r2s, there can be no more intersections */
        if (r2 == NULL)
            break;
    }
 
    return make_multirange(mltrngtypoid, rangetyp, range_count3, ranges3);
}

References make_multirange(), palloc0(), range_before_internal(), range_intersect_internal(), range_overlaps_internal(), and range_overleft_internal().

Referenced by multirange_intersect(), and multirange_intersect_agg_transfn().

◆ multirange_le()

Datum multirange_le ( PG_FUNCTION_ARGS )

Definition at line 2648 of file multirangetypes.c.

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

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

◆ multirange_lower()

Datum multirange_lower ( PG_FUNCTION_ARGS )

Definition at line 1508 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
 
    if (MultirangeIsEmpty(mr))
        PG_RETURN_NULL();
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    multirange_get_bounds(typcache->rngtype, mr, 0,
                          &lower, &upper);
 
    if (!lower.infinite)
        PG_RETURN_DATUM(lower.val);
    else
        PG_RETURN_NULL();
}

References lower(), multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_DATUM, PG_RETURN_NULL, TypeCacheEntry::rngtype, and upper().

◆ multirange_lower_inc()

Datum multirange_lower_inc ( PG_FUNCTION_ARGS )

Definition at line 1566 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
 
    if (MultirangeIsEmpty(mr))
        PG_RETURN_BOOL(false);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
    multirange_get_bounds(typcache->rngtype, mr, 0,
                          &lower, &upper);
 
    PG_RETURN_BOOL(lower.inclusive);
}

References lower(), multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, TypeCacheEntry::rngtype, and upper().

◆ multirange_lower_inf()

Datum multirange_lower_inf ( PG_FUNCTION_ARGS )

Definition at line 1604 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
 
    if (MultirangeIsEmpty(mr))
        PG_RETURN_BOOL(false);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
    multirange_get_bounds(typcache->rngtype, mr, 0,
                          &lower, &upper);
 
    PG_RETURN_BOOL(lower.infinite);
}

References lower(), multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, TypeCacheEntry::rngtype, and upper().

◆ multirange_lt()

Datum multirange_lt ( PG_FUNCTION_ARGS )

Definition at line 2640 of file multirangetypes.c.

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

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

◆ multirange_minus()

Datum multirange_minus ( PG_FUNCTION_ARGS )

Definition at line 1115 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    Oid         mltrngtypoid = MultirangeTypeGetOid(mr1);
    TypeCacheEntry *typcache;
    TypeCacheEntry *rangetyp;
    int32       range_count1;
    int32       range_count2;
    RangeType **ranges1;
    RangeType **ranges2;
 
    typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
    rangetyp = typcache->rngtype;
 
    if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
        PG_RETURN_MULTIRANGE_P(mr1);
 
    multirange_deserialize(typcache->rngtype, mr1, &range_count1, &ranges1);
    multirange_deserialize(typcache->rngtype, mr2, &range_count2, &ranges2);
 
    PG_RETURN_MULTIRANGE_P(multirange_minus_internal(mltrngtypoid,
                                                     rangetyp,
                                                     range_count1,
                                                     ranges1,
                                                     range_count2,
                                                     ranges2));
}

References multirange_deserialize(), multirange_get_typcache(), multirange_minus_internal(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_MULTIRANGE_P, and TypeCacheEntry::rngtype.

◆ multirange_minus_internal()

MultirangeType * multirange_minus_internal	(	Oid	mltrngtypoid,
		TypeCacheEntry *	rangetyp,
		int32	range_count1,
		RangeType **	ranges1,
		int32	range_count2,
		RangeType **	ranges2
	)

Definition at line 1145 of file multirangetypes.c.

{
    RangeType  *r1;
    RangeType  *r2;
    RangeType **ranges3;
    int32       range_count3;
    int32       i1;
    int32       i2;
 
    /*
     * Worst case: every range in ranges1 makes a different cut to some range
     * in ranges2.
     */
    ranges3 = palloc0((range_count1 + range_count2) * sizeof(RangeType *));
    range_count3 = 0;
 
    /*
     * For each range in mr1, keep subtracting until it's gone or the ranges
     * in mr2 have passed it. After a subtraction we assign what's left back
     * to r1. The parallel progress through mr1 and mr2 is similar to
     * multirange_overlaps_multirange_internal.
     */
    r2 = ranges2[0];
    for (i1 = 0, i2 = 0; i1 < range_count1; i1++)
    {
        r1 = ranges1[i1];
 
        /* Discard r2s while r2 << r1 */
        while (r2 != NULL && range_before_internal(rangetyp, r2, r1))
        {
            r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
        }
 
        while (r2 != NULL)
        {
            if (range_split_internal(rangetyp, r1, r2, &ranges3[range_count3], &r1))
            {
                /*
                 * If r2 takes a bite out of the middle of r1, we need two
                 * outputs
                 */
                range_count3++;
                r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
            }
            else if (range_overlaps_internal(rangetyp, r1, r2))
            {
                /*
                 * If r2 overlaps r1, replace r1 with r1 - r2.
                 */
                r1 = range_minus_internal(rangetyp, r1, r2);
 
                /*
                 * If r2 goes past r1, then we need to stay with it, in case
                 * it hits future r1s. Otherwise we need to keep r1, in case
                 * future r2s hit it. Since we already subtracted, there's no
                 * point in using the overright/overleft calls.
                 */
                if (RangeIsEmpty(r1) || range_before_internal(rangetyp, r1, r2))
                    break;
                else
                    r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
            }
            else
            {
                /*
                 * This and all future r2s are past r1, so keep them. Also
                 * assign whatever is left of r1 to the result.
                 */
                break;
            }
        }
 
        /*
         * Nothing else can remove anything from r1, so keep it. Even if r1 is
         * empty here, make_multirange will remove it.
         */
        ranges3[range_count3++] = r1;
    }
 
    return make_multirange(mltrngtypoid, rangetyp, range_count3, ranges3);
}

References make_multirange(), palloc0(), range_before_internal(), range_minus_internal(), range_overlaps_internal(), range_split_internal(), and RangeIsEmpty.

Referenced by multirange_minus().

◆ multirange_ne()

Datum multirange_ne ( PG_FUNCTION_ARGS )

Definition at line 1924 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    PG_RETURN_BOOL(multirange_ne_internal(typcache->rngtype, mr1, mr2));
}

References multirange_get_typcache(), multirange_ne_internal(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, and TypeCacheEntry::rngtype.

◆ multirange_ne_internal()

bool multirange_ne_internal	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	mr1,
		const MultirangeType *	mr2
	)

Definition at line 1915 of file multirangetypes.c.

{
    return (!multirange_eq_internal(rangetyp, mr1, mr2));
}

References multirange_eq_internal().

Referenced by multirange_ne().

◆ multirange_out()

Datum multirange_out ( PG_FUNCTION_ARGS )

Definition at line 299 of file multirangetypes.c.

{
    MultirangeType *multirange = PG_GETARG_MULTIRANGE_P(0);
    Oid         mltrngtypoid = MultirangeTypeGetOid(multirange);
    MultirangeIOData *cache;
    StringInfoData buf;
    RangeType  *range;
    char       *rangeStr;
    int32       range_count;
    int32       i;
    RangeType **ranges;
 
    cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_output);
 
    initStringInfo(&buf);
 
    appendStringInfoChar(&buf, '{');
 
    multirange_deserialize(cache->typcache->rngtype, multirange, &range_count, &ranges);
    for (i = 0; i < range_count; i++)
    {
        if (i > 0)
            appendStringInfoChar(&buf, ',');
        range = ranges[i];
        rangeStr = OutputFunctionCall(&cache->typioproc, RangeTypePGetDatum(range));
        appendStringInfoString(&buf, rangeStr);
    }
 
    appendStringInfoChar(&buf, '}');
 
    PG_RETURN_CSTRING(buf.data);
}

References appendStringInfoChar(), appendStringInfoString(), buf, get_multirange_io_data(), i, initStringInfo(), IOFunc_output, multirange_deserialize(), MultirangeTypeGetOid, OutputFunctionCall(), PG_GETARG_MULTIRANGE_P, PG_RETURN_CSTRING, range(), RangeTypePGetDatum(), TypeCacheEntry::rngtype, MultirangeIOData::typcache, and MultirangeIOData::typioproc.

Referenced by anycompatiblemultirange_out(), and anymultirange_out().

◆ multirange_overlaps_multirange()

Datum multirange_overlaps_multirange ( PG_FUNCTION_ARGS )

Definition at line 1961 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    PG_RETURN_BOOL(multirange_overlaps_multirange_internal(typcache->rngtype, mr1, mr2));
}

References multirange_get_typcache(), multirange_overlaps_multirange_internal(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, and TypeCacheEntry::rngtype.

◆ multirange_overlaps_multirange_internal()

bool multirange_overlaps_multirange_internal	(	TypeCacheEntry *	rangetyp,
		const MultirangeType *	mr1,
		const MultirangeType *	mr2
	)

Definition at line 2016 of file multirangetypes.c.

{
    int32       range_count1;
    int32       range_count2;
    int32       i1;
    int32       i2;
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
 
    /*
     * Empties never overlap, even with empties. (This seems strange since
     * they *do* contain each other, but we want to follow how ranges work.)
     */
    if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
        return false;
 
    range_count1 = mr1->rangeCount;
    range_count2 = mr2->rangeCount;
 
    /*
     * Every range in mr1 gets a chance to overlap with the ranges in mr2, but
     * we can use their ordering to avoid O(n^2). This is similar to
     * range_overlaps_multirange where r1 : r2 :: mrr : r, but there if we
     * don't find an overlap with r we're done, and here if we don't find an
     * overlap with r2 we try the next r2.
     */
    i1 = 0;
    multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
    for (i1 = 0, i2 = 0; i2 < range_count2; i2++)
    {
        multirange_get_bounds(rangetyp, mr2, i2, &lower2, &upper2);
 
        /* Discard r1s while r1 << r2 */
        while (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0)
        {
            if (++i1 >= range_count1)
                return false;
            multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
        }
 
        /*
         * If r1 && r2, we're done, otherwise we failed to find an overlap for
         * r2, so go to the next one.
         */
        if (range_bounds_overlaps(rangetyp, &lower1, &upper1, &lower2, &upper2))
            return true;
    }
 
    /* We looked through all of mr2 without finding an overlap */
    return false;
}

References multirange_get_bounds(), MultirangeIsEmpty, range_bounds_overlaps(), range_cmp_bounds(), and MultirangeType::rangeCount.

Referenced by multirange_overlaps_multirange().

◆ multirange_overlaps_range()

Datum multirange_overlaps_range ( PG_FUNCTION_ARGS )

Definition at line 1949 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    RangeType  *r = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_overlaps_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_overlaps_multirange_internal(), and TypeCacheEntry::rngtype.

◆ multirange_overleft_multirange()

Datum multirange_overleft_multirange ( PG_FUNCTION_ARGS )

Definition at line 2133 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
 
    if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
        PG_RETURN_BOOL(false);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    multirange_get_bounds(typcache->rngtype, mr1, mr1->rangeCount - 1,
                          &lower1, &upper1);
    multirange_get_bounds(typcache->rngtype, mr2, mr2->rangeCount - 1,
                          &lower2, &upper2);
 
    PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &upper1, &upper2) <= 0);
}

References multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, range_cmp_bounds(), MultirangeType::rangeCount, and TypeCacheEntry::rngtype.

◆ multirange_overleft_range()

Datum multirange_overleft_range ( PG_FUNCTION_ARGS )

Definition at line 2108 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    RangeType  *r = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
    bool        empty;
 
    if (MultirangeIsEmpty(mr) || RangeIsEmpty(r))
        PG_RETURN_BOOL(false);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
                          &lower1, &upper1);
    range_deserialize(typcache->rngtype, r, &lower2, &upper2, &empty);
    Assert(!empty);
 
    PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &upper1, &upper2) <= 0);
}

References Assert(), multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_cmp_bounds(), range_deserialize(), MultirangeType::rangeCount, RangeIsEmpty, and TypeCacheEntry::rngtype.

◆ multirange_overright_multirange()

Datum multirange_overright_multirange ( PG_FUNCTION_ARGS )

Definition at line 2215 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
 
    if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
        PG_RETURN_BOOL(false);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    multirange_get_bounds(typcache->rngtype, mr1, 0, &lower1, &upper1);
    multirange_get_bounds(typcache->rngtype, mr2, 0, &lower2, &upper2);
 
    PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &lower1, &lower2) >= 0);
}

References multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, range_cmp_bounds(), and TypeCacheEntry::rngtype.

◆ multirange_overright_range()

Datum multirange_overright_range ( PG_FUNCTION_ARGS )

Definition at line 2191 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    RangeType  *r = PG_GETARG_RANGE_P(1);
    TypeCacheEntry *typcache;
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
    bool        empty;
 
    if (MultirangeIsEmpty(mr) || RangeIsEmpty(r))
        PG_RETURN_BOOL(false);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    multirange_get_bounds(typcache->rngtype, mr, 0, &lower1, &upper1);
    range_deserialize(typcache->rngtype, r, &lower2, &upper2, &empty);
    Assert(!empty);
 
    PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &lower1, &lower2) >= 0);
}

References Assert(), multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_cmp_bounds(), range_deserialize(), RangeIsEmpty, and TypeCacheEntry::rngtype.

◆ multirange_range_contains_bsearch_comparison()

static int multirange_range_contains_bsearch_comparison	(	TypeCacheEntry *	typcache,
		RangeBound *	lower,
		RangeBound *	upper,
		void *	key,
		bool *	match
	)

static

Definition at line 1775 of file multirangetypes.c.

{
    RangeBound *keyLower = (RangeBound *) key;
    RangeBound *keyUpper = (RangeBound *) key + 1;
 
    /* Check if key range is strictly in the left or in the right */
    if (range_cmp_bounds(typcache, keyUpper, lower) < 0)
        return -1;
    if (range_cmp_bounds(typcache, keyLower, upper) > 0)
        return 1;
 
    /*
     * At this point we found overlapping range.  But we have to check if it
     * really contains the key range.  Anyway, we have to stop our search
     * here, because multirange contains only non-overlapping ranges.
     */
    *match = range_bounds_contains(typcache, lower, upper, keyLower, keyUpper);
 
    return 0;
}

References sort-test::key, lower(), range_bounds_contains(), range_cmp_bounds(), and upper().

Referenced by multirange_contains_range_internal().

◆ multirange_range_overlaps_bsearch_comparison()

static int multirange_range_overlaps_bsearch_comparison	(	TypeCacheEntry *	typcache,
		RangeBound *	lower,
		RangeBound *	upper,
		void *	key,
		bool *	match
	)

static

Definition at line 1977 of file multirangetypes.c.

{
    RangeBound *keyLower = (RangeBound *) key;
    RangeBound *keyUpper = (RangeBound *) key + 1;
 
    if (range_cmp_bounds(typcache, keyUpper, lower) < 0)
        return -1;
    if (range_cmp_bounds(typcache, keyLower, upper) > 0)
        return 1;
 
    *match = true;
    return 0;
}

References sort-test::key, lower(), range_cmp_bounds(), and upper().

Referenced by range_overlaps_multirange_internal().

◆ multirange_recv()

Datum multirange_recv ( PG_FUNCTION_ARGS )

Definition at line 337 of file multirangetypes.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
    Oid         mltrngtypoid = PG_GETARG_OID(1);
    int32       typmod = PG_GETARG_INT32(2);
    MultirangeIOData *cache;
    uint32      range_count;
    RangeType **ranges;
    MultirangeType *ret;
    StringInfoData tmpbuf;
 
    cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_receive);
 
    range_count = pq_getmsgint(buf, 4);
    ranges = palloc(range_count * sizeof(RangeType *));
 
    initStringInfo(&tmpbuf);
    for (int i = 0; i < range_count; i++)
    {
        uint32      range_len = pq_getmsgint(buf, 4);
        const char *range_data = pq_getmsgbytes(buf, range_len);
 
        resetStringInfo(&tmpbuf);
        appendBinaryStringInfo(&tmpbuf, range_data, range_len);
 
        ranges[i] = DatumGetRangeTypeP(ReceiveFunctionCall(&cache->typioproc,
                                                           &tmpbuf,
                                                           cache->typioparam,
                                                           typmod));
    }
    pfree(tmpbuf.data);
 
    pq_getmsgend(buf);
 
    ret = make_multirange(mltrngtypoid, cache->typcache->rngtype,
                          range_count, ranges);
    PG_RETURN_MULTIRANGE_P(ret);
}

References appendBinaryStringInfo(), buf, StringInfoData::data, DatumGetRangeTypeP(), get_multirange_io_data(), i, initStringInfo(), IOFunc_receive, make_multirange(), palloc(), pfree(), PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_MULTIRANGE_P, pq_getmsgbytes(), pq_getmsgend(), pq_getmsgint(), ReceiveFunctionCall(), resetStringInfo(), TypeCacheEntry::rngtype, tmpbuf, MultirangeIOData::typcache, MultirangeIOData::typioparam, and MultirangeIOData::typioproc.

◆ multirange_send()

Datum multirange_send ( PG_FUNCTION_ARGS )

Definition at line 377 of file multirangetypes.c.

{
    MultirangeType *multirange = PG_GETARG_MULTIRANGE_P(0);
    Oid         mltrngtypoid = MultirangeTypeGetOid(multirange);
    StringInfo  buf = makeStringInfo();
    RangeType **ranges;
    int32       range_count;
    MultirangeIOData *cache;
 
    cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_send);
 
    /* construct output */
    pq_begintypsend(buf);
 
    pq_sendint32(buf, multirange->rangeCount);
 
    multirange_deserialize(cache->typcache->rngtype, multirange, &range_count, &ranges);
    for (int i = 0; i < range_count; i++)
    {
        Datum       range;
        bytea      *outputbytes;
 
        range = RangeTypePGetDatum(ranges[i]);
        outputbytes = SendFunctionCall(&cache->typioproc, range);
 
        pq_sendint32(buf, VARSIZE(outputbytes) - VARHDRSZ);
        pq_sendbytes(buf, VARDATA(outputbytes), VARSIZE(outputbytes) - VARHDRSZ);
    }
 
    PG_RETURN_BYTEA_P(pq_endtypsend(buf));
}

References buf, get_multirange_io_data(), i, IOFunc_send, makeStringInfo(), multirange_deserialize(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendbytes(), pq_sendint32(), range(), MultirangeType::rangeCount, RangeTypePGetDatum(), TypeCacheEntry::rngtype, SendFunctionCall(), MultirangeIOData::typcache, MultirangeIOData::typioproc, VARDATA(), VARHDRSZ, and VARSIZE().

◆ multirange_size_estimate()

static Size multirange_size_estimate	(	TypeCacheEntry *	rangetyp,
		int32	range_count,
		RangeType **	ranges
	)

static

Definition at line 570 of file multirangetypes.c.

{
    char        elemalign = rangetyp->rngelemtype->typalign;
    Size        size;
    int32       i;
 
    /*
     * Count space for MultirangeType struct, items and flags.
     */
    size = att_align_nominal(sizeof(MultirangeType) +
                             Max(range_count - 1, 0) * sizeof(uint32) +
                             range_count * sizeof(uint8), elemalign);
 
    /* Count space for range bounds */
    for (i = 0; i < range_count; i++)
        size += att_align_nominal(VARSIZE(ranges[i]) -
                                  sizeof(RangeType) -
                                  sizeof(char), elemalign);
 
    return size;
}

References att_align_nominal, i, Max, TypeCacheEntry::rngelemtype, TypeCacheEntry::typalign, and VARSIZE().

Referenced by make_multirange().

◆ multirange_union()

Datum multirange_union ( PG_FUNCTION_ARGS )

Definition at line 1083 of file multirangetypes.c.

{
    MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
    MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
    int32       range_count1;
    int32       range_count2;
    int32       range_count3;
    RangeType **ranges1;
    RangeType **ranges2;
    RangeType **ranges3;
 
    if (MultirangeIsEmpty(mr1))
        PG_RETURN_MULTIRANGE_P(mr2);
    if (MultirangeIsEmpty(mr2))
        PG_RETURN_MULTIRANGE_P(mr1);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
 
    multirange_deserialize(typcache->rngtype, mr1, &range_count1, &ranges1);
    multirange_deserialize(typcache->rngtype, mr2, &range_count2, &ranges2);
 
    range_count3 = range_count1 + range_count2;
    ranges3 = palloc0(range_count3 * sizeof(RangeType *));
    memcpy(ranges3, ranges1, range_count1 * sizeof(RangeType *));
    memcpy(ranges3 + range_count1, ranges2, range_count2 * sizeof(RangeType *));
    PG_RETURN_MULTIRANGE_P(make_multirange(typcache->type_id, typcache->rngtype,
                                           range_count3, ranges3));
}

References make_multirange(), multirange_deserialize(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, palloc0(), PG_GETARG_MULTIRANGE_P, PG_RETURN_MULTIRANGE_P, TypeCacheEntry::rngtype, and TypeCacheEntry::type_id.

◆ multirange_unnest()

Datum multirange_unnest ( PG_FUNCTION_ARGS )

Definition at line 2713 of file multirangetypes.c.

{
    typedef struct
    {
        MultirangeType *mr;
        TypeCacheEntry *typcache;
        int         index;
    } multirange_unnest_fctx;
 
    FuncCallContext *funcctx;
    multirange_unnest_fctx *fctx;
    MemoryContext oldcontext;
 
    /* stuff done only on the first call of the function */
    if (SRF_IS_FIRSTCALL())
    {
        MultirangeType *mr;
 
        /* create a function context for cross-call persistence */
        funcctx = SRF_FIRSTCALL_INIT();
 
        /*
         * switch to memory context appropriate for multiple function calls
         */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        /*
         * Get the multirange value and detoast if needed.  We can't do this
         * earlier because if we have to detoast, we want the detoasted copy
         * to be in multi_call_memory_ctx, so it will go away when we're done
         * and not before.  (If no detoast happens, we assume the originally
         * passed multirange will stick around till then.)
         */
        mr = PG_GETARG_MULTIRANGE_P(0);
 
        /* allocate memory for user context */
        fctx = (multirange_unnest_fctx *) palloc(sizeof(multirange_unnest_fctx));
 
        /* initialize state */
        fctx->mr = mr;
        fctx->index = 0;
        fctx->typcache = lookup_type_cache(MultirangeTypeGetOid(mr),
                                           TYPECACHE_MULTIRANGE_INFO);
 
        funcctx->user_fctx = fctx;
        MemoryContextSwitchTo(oldcontext);
    }
 
    /* stuff done on every call of the function */
    funcctx = SRF_PERCALL_SETUP();
    fctx = funcctx->user_fctx;
 
    if (fctx->index < fctx->mr->rangeCount)
    {
        RangeType  *range;
 
        range = multirange_get_range(fctx->typcache->rngtype,
                                     fctx->mr,
                                     fctx->index);
        fctx->index++;
 
        SRF_RETURN_NEXT(funcctx, RangeTypePGetDatum(range));
    }
    else
    {
        /* do when there is no more left */
        SRF_RETURN_DONE(funcctx);
    }
}

References lookup_type_cache(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, multirange_get_range(), MultirangeTypeGetOid, palloc(), PG_GETARG_MULTIRANGE_P, range(), RangeTypePGetDatum(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, TYPECACHE_MULTIRANGE_INFO, and FuncCallContext::user_fctx.

◆ multirange_upper()

Datum multirange_upper ( PG_FUNCTION_ARGS )

Definition at line 1531 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
 
    if (MultirangeIsEmpty(mr))
        PG_RETURN_NULL();
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
                          &lower, &upper);
 
    if (!upper.infinite)
        PG_RETURN_DATUM(upper.val);
    else
        PG_RETURN_NULL();
}

References lower(), multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_DATUM, PG_RETURN_NULL, MultirangeType::rangeCount, TypeCacheEntry::rngtype, and upper().

◆ multirange_upper_inc()

Datum multirange_upper_inc ( PG_FUNCTION_ARGS )

Definition at line 1585 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
 
    if (MultirangeIsEmpty(mr))
        PG_RETURN_BOOL(false);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
    multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
                          &lower, &upper);
 
    PG_RETURN_BOOL(upper.inclusive);
}

References lower(), multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, MultirangeType::rangeCount, TypeCacheEntry::rngtype, and upper().

◆ multirange_upper_inf()

Datum multirange_upper_inf ( PG_FUNCTION_ARGS )

Definition at line 1623 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    TypeCacheEntry *typcache;
    RangeBound  lower;
    RangeBound  upper;
 
    if (MultirangeIsEmpty(mr))
        PG_RETURN_BOOL(false);
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
    multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
                          &lower, &upper);
 
    PG_RETURN_BOOL(upper.infinite);
}

References lower(), multirange_get_bounds(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BOOL, MultirangeType::rangeCount, TypeCacheEntry::rngtype, and upper().

◆ range_adjacent_multirange()

Datum range_adjacent_multirange ( PG_FUNCTION_ARGS )

Definition at line 2507 of file multirangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_adjacent_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_adjacent_multirange_internal(), and TypeCacheEntry::rngtype.

◆ range_adjacent_multirange_internal()

bool range_adjacent_multirange_internal	(	TypeCacheEntry *	rangetyp,
		const RangeType *	r,
		const MultirangeType *	mr
	)

Definition at line 2471 of file multirangetypes.c.

{
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
    bool        empty;
    int32       range_count;
 
    if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
        return false;
 
    range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
    Assert(!empty);
 
    range_count = mr->rangeCount;
    multirange_get_bounds(rangetyp, mr, 0,
                          &lower2, &upper2);
 
    if (bounds_adjacent(rangetyp, upper1, lower2))
        return true;
 
    if (range_count > 1)
        multirange_get_bounds(rangetyp, mr, range_count - 1,
                              &lower2, &upper2);
 
    if (bounds_adjacent(rangetyp, upper2, lower1))
        return true;
 
    return false;
}

References Assert(), bounds_adjacent(), multirange_get_bounds(), MultirangeIsEmpty, range_deserialize(), MultirangeType::rangeCount, and RangeIsEmpty.

Referenced by multirange_adjacent_range(), range_adjacent_multirange(), range_gist_consistent_int_multirange(), and range_gist_consistent_leaf_multirange().

◆ range_after_multirange()

Datum range_after_multirange ( PG_FUNCTION_ARGS )

Definition at line 2365 of file multirangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_after_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_after_multirange_internal(), and TypeCacheEntry::rngtype.

◆ range_after_multirange_internal()

bool range_after_multirange_internal	(	TypeCacheEntry *	rangetyp,
		const RangeType *	r,
		const MultirangeType *	mr
	)

Definition at line 2446 of file multirangetypes.c.

{
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
    bool        empty;
    int32       range_count;
 
    if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
        return false;
 
    range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
    Assert(!empty);
 
    range_count = mr->rangeCount;
    multirange_get_bounds(rangetyp, mr, range_count - 1,
                          &lower2, &upper2);
 
    return (range_cmp_bounds(rangetyp, &lower1, &upper2) > 0);
}

References Assert(), multirange_get_bounds(), MultirangeIsEmpty, range_cmp_bounds(), range_deserialize(), MultirangeType::rangeCount, and RangeIsEmpty.

Referenced by multirange_before_range(), range_after_multirange(), range_gist_consistent_int_multirange(), and range_gist_consistent_leaf_multirange().

◆ range_agg_finalfn()

Datum range_agg_finalfn ( PG_FUNCTION_ARGS )

Definition at line 1373 of file multirangetypes.c.

{
    MemoryContext aggContext;
    Oid         mltrngtypoid;
    TypeCacheEntry *typcache;
    ArrayBuildState *state;
    int32       range_count;
    RangeType **ranges;
    int         i;
 
    if (!AggCheckCallContext(fcinfo, &aggContext))
        elog(ERROR, "range_agg_finalfn called in non-aggregate context");
 
    state = PG_ARGISNULL(0) ? NULL : (ArrayBuildState *) PG_GETARG_POINTER(0);
    if (state == NULL)
        /* This shouldn't be possible, but just in case.... */
        PG_RETURN_NULL();
 
    /* Also return NULL if we had zero inputs, like other aggregates */
    range_count = state->nelems;
    if (range_count == 0)
        PG_RETURN_NULL();
 
    mltrngtypoid = get_fn_expr_rettype(fcinfo->flinfo);
    typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
 
    ranges = palloc0(range_count * sizeof(RangeType *));
    for (i = 0; i < range_count; i++)
        ranges[i] = DatumGetRangeTypeP(state->dvalues[i]);
 
    PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypoid, typcache->rngtype, range_count, ranges));
}

References AggCheckCallContext(), DatumGetRangeTypeP(), elog, ERROR, get_fn_expr_rettype(), i, make_multirange(), multirange_get_typcache(), palloc0(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_MULTIRANGE_P, PG_RETURN_NULL, and TypeCacheEntry::rngtype.

◆ range_agg_transfn()

Datum range_agg_transfn ( PG_FUNCTION_ARGS )

Definition at line 1341 of file multirangetypes.c.

{
    MemoryContext aggContext;
    Oid         rngtypoid;
    ArrayBuildState *state;
 
    if (!AggCheckCallContext(fcinfo, &aggContext))
        elog(ERROR, "range_agg_transfn called in non-aggregate context");
 
    rngtypoid = get_fn_expr_argtype(fcinfo->flinfo, 1);
    if (!type_is_range(rngtypoid))
        elog(ERROR, "range_agg must be called with a range");
 
    if (PG_ARGISNULL(0))
        state = initArrayResult(rngtypoid, aggContext, false);
    else
        state = (ArrayBuildState *) PG_GETARG_POINTER(0);
 
    /* skip NULLs */
    if (!PG_ARGISNULL(1))
        accumArrayResult(state, PG_GETARG_DATUM(1), false, rngtypoid, aggContext);
 
    PG_RETURN_POINTER(state);
}

References accumArrayResult(), AggCheckCallContext(), elog, ERROR, get_fn_expr_argtype(), initArrayResult(), PG_ARGISNULL, PG_GETARG_DATUM, PG_GETARG_POINTER, PG_RETURN_POINTER, and type_is_range().

◆ range_before_multirange()

Datum range_before_multirange ( PG_FUNCTION_ARGS )

Definition at line 2328 of file multirangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_before_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_before_multirange_internal(), and TypeCacheEntry::rngtype.

◆ range_before_multirange_internal()

bool range_before_multirange_internal	(	TypeCacheEntry *	rangetyp,
		const RangeType *	r,
		const MultirangeType *	mr
	)

Definition at line 2402 of file multirangetypes.c.

{
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
    bool        empty;
 
    if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
        return false;
 
    range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
    Assert(!empty);
 
    multirange_get_bounds(rangetyp, mr, 0, &lower2, &upper2);
 
    return (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0);
}

References Assert(), multirange_get_bounds(), MultirangeIsEmpty, range_cmp_bounds(), range_deserialize(), and RangeIsEmpty.

Referenced by multirange_after_range(), range_before_multirange(), range_gist_consistent_int_multirange(), and range_gist_consistent_leaf_multirange().

◆ range_bounds_contains()

static bool range_bounds_contains	(	TypeCacheEntry *	typcache,
		RangeBound *	lower1,
		RangeBound *	upper1,
		RangeBound *	lower2,
		RangeBound *	upper2
	)

static

Definition at line 879 of file multirangetypes.c.

{
    if (range_cmp_bounds(typcache, lower1, lower2) <= 0 &&
        range_cmp_bounds(typcache, upper1, upper2) >= 0)
        return true;
 
    return false;
}

References range_cmp_bounds().

Referenced by multirange_contains_multirange_internal(), multirange_range_contains_bsearch_comparison(), and range_contains_multirange_internal().

◆ range_bounds_overlaps()

static bool range_bounds_overlaps	(	TypeCacheEntry *	typcache,
		RangeBound *	lower1,
		RangeBound *	upper1,
		RangeBound *	lower2,
		RangeBound *	upper2
	)

static

Definition at line 859 of file multirangetypes.c.

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

Referenced by multirange_overlaps_multirange_internal().

◆ range_contained_by_multirange()

Datum range_contained_by_multirange ( PG_FUNCTION_ARGS )

Definition at line 1747 of file multirangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(multirange_contains_range_internal(typcache->rngtype, mr, r));
}

References multirange_contains_range_internal(), multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, and TypeCacheEntry::rngtype.

◆ range_contains_multirange()

Datum range_contains_multirange ( PG_FUNCTION_ARGS )

Definition at line 1734 of file multirangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_contains_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_contains_multirange_internal(), and TypeCacheEntry::rngtype.

◆ range_contains_multirange_internal()

bool range_contains_multirange_internal	(	TypeCacheEntry *	rangetyp,
		const RangeType *	r,
		const MultirangeType *	mr
	)

Definition at line 1830 of file multirangetypes.c.

{
    RangeBound  lower1,
                upper1,
                lower2,
                upper2,
                tmp;
    bool        empty;
 
    /*
     * Every range contains an infinite number of empty multiranges, even an
     * empty one.
     */
    if (MultirangeIsEmpty(mr))
        return true;
 
    if (RangeIsEmpty(r))
        return false;
 
    /* Range contains multirange iff it contains its union range. */
    range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
    Assert(!empty);
    multirange_get_bounds(rangetyp, mr, 0, &lower2, &tmp);
    multirange_get_bounds(rangetyp, mr, mr->rangeCount - 1, &tmp, &upper2);
 
    return range_bounds_contains(rangetyp, &lower1, &upper1, &lower2, &upper2);
}

References Assert(), multirange_get_bounds(), MultirangeIsEmpty, range_bounds_contains(), range_deserialize(), MultirangeType::rangeCount, and RangeIsEmpty.

Referenced by multirange_contained_by_range(), range_contains_multirange(), range_gist_consistent_int_multirange(), and range_gist_consistent_leaf_multirange().

◆ range_merge_from_multirange()

Datum range_merge_from_multirange ( PG_FUNCTION_ARGS )

Definition at line 2675 of file multirangetypes.c.

{
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
    Oid         mltrngtypoid = MultirangeTypeGetOid(mr);
    TypeCacheEntry *typcache;
    RangeType  *result;
 
    typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
 
    if (MultirangeIsEmpty(mr))
    {
        result = make_empty_range(typcache->rngtype);
    }
    else if (mr->rangeCount == 1)
    {
        result = multirange_get_range(typcache->rngtype, mr, 0);
    }
    else
    {
        RangeBound  firstLower,
                    firstUpper,
                    lastLower,
                    lastUpper;
 
        multirange_get_bounds(typcache->rngtype, mr, 0,
                              &firstLower, &firstUpper);
        multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
                              &lastLower, &lastUpper);
 
        result = make_range(typcache->rngtype, &firstLower, &lastUpper,
                            false, NULL);
    }
 
    PG_RETURN_RANGE_P(result);
}

References make_empty_range(), make_range(), multirange_get_bounds(), multirange_get_range(), multirange_get_typcache(), MultirangeIsEmpty, MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_RANGE_P, MultirangeType::rangeCount, and TypeCacheEntry::rngtype.

◆ range_overlaps_multirange()

Datum range_overlaps_multirange ( PG_FUNCTION_ARGS )

Definition at line 1937 of file multirangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_overlaps_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_overlaps_multirange_internal(), and TypeCacheEntry::rngtype.

◆ range_overlaps_multirange_internal()

bool range_overlaps_multirange_internal	(	TypeCacheEntry *	rangetyp,
		const RangeType *	r,
		const MultirangeType *	mr
	)

Definition at line 1994 of file multirangetypes.c.

{
    RangeBound  bounds[2];
    bool        empty;
 
    /*
     * Empties never overlap, even with empties. (This seems strange since
     * they *do* contain each other, but we want to follow how ranges work.)
     */
    if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
        return false;
 
    range_deserialize(rangetyp, r, &bounds[0], &bounds[1], &empty);
    Assert(!empty);
 
    return multirange_bsearch_match(rangetyp, mr, bounds,
                                    multirange_range_overlaps_bsearch_comparison);
}

References Assert(), multirange_bsearch_match(), multirange_range_overlaps_bsearch_comparison(), MultirangeIsEmpty, range_deserialize(), and RangeIsEmpty.

Referenced by multirange_overlaps_range(), range_gist_consistent_int_multirange(), range_gist_consistent_leaf_multirange(), and range_overlaps_multirange().

◆ range_overleft_multirange()

Datum range_overleft_multirange ( PG_FUNCTION_ARGS )

Definition at line 2096 of file multirangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_overleft_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_overleft_multirange_internal(), and TypeCacheEntry::rngtype.

◆ range_overleft_multirange_internal()

bool range_overleft_multirange_internal	(	TypeCacheEntry *	rangetyp,
		const RangeType *	r,
		const MultirangeType *	mr
	)

Definition at line 2074 of file multirangetypes.c.

{
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
    bool        empty;
 
    if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
        return false;
 
    range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
    Assert(!empty);
    multirange_get_bounds(rangetyp, mr, mr->rangeCount - 1,
                          &lower2, &upper2);
 
    return (range_cmp_bounds(rangetyp, &upper1, &upper2) <= 0);
}

References Assert(), multirange_get_bounds(), MultirangeIsEmpty, range_cmp_bounds(), range_deserialize(), MultirangeType::rangeCount, and RangeIsEmpty.

Referenced by range_gist_consistent_int_multirange(), range_gist_consistent_leaf_multirange(), and range_overleft_multirange().

◆ range_overright_multirange()

Datum range_overright_multirange ( PG_FUNCTION_ARGS )

Definition at line 2179 of file multirangetypes.c.

{
    RangeType  *r = PG_GETARG_RANGE_P(0);
    MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
    TypeCacheEntry *typcache;
 
    typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
 
    PG_RETURN_BOOL(range_overright_multirange_internal(typcache->rngtype, r, mr));
}

References multirange_get_typcache(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_GETARG_RANGE_P, PG_RETURN_BOOL, range_overright_multirange_internal(), and TypeCacheEntry::rngtype.

◆ range_overright_multirange_internal()

bool range_overright_multirange_internal	(	TypeCacheEntry *	rangetyp,
		const RangeType *	r,
		const MultirangeType *	mr
	)

Definition at line 2158 of file multirangetypes.c.

{
    RangeBound  lower1,
                upper1,
                lower2,
                upper2;
    bool        empty;
 
    if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
        return false;
 
    range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
    Assert(!empty);
    multirange_get_bounds(rangetyp, mr, 0, &lower2, &upper2);
 
    return (range_cmp_bounds(rangetyp, &lower1, &lower2) >= 0);
}

References Assert(), multirange_get_bounds(), MultirangeIsEmpty, range_cmp_bounds(), range_deserialize(), and RangeIsEmpty.

Referenced by range_gist_consistent_int_multirange(), range_gist_consistent_leaf_multirange(), and range_overright_multirange().

◆ write_multirange_data()

static void write_multirange_data	(	MultirangeType *	multirange,
		TypeCacheEntry *	rangetyp,
		int32	range_count,
		RangeType **	ranges
	)

static

Definition at line 597 of file multirangetypes.c.

{
    uint32     *items;
    uint32      prev_offset = 0;
    uint8      *flags;
    int32       i;
    Pointer     begin,
                ptr;
    char        elemalign = rangetyp->rngelemtype->typalign;
 
    items = MultirangeGetItemsPtr(multirange);
    flags = MultirangeGetFlagsPtr(multirange);
    ptr = begin = MultirangeGetBoundariesPtr(multirange, elemalign);
    for (i = 0; i < range_count; i++)
    {
        uint32      len;
 
        if (i > 0)
        {
            /*
             * Every range, except the first one, has an item.  Every
             * MULTIRANGE_ITEM_OFFSET_STRIDE item contains an offset, others
             * contain lengths.
             */
            items[i - 1] = ptr - begin;
            if ((i % MULTIRANGE_ITEM_OFFSET_STRIDE) != 0)
                items[i - 1] -= prev_offset;
            else
                items[i - 1] |= MULTIRANGE_ITEM_OFF_BIT;
            prev_offset = ptr - begin;
        }
        flags[i] = *((Pointer) ranges[i] + VARSIZE(ranges[i]) - sizeof(char));
        len = VARSIZE(ranges[i]) - sizeof(RangeType) - sizeof(char);
        memcpy(ptr, (Pointer) (ranges[i] + 1), len);
        ptr += att_align_nominal(len, elemalign);
    }
}

References att_align_nominal, i, items, len, MULTIRANGE_ITEM_OFF_BIT, MULTIRANGE_ITEM_OFFSET_STRIDE, MultirangeGetBoundariesPtr, MultirangeGetFlagsPtr, MultirangeGetItemsPtr, TypeCacheEntry::rngelemtype, TypeCacheEntry::typalign, and VARSIZE().

Referenced by make_multirange().

Data Structures

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ MULTIRANGE_ITEM_GET_OFFLEN

◆ MULTIRANGE_ITEM_HAS_OFF

◆ MULTIRANGE_ITEM_OFF_BIT

◆ MULTIRANGE_ITEM_OFFSET_STRIDE

◆ MultirangeGetBoundariesPtr

◆ MultirangeGetFlagsPtr

◆ MultirangeGetItemsPtr

Typedef Documentation

◆ multirange_bsearch_comparison

◆ MultirangeIOData

Enumeration Type Documentation

◆ MultirangeParseState

Function Documentation

◆ elem_contained_by_multirange()

◆ get_multirange_io_data()

◆ hash_multirange()

◆ hash_multirange_extended()

◆ make_empty_multirange()

◆ make_multirange()

◆ multirange_adjacent_multirange()

◆ multirange_adjacent_range()

◆ multirange_after_multirange()

◆ multirange_after_range()

◆ multirange_agg_transfn()

◆ multirange_before_multirange()

◆ multirange_before_multirange_internal()

◆ multirange_before_range()

◆ multirange_bsearch_match()

◆ multirange_canonicalize()

◆ multirange_cmp()

◆ multirange_constructor0()

◆ multirange_constructor1()

◆ multirange_constructor2()

◆ multirange_contained_by_multirange()

◆ multirange_contained_by_range()

◆ multirange_contains_elem()

◆ multirange_contains_elem_internal()

◆ multirange_contains_multirange()

◆ multirange_contains_multirange_internal()

◆ multirange_contains_range()

◆ multirange_contains_range_internal()

◆ multirange_deserialize()

◆ multirange_elem_bsearch_comparison()

◆ multirange_empty()

◆ multirange_eq()

◆ multirange_eq_internal()

◆ multirange_ge()

◆ multirange_get_bounds()

◆ multirange_get_bounds_offset()

◆ multirange_get_range()

◆ multirange_get_typcache()

◆ multirange_get_union_range()

◆ multirange_gt()

◆ multirange_in()

◆ multirange_intersect()

◆ multirange_intersect_agg_transfn()

◆ multirange_intersect_internal()

◆ multirange_le()

◆ multirange_lower()

◆ multirange_lower_inc()

◆ multirange_lower_inf()

◆ multirange_lt()

◆ multirange_minus()

◆ multirange_minus_internal()

◆ multirange_ne()

◆ multirange_ne_internal()

◆ multirange_out()

◆ multirange_overlaps_multirange()

◆ multirange_overlaps_multirange_internal()

◆ multirange_overlaps_range()

◆ multirange_overleft_multirange()

◆ multirange_overleft_range()

◆ multirange_overright_multirange()

◆ multirange_overright_range()