PostgreSQL Source Code git master
Loading...
Searching...
No Matches
Data Structures | Macros | Typedefs | Enumerations | Functions
multirangetypes.c File Reference
#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:

Go to the source code of this file.

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_minus_multi (PG_FUNCTION_ARGS)
 
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:
((char *) (mr) + \
att_align_nominal(sizeof(MultirangeType) + \
((mr)->rangeCount - 1) * sizeof(uint32) + \
(mr)->rangeCount * sizeof(uint8), (align)))
uint8
uint8_t uint8
Definition c.h:622
uint32
uint32_t uint32
Definition c.h:624
fb
static int fb(int x)
Definition preproc-init.c:92

Definition at line 75 of file multirangetypes.c.

117{
118 char *input_str = PG_GETARG_CSTRING(0);
119 Oid mltrngtypoid = PG_GETARG_OID(1);
120 Oid typmod = PG_GETARG_INT32(2);
121 Node *escontext = fcinfo->context;
122 TypeCacheEntry *rangetyp;
123 int32 ranges_seen = 0;
124 int32 range_count = 0;
125 int32 range_capacity = 8;
126 RangeType *range;
127 RangeType **ranges = palloc_array(RangeType *, range_capacity);
128 MultirangeIOData *cache;
129 MultirangeType *ret;
130 MultirangeParseState parse_state;
131 const char *ptr = input_str;
132 const char *range_str_begin = NULL;
133 int32 range_str_len;
134 char *range_str;
135 Datum range_datum;
136
137 cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_input);
138 rangetyp = cache->typcache->rngtype;
139
140 /* consume whitespace */
141 while (*ptr != '\0' && isspace((unsigned char) *ptr))
142 ptr++;
143
144 if (*ptr == '{')
145 ptr++;
146 else
147 ereturn(escontext, (Datum) 0,
148 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
149 errmsg("malformed multirange literal: \"%s\"",
150 input_str),
151 errdetail("Missing left brace.")));
152
153 /* consume ranges */
154 parse_state = MULTIRANGE_BEFORE_RANGE;
155 for (; parse_state != MULTIRANGE_FINISHED; ptr++)
156 {
157 char ch = *ptr;
158
159 if (ch == '\0')
160 ereturn(escontext, (Datum) 0,
161 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
162 errmsg("malformed multirange literal: \"%s\"",
163 input_str),
164 errdetail("Unexpected end of input.")));
165
166 /* skip whitespace */
167 if (isspace((unsigned char) ch))
168 continue;
169
170 switch (parse_state)
171 {
172 case MULTIRANGE_BEFORE_RANGE:
173 if (ch == '[' || ch == '(')
174 {
175 range_str_begin = ptr;
176 parse_state = MULTIRANGE_IN_RANGE;
177 }
178 else if (ch == '}' && ranges_seen == 0)
179 parse_state = MULTIRANGE_FINISHED;
180 else if (pg_strncasecmp(ptr, RANGE_EMPTY_LITERAL,
181 strlen(RANGE_EMPTY_LITERAL)) == 0)
182 {
183 ranges_seen++;
184 /* nothing to do with an empty range */
185 ptr += strlen(RANGE_EMPTY_LITERAL) - 1;
186 parse_state = MULTIRANGE_AFTER_RANGE;
187 }
188 else
189 ereturn(escontext, (Datum) 0,
190 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
191 errmsg("malformed multirange literal: \"%s\"",
192 input_str),
193 errdetail("Expected range start.")));
194 break;
195 case MULTIRANGE_IN_RANGE:
196 if (ch == ']' || ch == ')')
197 {
198 range_str_len = ptr - range_str_begin + 1;
199 range_str = pnstrdup(range_str_begin, range_str_len);
200 if (range_capacity == range_count)
201 {
202 range_capacity *= 2;
203 ranges = (RangeType **)
204 repalloc(ranges, range_capacity * sizeof(RangeType *));
205 }
206 ranges_seen++;
207 if (!InputFunctionCallSafe(&cache->typioproc,
208 range_str,
209 cache->typioparam,
210 typmod,
211 escontext,
212 &range_datum))
213 PG_RETURN_NULL();
214 range = DatumGetRangeTypeP(range_datum);
215 if (!RangeIsEmpty(range))
216 ranges[range_count++] = range;
217 parse_state = MULTIRANGE_AFTER_RANGE;
218 }
219 else
220 {
221 if (ch == '"')
222 parse_state = MULTIRANGE_IN_RANGE_QUOTED;
223 else if (ch == '\\')
224 parse_state = MULTIRANGE_IN_RANGE_ESCAPED;
225
226 /*
227 * We will include this character into range_str once we
228 * find the end of the range value.
229 */
230 }
231 break;
232 case MULTIRANGE_IN_RANGE_ESCAPED:
233
234 /*
235 * We will include this character into range_str once we find
236 * the end of the range value.
237 */
238 parse_state = MULTIRANGE_IN_RANGE;
239 break;
240 case MULTIRANGE_IN_RANGE_QUOTED:
241 if (ch == '"')
242 if (*(ptr + 1) == '"')
243 {
244 /* two quote marks means an escaped quote mark */
245 ptr++;
246 }
247 else
248 parse_state = MULTIRANGE_IN_RANGE;
249 else if (ch == '\\')
250 parse_state = MULTIRANGE_IN_RANGE_QUOTED_ESCAPED;
251
252 /*
253 * We will include this character into range_str once we find
254 * the end of the range value.
255 */
256 break;
257 case MULTIRANGE_AFTER_RANGE:
258 if (ch == ',')
259 parse_state = MULTIRANGE_BEFORE_RANGE;
260 else if (ch == '}')
261 parse_state = MULTIRANGE_FINISHED;
262 else
263 ereturn(escontext, (Datum) 0,
264 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
265 errmsg("malformed multirange literal: \"%s\"",
266 input_str),
267 errdetail("Expected comma or end of multirange.")));
268 break;
269 case MULTIRANGE_IN_RANGE_QUOTED_ESCAPED:
270
271 /*
272 * We will include this character into range_str once we find
273 * the end of the range value.
274 */
275 parse_state = MULTIRANGE_IN_RANGE_QUOTED;
276 break;
277 default:
278 elog(ERROR, "unknown parse state: %d", parse_state);
279 }
280 }
281
282 /* consume whitespace */
283 while (*ptr != '\0' && isspace((unsigned char) *ptr))
284 ptr++;
285
286 if (*ptr != '\0')
287 ereturn(escontext, (Datum) 0,
288 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
289 errmsg("malformed multirange literal: \"%s\"",
290 input_str),
291 errdetail("Junk after closing right brace.")));
292
293 ret = make_multirange(mltrngtypoid, rangetyp, range_count, ranges);
294 PG_RETURN_MULTIRANGE_P(ret);
295}
296
297Datum
298multirange_out(PG_FUNCTION_ARGS)
299{
300 MultirangeType *multirange = PG_GETARG_MULTIRANGE_P(0);
301 Oid mltrngtypoid = MultirangeTypeGetOid(multirange);
302 MultirangeIOData *cache;
303 StringInfoData buf;
304 RangeType *range;
305 char *rangeStr;
306 int32 range_count;
307 int32 i;
308 RangeType **ranges;
309
310 cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_output);
311
312 initStringInfo(&buf);
313
314 appendStringInfoChar(&buf, '{');
315
316 multirange_deserialize(cache->typcache->rngtype, multirange, &range_count, &ranges);
317 for (i = 0; i < range_count; i++)
318 {
319 if (i > 0)
320 appendStringInfoChar(&buf, ',');
321 range = ranges[i];
322 rangeStr = OutputFunctionCall(&cache->typioproc, RangeTypePGetDatum(range));
323 appendStringInfoString(&buf, rangeStr);
324 }
325
326 appendStringInfoChar(&buf, '}');
327
328 PG_RETURN_CSTRING(buf.data);
329}
330
331/*
332 * Binary representation: First an int32-sized count of ranges, followed by
333 * ranges in their native binary representation.
334 */
335Datum
336multirange_recv(PG_FUNCTION_ARGS)
337{
338 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
339 Oid mltrngtypoid = PG_GETARG_OID(1);
340 int32 typmod = PG_GETARG_INT32(2);
341 MultirangeIOData *cache;
342 int32 range_count;
343 RangeType **ranges;
344 MultirangeType *ret;
345 StringInfoData tmpbuf;
346
347 cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_receive);
348
349 range_count = pq_getmsgint(buf, 4);
350 /* palloc_array will enforce a more-or-less-sane range_count value */
351 ranges = palloc_array(RangeType *, range_count);
352
353 initStringInfo(&tmpbuf);
354 for (int i = 0; i < range_count; i++)
355 {
356 uint32 range_len = pq_getmsgint(buf, 4);
357 const char *range_data = pq_getmsgbytes(buf, range_len);
358
359 resetStringInfo(&tmpbuf);
360 appendBinaryStringInfo(&tmpbuf, range_data, range_len);
361
362 ranges[i] = DatumGetRangeTypeP(ReceiveFunctionCall(&cache->typioproc,
363 &tmpbuf,
364 cache->typioparam,
365 typmod));
366 }
367 pfree(tmpbuf.data);
368
369 pq_getmsgend(buf);
370
371 ret = make_multirange(mltrngtypoid, cache->typcache->rngtype,
372 range_count, ranges);
373 PG_RETURN_MULTIRANGE_P(ret);
374}
375
376Datum
377multirange_send(PG_FUNCTION_ARGS)
378{
379 MultirangeType *multirange = PG_GETARG_MULTIRANGE_P(0);
380 Oid mltrngtypoid = MultirangeTypeGetOid(multirange);
381 StringInfoData buf;
382 RangeType **ranges;
383 int32 range_count;
384 MultirangeIOData *cache;
385
386 initStringInfo(&buf);
387 cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_send);
388
389 /* construct output */
390 pq_begintypsend(&buf);
391
392 pq_sendint32(&buf, multirange->rangeCount);
393
394 multirange_deserialize(cache->typcache->rngtype, multirange, &range_count, &ranges);
395 for (int i = 0; i < range_count; i++)
396 {
397 Datum range;
398 bytea *outputbytes;
399
400 range = RangeTypePGetDatum(ranges[i]);
401 outputbytes = SendFunctionCall(&cache->typioproc, range);
402
403 pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
404 pq_sendbytes(&buf, VARDATA(outputbytes), VARSIZE(outputbytes) - VARHDRSZ);
405 }
406
407 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
408}
409
410/*
411 * get_multirange_io_data: get cached information needed for multirange type I/O
412 *
413 * The multirange I/O functions need a bit more cached info than other multirange
414 * functions, so they store a MultirangeIOData struct in fn_extra, not just a
415 * pointer to a type cache entry.
416 */
417static MultirangeIOData *
418get_multirange_io_data(FunctionCallInfo fcinfo, Oid mltrngtypid, IOFuncSelector func)
419{
420 MultirangeIOData *cache = (MultirangeIOData *) fcinfo->flinfo->fn_extra;
421
422 if (cache == NULL || cache->typcache->type_id != mltrngtypid)
423 {
424 Oid typiofunc;
425 int16 typlen;
426 bool typbyval;
427 char typalign;
428 char typdelim;
429
430 cache = (MultirangeIOData *) MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
431 sizeof(MultirangeIOData));
432 cache->typcache = lookup_type_cache(mltrngtypid, TYPECACHE_MULTIRANGE_INFO);
433 if (cache->typcache->rngtype == NULL)
434 elog(ERROR, "type %u is not a multirange type", mltrngtypid);
435
436 /* get_type_io_data does more than we need, but is convenient */
437 get_type_io_data(cache->typcache->rngtype->type_id,
438 func,
439 &typlen,
440 &typbyval,
441 &typalign,
442 &typdelim,
443 &cache->typioparam,
444 &typiofunc);
445
446 if (!OidIsValid(typiofunc))
447 {
448 /* this could only happen for receive or send */
449 if (func == IOFunc_receive)
450 ereport(ERROR,
451 (errcode(ERRCODE_UNDEFINED_FUNCTION),
452 errmsg("no binary input function available for type %s",
453 format_type_be(cache->typcache->rngtype->type_id))));
454 else
455 ereport(ERROR,
456 (errcode(ERRCODE_UNDEFINED_FUNCTION),
457 errmsg("no binary output function available for type %s",
458 format_type_be(cache->typcache->rngtype->type_id))));
459 }
460 fmgr_info_cxt(typiofunc, &cache->typioproc,
461 fcinfo->flinfo->fn_mcxt);
462
463 fcinfo->flinfo->fn_extra = cache;
464 }
465
466 return cache;
467}
468
469/*
470 * Converts a list of arbitrary ranges into a list that is sorted and merged.
471 * Changes the contents of `ranges`.
472 *
473 * Returns the number of slots actually used, which may be less than
474 * input_range_count but never more.
475 *
476 * We assume that no input ranges are null, but empties are okay.
477 */
478static int32
479multirange_canonicalize(TypeCacheEntry *rangetyp, int32 input_range_count,
480 RangeType **ranges)
481{
482 RangeType *lastRange = NULL;
483 RangeType *currentRange;
484 int32 i;
485 int32 output_range_count = 0;
486
487 /* Sort the ranges so we can find the ones that overlap/meet. */
488 if (ranges != NULL)
489 qsort_arg(ranges, input_range_count, sizeof(RangeType *),
490 range_compare, rangetyp);
491
492 /* Now merge where possible: */
493 for (i = 0; i < input_range_count; i++)
494 {
495 currentRange = ranges[i];
496 if (RangeIsEmpty(currentRange))
497 continue;
498
499 if (lastRange == NULL)
500 {
501 ranges[output_range_count++] = lastRange = currentRange;
502 continue;
503 }
504
505 /*
506 * range_adjacent_internal gives true if *either* A meets B or B meets
507 * A, which is not quite want we want, but we rely on the sorting
508 * above to rule out B meets A ever happening.
509 */
510 if (range_adjacent_internal(rangetyp, lastRange, currentRange))
511 {
512 /* The two ranges touch (without overlap), so merge them: */
513 ranges[output_range_count - 1] = lastRange =
514 range_union_internal(rangetyp, lastRange, currentRange, false);
515 }
516 else if (range_before_internal(rangetyp, lastRange, currentRange))
517 {
518 /* There's a gap, so make a new entry: */
519 lastRange = ranges[output_range_count] = currentRange;
520 output_range_count++;
521 }
522 else
523 {
524 /* They must overlap, so merge them: */
525 ranges[output_range_count - 1] = lastRange =
526 range_union_internal(rangetyp, lastRange, currentRange, true);
527 }
528 }
529
530 return output_range_count;
531}
532
533/*
534 *----------------------------------------------------------
535 * SUPPORT FUNCTIONS
536 *
537 * These functions aren't in pg_proc, but are useful for
538 * defining new generic multirange functions in C.
539 *----------------------------------------------------------
540 */
541
542/*
543 * multirange_get_typcache: get cached information about a multirange type
544 *
545 * This is for use by multirange-related functions that follow the convention
546 * of using the fn_extra field as a pointer to the type cache entry for
547 * the multirange type. Functions that need to cache more information than
548 * that must fend for themselves.
549 */
550TypeCacheEntry *
551multirange_get_typcache(FunctionCallInfo fcinfo, Oid mltrngtypid)
552{
553 TypeCacheEntry *typcache = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
554
555 if (typcache == NULL ||
556 typcache->type_id != mltrngtypid)
557 {
558 typcache = lookup_type_cache(mltrngtypid, TYPECACHE_MULTIRANGE_INFO);
559 if (typcache->rngtype == NULL)
560 elog(ERROR, "type %u is not a multirange type", mltrngtypid);
561 fcinfo->flinfo->fn_extra = typcache;
562 }
563
564 return typcache;
565}
566
567
568/*
569 * Estimate size occupied by serialized multirange.
570 */
571static Size
572multirange_size_estimate(TypeCacheEntry *rangetyp, int32 range_count,
573 RangeType **ranges)
574{
575 char elemalign = rangetyp->rngelemtype->typalign;
576 uint8 elemalignby = typalign_to_alignby(elemalign);
577 Size size;
578 int32 i;
579
580 /*
581 * Count space for MultirangeType struct, items and flags.
582 */
583 size = att_nominal_alignby(sizeof(MultirangeType) +
584 Max(range_count - 1, 0) * sizeof(uint32) +
585 range_count * sizeof(uint8), elemalignby);
586
587 /* Count space for range bounds */
588 for (i = 0; i < range_count; i++)
589 size += att_nominal_alignby(VARSIZE(ranges[i]) -
590 sizeof(RangeType) -
591 sizeof(char), elemalignby);
592
593 return size;
594}
595
596/*
597 * Write multirange data into pre-allocated space.
598 */
599static void
600write_multirange_data(MultirangeType *multirange, TypeCacheEntry *rangetyp,
601 int32 range_count, RangeType **ranges)
602{
603 uint32 *items;
604 uint32 prev_offset = 0;
605 uint8 *flags;
606 int32 i;
607 const char *begin;
608 char *ptr;
609 char elemalign = rangetyp->rngelemtype->typalign;
610 uint8 elemalignby = typalign_to_alignby(elemalign);
611
612 items = MultirangeGetItemsPtr(multirange);
613 flags = MultirangeGetFlagsPtr(multirange);
614 begin = ptr = MultirangeGetBoundariesPtr(multirange, elemalign);
615 for (i = 0; i < range_count; i++)
616 {
617 uint32 len;
618
619 if (i > 0)
620 {
621 /*
622 * Every range, except the first one, has an item. Every
623 * MULTIRANGE_ITEM_OFFSET_STRIDE item contains an offset, others
624 * contain lengths.
625 */
626 items[i - 1] = ptr - begin;
627 if ((i % MULTIRANGE_ITEM_OFFSET_STRIDE) != 0)
628 items[i - 1] -= prev_offset;
629 else
630 items[i - 1] |= MULTIRANGE_ITEM_OFF_BIT;
631 prev_offset = ptr - begin;
632 }
633 flags[i] = *((char *) ranges[i] + VARSIZE(ranges[i]) - sizeof(char));
634 len = VARSIZE(ranges[i]) - sizeof(RangeType) - sizeof(char);
635 memcpy(ptr, ranges[i] + 1, len);
636 ptr += att_nominal_alignby(len, elemalignby);
637 }
638}
639
640
641/*
642 * This serializes the multirange from a list of non-null ranges. It also
643 * sorts the ranges and merges any that touch. The ranges should already be
644 * detoasted, and there should be no NULLs. This should be used by most
645 * callers.
646 *
647 * Note that we may change the `ranges` parameter (the pointers, but not
648 * any already-existing RangeType contents).
649 */
650MultirangeType *
651make_multirange(Oid mltrngtypoid, TypeCacheEntry *rangetyp, int32 range_count,
652 RangeType **ranges)
653{
654 MultirangeType *multirange;
655 Size size;
656
657 /* Sort and merge input ranges. */
658 range_count = multirange_canonicalize(rangetyp, range_count, ranges);
659
660 /* Note: zero-fill is required here, just as in heap tuples */
661 size = multirange_size_estimate(rangetyp, range_count, ranges);
662 multirange = palloc0(size);
663 SET_VARSIZE(multirange, size);
664
665 /* Now fill in the datum */
666 multirange->multirangetypid = mltrngtypoid;
667 multirange->rangeCount = range_count;
668
669 write_multirange_data(multirange, rangetyp, range_count, ranges);
670
671 return multirange;
672}
673
674/*
675 * Get offset of bounds values of the i'th range in the multirange.
676 */
677static uint32
678multirange_get_bounds_offset(const MultirangeType *multirange, int32 i)
679{
680 uint32 *items = MultirangeGetItemsPtr(multirange);
681 uint32 offset = 0;
682
683 /*
684 * Summarize lengths till we meet an offset.
685 */
686 while (i > 0)
687 {
688 offset += MULTIRANGE_ITEM_GET_OFFLEN(items[i - 1]);
689 if (MULTIRANGE_ITEM_HAS_OFF(items[i - 1]))
690 break;
691 i--;
692 }
693 return offset;
694}
695
696/*
697 * Fetch the i'th range from the multirange.
698 */
699RangeType *
700multirange_get_range(TypeCacheEntry *rangetyp,
701 const MultirangeType *multirange, int i)
702{
703 uint32 offset;
704 uint8 flags;
705 const char *begin;
706 char *ptr;
707 int16 typlen = rangetyp->rngelemtype->typlen;
708 char typalign = rangetyp->rngelemtype->typalign;
709 uint32 len;
710 RangeType *range;
711
712 Assert(i < multirange->rangeCount);
713
714 offset = multirange_get_bounds_offset(multirange, i);
715 flags = MultirangeGetFlagsPtr(multirange)[i];
716 begin = ptr = MultirangeGetBoundariesPtr(multirange, typalign) + offset;
717
718 /*
719 * Calculate the size of bound values. In principle, we could get offset
720 * of the next range bound values and calculate accordingly. But range
721 * bound values are aligned, so we have to walk the values to get the
722 * exact size.
723 */
724 if (RANGE_HAS_LBOUND(flags))
725 ptr = (char *) att_addlength_pointer(ptr, typlen, ptr);
726 if (RANGE_HAS_UBOUND(flags))
727 {
728 ptr = (char *) att_align_pointer(ptr, typalign, typlen, ptr);
729 ptr = (char *) att_addlength_pointer(ptr, typlen, ptr);
730 }
731 len = (ptr - begin) + sizeof(RangeType) + sizeof(uint8);
732
733 range = palloc0(len);
734 SET_VARSIZE(range, len);
735 range->rangetypid = rangetyp->type_id;
736
737 memcpy(range + 1, begin, ptr - begin);
738 *((uint8 *) (range + 1) + (ptr - begin)) = flags;
739
740 return range;
741}
742
743/*
744 * Fetch bounds from the i'th range of the multirange. This is the shortcut for
745 * doing the same thing as multirange_get_range() + range_deserialize(), but
746 * performing fewer operations.
747 */
748void
749multirange_get_bounds(TypeCacheEntry *rangetyp,
750 const MultirangeType *multirange,
751 uint32 i, RangeBound *lower, RangeBound *upper)
752{
753 uint32 offset;
754 uint8 flags;
755 const char *ptr;
756 int16 typlen = rangetyp->rngelemtype->typlen;
757 char typalign = rangetyp->rngelemtype->typalign;
758 bool typbyval = rangetyp->rngelemtype->typbyval;
759 Datum lbound;
760 Datum ubound;
761
762 Assert(i < multirange->rangeCount);
763
764 offset = multirange_get_bounds_offset(multirange, i);
765 flags = MultirangeGetFlagsPtr(multirange)[i];
766 ptr = MultirangeGetBoundariesPtr(multirange, typalign) + offset;
767
768 /* multirange can't contain empty ranges */
769 Assert((flags & RANGE_EMPTY) == 0);
770
771 /* fetch lower bound, if any */
772 if (RANGE_HAS_LBOUND(flags))
773 {
774 /* att_align_pointer cannot be necessary here */
775 lbound = fetch_att(ptr, typbyval, typlen);
776 ptr = (char *) att_addlength_pointer(ptr, typlen, ptr);
777 }
778 else
779 lbound = (Datum) 0;
780
781 /* fetch upper bound, if any */
782 if (RANGE_HAS_UBOUND(flags))
783 {
784 ptr = (char *) att_align_pointer(ptr, typalign, typlen, ptr);
785 ubound = fetch_att(ptr, typbyval, typlen);
786 /* no need for att_addlength_pointer */
787 }
788 else
789 ubound = (Datum) 0;
790
791 /* emit results */
792 lower->val = lbound;
793 lower->infinite = (flags & RANGE_LB_INF) != 0;
794 lower->inclusive = (flags & RANGE_LB_INC) != 0;
795 lower->lower = true;
796
797 upper->val = ubound;
798 upper->infinite = (flags & RANGE_UB_INF) != 0;
799 upper->inclusive = (flags & RANGE_UB_INC) != 0;
800 upper->lower = false;
801}
802
803/*
804 * Construct union range from the multirange.
805 */
806RangeType *
807multirange_get_union_range(TypeCacheEntry *rangetyp,
808 const MultirangeType *mr)
809{
810 RangeBound lower,
811 upper,
812 tmp;
813
814 if (MultirangeIsEmpty(mr))
815 return make_empty_range(rangetyp);
816
817 multirange_get_bounds(rangetyp, mr, 0, &lower, &tmp);
818 multirange_get_bounds(rangetyp, mr, mr->rangeCount - 1, &tmp, &upper);
819
820 return make_range(rangetyp, &lower, &upper, false, NULL);
821}
822
823
824/*
825 * multirange_deserialize: deconstruct a multirange value
826 *
827 * NB: the given multirange object must be fully detoasted; it cannot have a
828 * short varlena header.
829 */
830void
831multirange_deserialize(TypeCacheEntry *rangetyp,
832 const MultirangeType *multirange, int32 *range_count,
833 RangeType ***ranges)
834{
835 *range_count = multirange->rangeCount;
836
837 /* Convert each ShortRangeType into a RangeType */
838 if (*range_count > 0)
839 {
840 int i;
841
842 *ranges = palloc_array(RangeType *, *range_count);
843 for (i = 0; i < *range_count; i++)
844 (*ranges)[i] = multirange_get_range(rangetyp, multirange, i);
845 }
846 else
847 {
848 *ranges = NULL;
849 }
850}
851
852MultirangeType *
853make_empty_multirange(Oid mltrngtypoid, TypeCacheEntry *rangetyp)
854{
855 return make_multirange(mltrngtypoid, rangetyp, 0, NULL);
856}
857
858/*
859 * Similar to range_overlaps_internal(), but takes range bounds instead of
860 * ranges as arguments.
861 */
862static bool
863range_bounds_overlaps(TypeCacheEntry *typcache,
864 RangeBound *lower1, RangeBound *upper1,
865 RangeBound *lower2, RangeBound *upper2)
866{
867 if (range_cmp_bounds(typcache, lower1, lower2) >= 0 &&
868 range_cmp_bounds(typcache, lower1, upper2) <= 0)
869 return true;
870
871 if (range_cmp_bounds(typcache, lower2, lower1) >= 0 &&
872 range_cmp_bounds(typcache, lower2, upper1) <= 0)
873 return true;
874
875 return false;
876}
877
878/*
879 * Similar to range_contains_internal(), but takes range bounds instead of
880 * ranges as arguments.
881 */
882static bool
883range_bounds_contains(TypeCacheEntry *typcache,
884 RangeBound *lower1, RangeBound *upper1,
885 RangeBound *lower2, RangeBound *upper2)
886{
887 if (range_cmp_bounds(typcache, lower1, lower2) <= 0 &&
888 range_cmp_bounds(typcache, upper1, upper2) >= 0)
889 return true;
890
891 return false;
892}
893
894/*
895 * Check if the given key matches any range in multirange using binary search.
896 * If the required range isn't found, that counts as a mismatch. When the
897 * required range is found, the comparison function can still report this as
898 * either match or mismatch. For instance, if we search for containment, we can
899 * found a range, which is overlapping but not containing the key range, and
900 * that would count as a mismatch.
901 */
902static bool
903multirange_bsearch_match(TypeCacheEntry *typcache, const MultirangeType *mr,
904 void *key, multirange_bsearch_comparison cmp_func)
905{
906 uint32 l,
907 u,
908 idx;
909 int comparison;
910 bool match = false;
911
912 l = 0;
913 u = mr->rangeCount;
914 while (l < u)
915 {
916 RangeBound lower,
917 upper;
918
919 idx = (l + u) / 2;
920 multirange_get_bounds(typcache, mr, idx, &lower, &upper);
921 comparison = (*cmp_func) (typcache, &lower, &upper, key, &match);
922
923 if (comparison < 0)
924 u = idx;
925 else if (comparison > 0)
926 l = idx + 1;
927 else
928 return match;
929 }
930
931 return false;
932}
933
934/*
935 *----------------------------------------------------------
936 * GENERIC FUNCTIONS
937 *----------------------------------------------------------
938 */
939
940/*
941 * Construct multirange value from zero or more ranges. Since this is a
942 * variadic function we get passed an array. The array must contain ranges
943 * that match our return value, and there must be no NULLs.
944 */
945Datum
946multirange_constructor2(PG_FUNCTION_ARGS)
947{
948 Oid mltrngtypid = get_fn_expr_rettype(fcinfo->flinfo);
949 Oid rngtypid;
950 TypeCacheEntry *typcache;
951 TypeCacheEntry *rangetyp;
952 ArrayType *rangeArray;
953 int range_count;
954 Datum *elements;
955 bool *nulls;
956 RangeType **ranges;
957 int dims;
958 int i;
959
960 typcache = multirange_get_typcache(fcinfo, mltrngtypid);
961 rangetyp = typcache->rngtype;
962
963 /*
964 * A no-arg invocation should call multirange_constructor0 instead, but
965 * returning an empty range is what that does.
966 */
967
968 if (PG_NARGS() == 0)
969 PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, 0, NULL));
970
971 /*
972 * This check should be guaranteed by our signature, but let's do it just
973 * in case.
974 */
975
976 if (PG_ARGISNULL(0))
977 elog(ERROR,
978 "multirange values cannot contain null members");
979
980 rangeArray = PG_GETARG_ARRAYTYPE_P(0);
981
982 dims = ARR_NDIM(rangeArray);
983 if (dims > 1)
984 ereport(ERROR,
985 (errcode(ERRCODE_CARDINALITY_VIOLATION),
986 errmsg("multiranges cannot be constructed from multidimensional arrays")));
987
988 rngtypid = ARR_ELEMTYPE(rangeArray);
989 if (rngtypid != rangetyp->type_id)
990 elog(ERROR, "type %u does not match constructor type", rngtypid);
991
992 /*
993 * Be careful: we can still be called with zero ranges, like this:
994 * `int4multirange(variadic '{}'::int4range[])
995 */
996 if (dims == 0)
997 {
998 range_count = 0;
999 ranges = NULL;
1000 }
1001 else
1002 {
1003 deconstruct_array(rangeArray, rngtypid, rangetyp->typlen, rangetyp->typbyval,
1004 rangetyp->typalign, &elements, &nulls, &range_count);
1005
1006 ranges = palloc0(range_count * sizeof(RangeType *));
1007 for (i = 0; i < range_count; i++)
1008 {
1009 if (nulls[i])
1010 ereport(ERROR,
1011 (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
1012 errmsg("multirange values cannot contain null members")));
1013
1014 /* make_multirange will do its own copy */
1015 ranges[i] = DatumGetRangeTypeP(elements[i]);
1016 }
1017 }
1018
1019 PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, range_count, ranges));
1020}
1021
1022/*
1023 * Construct multirange value from a single range. It'd be nice if we could
1024 * just use multirange_constructor2 for this case, but we need a non-variadic
1025 * single-arg function to let us define a CAST from a range to its multirange.
1026 */
1027Datum
1028multirange_constructor1(PG_FUNCTION_ARGS)
1029{
1030 Oid mltrngtypid = get_fn_expr_rettype(fcinfo->flinfo);
1031 Oid rngtypid;
1032 TypeCacheEntry *typcache;
1033 TypeCacheEntry *rangetyp;
1034 RangeType *range;
1035
1036 typcache = multirange_get_typcache(fcinfo, mltrngtypid);
1037 rangetyp = typcache->rngtype;
1038
1039 /*
1040 * This check should be guaranteed by our signature, but let's do it just
1041 * in case.
1042 */
1043
1044 if (PG_ARGISNULL(0))
1045 elog(ERROR,
1046 "multirange values cannot contain null members");
1047
1048 range = PG_GETARG_RANGE_P(0);
1049
1050 /* Make sure the range type matches. */
1051 rngtypid = RangeTypeGetOid(range);
1052 if (rngtypid != rangetyp->type_id)
1053 elog(ERROR, "type %u does not match constructor type", rngtypid);
1054
1055 PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, 1, &range));
1056}
1057
1058/*
1059 * Constructor just like multirange_constructor1, but opr_sanity gets angry
1060 * if the same internal function handles multiple functions with different arg
1061 * counts.
1062 */
1063Datum
1064multirange_constructor0(PG_FUNCTION_ARGS)
1065{
1066 Oid mltrngtypid;
1067 TypeCacheEntry *typcache;
1068 TypeCacheEntry *rangetyp;
1069
1070 /* This should always be called without arguments */
1071 if (PG_NARGS() != 0)
1072 elog(ERROR,
1073 "niladic multirange constructor must not receive arguments");
1074
1075 mltrngtypid = get_fn_expr_rettype(fcinfo->flinfo);
1076 typcache = multirange_get_typcache(fcinfo, mltrngtypid);
1077 rangetyp = typcache->rngtype;
1078
1079 PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, 0, NULL));
1080}
1081
1082
1083/* multirange, multirange -> multirange type functions */
1084
1085/* multirange union */
1086Datum
1087multirange_union(PG_FUNCTION_ARGS)
1088{
1089 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
1090 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
1091 TypeCacheEntry *typcache;
1092 int32 range_count1;
1093 int32 range_count2;
1094 int32 range_count3;
1095 RangeType **ranges1;
1096 RangeType **ranges2;
1097 RangeType **ranges3;
1098
1099 if (MultirangeIsEmpty(mr1))
1100 PG_RETURN_MULTIRANGE_P(mr2);
1101 if (MultirangeIsEmpty(mr2))
1102 PG_RETURN_MULTIRANGE_P(mr1);
1103
1104 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
1105
1106 multirange_deserialize(typcache->rngtype, mr1, &range_count1, &ranges1);
1107 multirange_deserialize(typcache->rngtype, mr2, &range_count2, &ranges2);
1108
1109 range_count3 = range_count1 + range_count2;
1110 ranges3 = palloc0(range_count3 * sizeof(RangeType *));
1111 memcpy(ranges3, ranges1, range_count1 * sizeof(RangeType *));
1112 memcpy(ranges3 + range_count1, ranges2, range_count2 * sizeof(RangeType *));
1113 PG_RETURN_MULTIRANGE_P(make_multirange(typcache->type_id, typcache->rngtype,
1114 range_count3, ranges3));
1115}
1116
1117/* multirange minus */
1118Datum
1119multirange_minus(PG_FUNCTION_ARGS)
1120{
1121 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
1122 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
1123 Oid mltrngtypoid = MultirangeTypeGetOid(mr1);
1124 TypeCacheEntry *typcache;
1125 TypeCacheEntry *rangetyp;
1126 int32 range_count1;
1127 int32 range_count2;
1128 RangeType **ranges1;
1129 RangeType **ranges2;
1130
1131 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
1132 rangetyp = typcache->rngtype;
1133
1134 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
1135 PG_RETURN_MULTIRANGE_P(mr1);
1136
1137 multirange_deserialize(typcache->rngtype, mr1, &range_count1, &ranges1);
1138 multirange_deserialize(typcache->rngtype, mr2, &range_count2, &ranges2);
1139
1140 PG_RETURN_MULTIRANGE_P(multirange_minus_internal(mltrngtypoid,
1141 rangetyp,
1142 range_count1,
1143 ranges1,
1144 range_count2,
1145 ranges2));
1146}
1147
1148MultirangeType *
1149multirange_minus_internal(Oid mltrngtypoid, TypeCacheEntry *rangetyp,
1150 int32 range_count1, RangeType **ranges1,
1151 int32 range_count2, RangeType **ranges2)
1152{
1153 RangeType *r1;
1154 RangeType *r2;
1155 RangeType **ranges3;
1156 int32 range_count3;
1157 int32 i1;
1158 int32 i2;
1159
1160 /*
1161 * Worst case: every range in ranges1 makes a different cut to some range
1162 * in ranges2.
1163 */
1164 ranges3 = palloc0((range_count1 + range_count2) * sizeof(RangeType *));
1165 range_count3 = 0;
1166
1167 /*
1168 * For each range in mr1, keep subtracting until it's gone or the ranges
1169 * in mr2 have passed it. After a subtraction we assign what's left back
1170 * to r1. The parallel progress through mr1 and mr2 is similar to
1171 * multirange_overlaps_multirange_internal.
1172 */
1173 r2 = ranges2[0];
1174 for (i1 = 0, i2 = 0; i1 < range_count1; i1++)
1175 {
1176 r1 = ranges1[i1];
1177
1178 /* Discard r2s while r2 << r1 */
1179 while (r2 != NULL && range_before_internal(rangetyp, r2, r1))
1180 {
1181 r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
1182 }
1183
1184 while (r2 != NULL)
1185 {
1186 if (range_split_internal(rangetyp, r1, r2, &ranges3[range_count3], &r1))
1187 {
1188 /*
1189 * If r2 takes a bite out of the middle of r1, we need two
1190 * outputs
1191 */
1192 range_count3++;
1193 r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
1194 }
1195 else if (range_overlaps_internal(rangetyp, r1, r2))
1196 {
1197 /*
1198 * If r2 overlaps r1, replace r1 with r1 - r2.
1199 */
1200 r1 = range_minus_internal(rangetyp, r1, r2);
1201
1202 /*
1203 * If r2 goes past r1, then we need to stay with it, in case
1204 * it hits future r1s. Otherwise we need to keep r1, in case
1205 * future r2s hit it. Since we already subtracted, there's no
1206 * point in using the overright/overleft calls.
1207 */
1208 if (RangeIsEmpty(r1) || range_before_internal(rangetyp, r1, r2))
1209 break;
1210 else
1211 r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
1212 }
1213 else
1214 {
1215 /*
1216 * This and all future r2s are past r1, so keep them. Also
1217 * assign whatever is left of r1 to the result.
1218 */
1219 break;
1220 }
1221 }
1222
1223 /*
1224 * Nothing else can remove anything from r1, so keep it. Even if r1 is
1225 * empty here, make_multirange will remove it.
1226 */
1227 ranges3[range_count3++] = r1;
1228 }
1229
1230 return make_multirange(mltrngtypoid, rangetyp, range_count3, ranges3);
1231}
1232
1233/*
1234 * multirange_minus_multi - like multirange_minus but returning the result as a
1235 * SRF, with no rows if the result would be empty.
1236 */
1237Datum
1238multirange_minus_multi(PG_FUNCTION_ARGS)
1239{
1240 FuncCallContext *funcctx;
1241 MemoryContext oldcontext;
1242
1243 if (!SRF_IS_FIRSTCALL())
1244 {
1245 /* We never have more than one result */
1246 funcctx = SRF_PERCALL_SETUP();
1247 SRF_RETURN_DONE(funcctx);
1248 }
1249 else
1250 {
1251 MultirangeType *mr1;
1252 MultirangeType *mr2;
1253 Oid mltrngtypoid;
1254 TypeCacheEntry *typcache;
1255 TypeCacheEntry *rangetyp;
1256 int32 range_count1;
1257 int32 range_count2;
1258 RangeType **ranges1;
1259 RangeType **ranges2;
1260 MultirangeType *mr;
1261
1262 funcctx = SRF_FIRSTCALL_INIT();
1263
1264 /*
1265 * switch to memory context appropriate for multiple function calls
1266 */
1267 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
1268
1269 /* get args, detoasting into multi-call memory context */
1270 mr1 = PG_GETARG_MULTIRANGE_P(0);
1271 mr2 = PG_GETARG_MULTIRANGE_P(1);
1272
1273 mltrngtypoid = MultirangeTypeGetOid(mr1);
1274 typcache = lookup_type_cache(mltrngtypoid, TYPECACHE_MULTIRANGE_INFO);
1275 if (typcache->rngtype == NULL)
1276 elog(ERROR, "type %u is not a multirange type", mltrngtypoid);
1277 rangetyp = typcache->rngtype;
1278
1279 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
1280 mr = mr1;
1281 else
1282 {
1283 multirange_deserialize(rangetyp, mr1, &range_count1, &ranges1);
1284 multirange_deserialize(rangetyp, mr2, &range_count2, &ranges2);
1285
1286 mr = multirange_minus_internal(mltrngtypoid,
1287 rangetyp,
1288 range_count1,
1289 ranges1,
1290 range_count2,
1291 ranges2);
1292 }
1293
1294 MemoryContextSwitchTo(oldcontext);
1295
1296 funcctx = SRF_PERCALL_SETUP();
1297 if (MultirangeIsEmpty(mr))
1298 SRF_RETURN_DONE(funcctx);
1299 else
1300 SRF_RETURN_NEXT(funcctx, MultirangeTypePGetDatum(mr));
1301 }
1302}
1303
1304/* multirange intersection */
1305Datum
1306multirange_intersect(PG_FUNCTION_ARGS)
1307{
1308 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
1309 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
1310 Oid mltrngtypoid = MultirangeTypeGetOid(mr1);
1311 TypeCacheEntry *typcache;
1312 TypeCacheEntry *rangetyp;
1313 int32 range_count1;
1314 int32 range_count2;
1315 RangeType **ranges1;
1316 RangeType **ranges2;
1317
1318 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
1319 rangetyp = typcache->rngtype;
1320
1321 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
1322 PG_RETURN_MULTIRANGE_P(make_empty_multirange(mltrngtypoid, rangetyp));
1323
1324 multirange_deserialize(rangetyp, mr1, &range_count1, &ranges1);
1325 multirange_deserialize(rangetyp, mr2, &range_count2, &ranges2);
1326
1327 PG_RETURN_MULTIRANGE_P(multirange_intersect_internal(mltrngtypoid,
1328 rangetyp,
1329 range_count1,
1330 ranges1,
1331 range_count2,
1332 ranges2));
1333}
1334
1335MultirangeType *
1336multirange_intersect_internal(Oid mltrngtypoid, TypeCacheEntry *rangetyp,
1337 int32 range_count1, RangeType **ranges1,
1338 int32 range_count2, RangeType **ranges2)
1339{
1340 RangeType *r1;
1341 RangeType *r2;
1342 RangeType **ranges3;
1343 int32 range_count3;
1344 int32 i1;
1345 int32 i2;
1346
1347 if (range_count1 == 0 || range_count2 == 0)
1348 return make_multirange(mltrngtypoid, rangetyp, 0, NULL);
1349
1350 /*-----------------------------------------------
1351 * Worst case is a stitching pattern like this:
1352 *
1353 * mr1: --- --- --- ---
1354 * mr2: --- --- ---
1355 * mr3: - - - - - -
1356 *
1357 * That seems to be range_count1 + range_count2 - 1,
1358 * but one extra won't hurt.
1359 *-----------------------------------------------
1360 */
1361 ranges3 = palloc0((range_count1 + range_count2) * sizeof(RangeType *));
1362 range_count3 = 0;
1363
1364 /*
1365 * For each range in mr1, keep intersecting until the ranges in mr2 have
1366 * passed it. The parallel progress through mr1 and mr2 is similar to
1367 * multirange_minus_multirange_internal, but we don't have to assign back
1368 * to r1.
1369 */
1370 r2 = ranges2[0];
1371 for (i1 = 0, i2 = 0; i1 < range_count1; i1++)
1372 {
1373 r1 = ranges1[i1];
1374
1375 /* Discard r2s while r2 << r1 */
1376 while (r2 != NULL && range_before_internal(rangetyp, r2, r1))
1377 {
1378 r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
1379 }
1380
1381 while (r2 != NULL)
1382 {
1383 if (range_overlaps_internal(rangetyp, r1, r2))
1384 {
1385 /* Keep the overlapping part */
1386 ranges3[range_count3++] = range_intersect_internal(rangetyp, r1, r2);
1387
1388 /* If we "used up" all of r2, go to the next one... */
1389 if (range_overleft_internal(rangetyp, r2, r1))
1390 r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
1391
1392 /* ...otherwise go to the next r1 */
1393 else
1394 break;
1395 }
1396 else
1397 /* We're past r1, so move to the next one */
1398 break;
1399 }
1400
1401 /* If we're out of r2s, there can be no more intersections */
1402 if (r2 == NULL)
1403 break;
1404 }
1405
1406 return make_multirange(mltrngtypoid, rangetyp, range_count3, ranges3);
1407}
1408
1409/*
1410 * range_agg_transfn: combine adjacent/overlapping ranges.
1411 *
1412 * All we do here is gather the input ranges into an array
1413 * so that the finalfn can sort and combine them.
1414 */
1415Datum
1416range_agg_transfn(PG_FUNCTION_ARGS)
1417{
1418 MemoryContext aggContext;
1419 Oid rngtypoid;
1420 ArrayBuildState *state;
1421
1422 if (!AggCheckCallContext(fcinfo, &aggContext))
1423 elog(ERROR, "range_agg_transfn called in non-aggregate context");
1424
1425 rngtypoid = get_fn_expr_argtype(fcinfo->flinfo, 1);
1426 if (!type_is_range(rngtypoid))
1427 elog(ERROR, "range_agg must be called with a range");
1428
1429 if (PG_ARGISNULL(0))
1430 state = initArrayResult(rngtypoid, aggContext, false);
1431 else
1432 state = (ArrayBuildState *) PG_GETARG_POINTER(0);
1433
1434 /* skip NULLs */
1435 if (!PG_ARGISNULL(1))
1436 accumArrayResult(state, PG_GETARG_DATUM(1), false, rngtypoid, aggContext);
1437
1438 PG_RETURN_POINTER(state);
1439}
1440
1441/*
1442 * range_agg_finalfn: use our internal array to merge touching ranges.
1443 *
1444 * Shared by range_agg_finalfn(anyrange) and
1445 * multirange_agg_finalfn(anymultirange).
1446 */
1447Datum
1448range_agg_finalfn(PG_FUNCTION_ARGS)
1449{
1450 MemoryContext aggContext;
1451 Oid mltrngtypoid;
1452 TypeCacheEntry *typcache;
1453 ArrayBuildState *state;
1454 int32 range_count;
1455 RangeType **ranges;
1456 int i;
1457
1458 if (!AggCheckCallContext(fcinfo, &aggContext))
1459 elog(ERROR, "range_agg_finalfn called in non-aggregate context");
1460
1461 state = PG_ARGISNULL(0) ? NULL : (ArrayBuildState *) PG_GETARG_POINTER(0);
1462 if (state == NULL)
1463 /* This shouldn't be possible, but just in case.... */
1464 PG_RETURN_NULL();
1465
1466 /* Also return NULL if we had zero inputs, like other aggregates */
1467 range_count = state->nelems;
1468 if (range_count == 0)
1469 PG_RETURN_NULL();
1470
1471 mltrngtypoid = get_fn_expr_rettype(fcinfo->flinfo);
1472 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
1473
1474 ranges = palloc0(range_count * sizeof(RangeType *));
1475 for (i = 0; i < range_count; i++)
1476 ranges[i] = DatumGetRangeTypeP(state->dvalues[i]);
1477
1478 PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypoid, typcache->rngtype, range_count, ranges));
1479}
1480
1481/*
1482 * multirange_agg_transfn: combine adjacent/overlapping multiranges.
1483 *
1484 * All we do here is gather the input multiranges' ranges into an array so
1485 * that the finalfn can sort and combine them.
1486 */
1487Datum
1488multirange_agg_transfn(PG_FUNCTION_ARGS)
1489{
1490 MemoryContext aggContext;
1491 Oid mltrngtypoid;
1492 TypeCacheEntry *typcache;
1493 TypeCacheEntry *rngtypcache;
1494 ArrayBuildState *state;
1495
1496 if (!AggCheckCallContext(fcinfo, &aggContext))
1497 elog(ERROR, "multirange_agg_transfn called in non-aggregate context");
1498
1499 mltrngtypoid = get_fn_expr_argtype(fcinfo->flinfo, 1);
1500 if (!type_is_multirange(mltrngtypoid))
1501 elog(ERROR, "range_agg must be called with a multirange");
1502
1503 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
1504 rngtypcache = typcache->rngtype;
1505
1506 if (PG_ARGISNULL(0))
1507 state = initArrayResult(rngtypcache->type_id, aggContext, false);
1508 else
1509 state = (ArrayBuildState *) PG_GETARG_POINTER(0);
1510
1511 /* skip NULLs */
1512 if (!PG_ARGISNULL(1))
1513 {
1514 MultirangeType *current;
1515 int32 range_count;
1516 RangeType **ranges;
1517
1518 current = PG_GETARG_MULTIRANGE_P(1);
1519 multirange_deserialize(rngtypcache, current, &range_count, &ranges);
1520 if (range_count == 0)
1521 {
1522 /*
1523 * Add an empty range so we get an empty result (not a null
1524 * result).
1525 */
1526 accumArrayResult(state,
1527 RangeTypePGetDatum(make_empty_range(rngtypcache)),
1528 false, rngtypcache->type_id, aggContext);
1529 }
1530 else
1531 {
1532 for (int32 i = 0; i < range_count; i++)
1533 accumArrayResult(state, RangeTypePGetDatum(ranges[i]), false, rngtypcache->type_id, aggContext);
1534 }
1535 }
1536
1537 PG_RETURN_POINTER(state);
1538}
1539
1540Datum
1541multirange_intersect_agg_transfn(PG_FUNCTION_ARGS)
1542{
1543 MemoryContext aggContext;
1544 Oid mltrngtypoid;
1545 TypeCacheEntry *typcache;
1546 MultirangeType *result;
1547 MultirangeType *current;
1548 int32 range_count1;
1549 int32 range_count2;
1550 RangeType **ranges1;
1551 RangeType **ranges2;
1552
1553 if (!AggCheckCallContext(fcinfo, &aggContext))
1554 elog(ERROR, "multirange_intersect_agg_transfn called in non-aggregate context");
1555
1556 mltrngtypoid = get_fn_expr_argtype(fcinfo->flinfo, 1);
1557 if (!type_is_multirange(mltrngtypoid))
1558 elog(ERROR, "range_intersect_agg must be called with a multirange");
1559
1560 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
1561
1562 /* strictness ensures these are non-null */
1563 result = PG_GETARG_MULTIRANGE_P(0);
1564 current = PG_GETARG_MULTIRANGE_P(1);
1565
1566 multirange_deserialize(typcache->rngtype, result, &range_count1, &ranges1);
1567 multirange_deserialize(typcache->rngtype, current, &range_count2, &ranges2);
1568
1569 result = multirange_intersect_internal(mltrngtypoid,
1570 typcache->rngtype,
1571 range_count1,
1572 ranges1,
1573 range_count2,
1574 ranges2);
1575 PG_RETURN_MULTIRANGE_P(result);
1576}
1577
1578
1579/* multirange -> element type functions */
1580
1581/* extract lower bound value */
1582Datum
1583multirange_lower(PG_FUNCTION_ARGS)
1584{
1585 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1586 TypeCacheEntry *typcache;
1587 RangeBound lower;
1588 RangeBound upper;
1589
1590 if (MultirangeIsEmpty(mr))
1591 PG_RETURN_NULL();
1592
1593 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1594
1595 multirange_get_bounds(typcache->rngtype, mr, 0,
1596 &lower, &upper);
1597
1598 if (!lower.infinite)
1599 PG_RETURN_DATUM(lower.val);
1600 else
1601 PG_RETURN_NULL();
1602}
1603
1604/* extract upper bound value */
1605Datum
1606multirange_upper(PG_FUNCTION_ARGS)
1607{
1608 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1609 TypeCacheEntry *typcache;
1610 RangeBound lower;
1611 RangeBound upper;
1612
1613 if (MultirangeIsEmpty(mr))
1614 PG_RETURN_NULL();
1615
1616 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1617
1618 multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
1619 &lower, &upper);
1620
1621 if (!upper.infinite)
1622 PG_RETURN_DATUM(upper.val);
1623 else
1624 PG_RETURN_NULL();
1625}
1626
1627
1628/* multirange -> bool functions */
1629
1630/* is multirange empty? */
1631Datum
1632multirange_empty(PG_FUNCTION_ARGS)
1633{
1634 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1635
1636 PG_RETURN_BOOL(MultirangeIsEmpty(mr));
1637}
1638
1639/* is lower bound inclusive? */
1640Datum
1641multirange_lower_inc(PG_FUNCTION_ARGS)
1642{
1643 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1644 TypeCacheEntry *typcache;
1645 RangeBound lower;
1646 RangeBound upper;
1647
1648 if (MultirangeIsEmpty(mr))
1649 PG_RETURN_BOOL(false);
1650
1651 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1652 multirange_get_bounds(typcache->rngtype, mr, 0,
1653 &lower, &upper);
1654
1655 PG_RETURN_BOOL(lower.inclusive);
1656}
1657
1658/* is upper bound inclusive? */
1659Datum
1660multirange_upper_inc(PG_FUNCTION_ARGS)
1661{
1662 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1663 TypeCacheEntry *typcache;
1664 RangeBound lower;
1665 RangeBound upper;
1666
1667 if (MultirangeIsEmpty(mr))
1668 PG_RETURN_BOOL(false);
1669
1670 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1671 multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
1672 &lower, &upper);
1673
1674 PG_RETURN_BOOL(upper.inclusive);
1675}
1676
1677/* is lower bound infinite? */
1678Datum
1679multirange_lower_inf(PG_FUNCTION_ARGS)
1680{
1681 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1682 TypeCacheEntry *typcache;
1683 RangeBound lower;
1684 RangeBound upper;
1685
1686 if (MultirangeIsEmpty(mr))
1687 PG_RETURN_BOOL(false);
1688
1689 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1690 multirange_get_bounds(typcache->rngtype, mr, 0,
1691 &lower, &upper);
1692
1693 PG_RETURN_BOOL(lower.infinite);
1694}
1695
1696/* is upper bound infinite? */
1697Datum
1698multirange_upper_inf(PG_FUNCTION_ARGS)
1699{
1700 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1701 TypeCacheEntry *typcache;
1702 RangeBound lower;
1703 RangeBound upper;
1704
1705 if (MultirangeIsEmpty(mr))
1706 PG_RETURN_BOOL(false);
1707
1708 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1709 multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
1710 &lower, &upper);
1711
1712 PG_RETURN_BOOL(upper.infinite);
1713}
1714
1715
1716
1717/* multirange, element -> bool functions */
1718
1719/* contains? */
1720Datum
1721multirange_contains_elem(PG_FUNCTION_ARGS)
1722{
1723 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1724 Datum val = PG_GETARG_DATUM(1);
1725 TypeCacheEntry *typcache;
1726
1727 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1728
1729 PG_RETURN_BOOL(multirange_contains_elem_internal(typcache->rngtype, mr, val));
1730}
1731
1732/* contained by? */
1733Datum
1734elem_contained_by_multirange(PG_FUNCTION_ARGS)
1735{
1736 Datum val = PG_GETARG_DATUM(0);
1737 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
1738 TypeCacheEntry *typcache;
1739
1740 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1741
1742 PG_RETURN_BOOL(multirange_contains_elem_internal(typcache->rngtype, mr, val));
1743}
1744
1745/*
1746 * Comparison function for checking if any range of multirange contains given
1747 * key element using binary search.
1748 */
1749static int
1750multirange_elem_bsearch_comparison(TypeCacheEntry *typcache,
1751 RangeBound *lower, RangeBound *upper,
1752 void *key, bool *match)
1753{
1754 Datum val = *((Datum *) key);
1755 int cmp;
1756
1757 if (!lower->infinite)
1758 {
1759 cmp = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
1760 typcache->rng_collation,
1761 lower->val, val));
1762 if (cmp > 0 || (cmp == 0 && !lower->inclusive))
1763 return -1;
1764 }
1765
1766 if (!upper->infinite)
1767 {
1768 cmp = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
1769 typcache->rng_collation,
1770 upper->val, val));
1771 if (cmp < 0 || (cmp == 0 && !upper->inclusive))
1772 return 1;
1773 }
1774
1775 *match = true;
1776 return 0;
1777}
1778
1779/*
1780 * Test whether multirange mr contains a specific element value.
1781 */
1782bool
1783multirange_contains_elem_internal(TypeCacheEntry *rangetyp,
1784 const MultirangeType *mr, Datum val)
1785{
1786 if (MultirangeIsEmpty(mr))
1787 return false;
1788
1789 return multirange_bsearch_match(rangetyp, mr, &val,
1790 multirange_elem_bsearch_comparison);
1791}
1792
1793/* multirange, range -> bool functions */
1794
1795/* contains? */
1796Datum
1797multirange_contains_range(PG_FUNCTION_ARGS)
1798{
1799 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1800 RangeType *r = PG_GETARG_RANGE_P(1);
1801 TypeCacheEntry *typcache;
1802
1803 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1804
1805 PG_RETURN_BOOL(multirange_contains_range_internal(typcache->rngtype, mr, r));
1806}
1807
1808Datum
1809range_contains_multirange(PG_FUNCTION_ARGS)
1810{
1811 RangeType *r = PG_GETARG_RANGE_P(0);
1812 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
1813 TypeCacheEntry *typcache;
1814
1815 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1816
1817 PG_RETURN_BOOL(range_contains_multirange_internal(typcache->rngtype, r, mr));
1818}
1819
1820/* contained by? */
1821Datum
1822range_contained_by_multirange(PG_FUNCTION_ARGS)
1823{
1824 RangeType *r = PG_GETARG_RANGE_P(0);
1825 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
1826 TypeCacheEntry *typcache;
1827
1828 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1829
1830 PG_RETURN_BOOL(multirange_contains_range_internal(typcache->rngtype, mr, r));
1831}
1832
1833Datum
1834multirange_contained_by_range(PG_FUNCTION_ARGS)
1835{
1836 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1837 RangeType *r = PG_GETARG_RANGE_P(1);
1838 TypeCacheEntry *typcache;
1839
1840 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1841
1842 PG_RETURN_BOOL(range_contains_multirange_internal(typcache->rngtype, r, mr));
1843}
1844
1845/*
1846 * Comparison function for checking if any range of multirange contains given
1847 * key range using binary search.
1848 */
1849static int
1850multirange_range_contains_bsearch_comparison(TypeCacheEntry *typcache,
1851 RangeBound *lower, RangeBound *upper,
1852 void *key, bool *match)
1853{
1854 RangeBound *keyLower = (RangeBound *) key;
1855 RangeBound *keyUpper = (RangeBound *) key + 1;
1856
1857 /* Check if key range is strictly in the left or in the right */
1858 if (range_cmp_bounds(typcache, keyUpper, lower) < 0)
1859 return -1;
1860 if (range_cmp_bounds(typcache, keyLower, upper) > 0)
1861 return 1;
1862
1863 /*
1864 * At this point we found overlapping range. But we have to check if it
1865 * really contains the key range. Anyway, we have to stop our search
1866 * here, because multirange contains only non-overlapping ranges.
1867 */
1868 *match = range_bounds_contains(typcache, lower, upper, keyLower, keyUpper);
1869
1870 return 0;
1871}
1872
1873/*
1874 * Test whether multirange mr contains a specific range r.
1875 */
1876bool
1877multirange_contains_range_internal(TypeCacheEntry *rangetyp,
1878 const MultirangeType *mr,
1879 const RangeType *r)
1880{
1881 RangeBound bounds[2];
1882 bool empty;
1883
1884 /*
1885 * Every multirange contains an infinite number of empty ranges, even an
1886 * empty one.
1887 */
1888 if (RangeIsEmpty(r))
1889 return true;
1890
1891 if (MultirangeIsEmpty(mr))
1892 return false;
1893
1894 range_deserialize(rangetyp, r, &bounds[0], &bounds[1], &empty);
1895 Assert(!empty);
1896
1897 return multirange_bsearch_match(rangetyp, mr, bounds,
1898 multirange_range_contains_bsearch_comparison);
1899}
1900
1901/*
1902 * Test whether range r contains a multirange mr.
1903 */
1904bool
1905range_contains_multirange_internal(TypeCacheEntry *rangetyp,
1906 const RangeType *r,
1907 const MultirangeType *mr)
1908{
1909 RangeBound lower1,
1910 upper1,
1911 lower2,
1912 upper2,
1913 tmp;
1914 bool empty;
1915
1916 /*
1917 * Every range contains an infinite number of empty multiranges, even an
1918 * empty one.
1919 */
1920 if (MultirangeIsEmpty(mr))
1921 return true;
1922
1923 if (RangeIsEmpty(r))
1924 return false;
1925
1926 /* Range contains multirange iff it contains its union range. */
1927 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
1928 Assert(!empty);
1929 multirange_get_bounds(rangetyp, mr, 0, &lower2, &tmp);
1930 multirange_get_bounds(rangetyp, mr, mr->rangeCount - 1, &tmp, &upper2);
1931
1932 return range_bounds_contains(rangetyp, &lower1, &upper1, &lower2, &upper2);
1933}
1934
1935
1936/* multirange, multirange -> bool functions */
1937
1938/* equality (internal version) */
1939bool
1940multirange_eq_internal(TypeCacheEntry *rangetyp,
1941 const MultirangeType *mr1,
1942 const MultirangeType *mr2)
1943{
1944 int32 range_count_1;
1945 int32 range_count_2;
1946 int32 i;
1947 RangeBound lower1,
1948 upper1,
1949 lower2,
1950 upper2;
1951
1952 /* Different types should be prevented by ANYMULTIRANGE matching rules */
1953 if (MultirangeTypeGetOid(mr1) != MultirangeTypeGetOid(mr2))
1954 elog(ERROR, "multirange types do not match");
1955
1956 range_count_1 = mr1->rangeCount;
1957 range_count_2 = mr2->rangeCount;
1958
1959 if (range_count_1 != range_count_2)
1960 return false;
1961
1962 for (i = 0; i < range_count_1; i++)
1963 {
1964 multirange_get_bounds(rangetyp, mr1, i, &lower1, &upper1);
1965 multirange_get_bounds(rangetyp, mr2, i, &lower2, &upper2);
1966
1967 if (range_cmp_bounds(rangetyp, &lower1, &lower2) != 0 ||
1968 range_cmp_bounds(rangetyp, &upper1, &upper2) != 0)
1969 return false;
1970 }
1971
1972 return true;
1973}
1974
1975/* equality */
1976Datum
1977multirange_eq(PG_FUNCTION_ARGS)
1978{
1979 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
1980 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
1981 TypeCacheEntry *typcache;
1982
1983 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
1984
1985 PG_RETURN_BOOL(multirange_eq_internal(typcache->rngtype, mr1, mr2));
1986}
1987
1988/* inequality (internal version) */
1989bool
1990multirange_ne_internal(TypeCacheEntry *rangetyp,
1991 const MultirangeType *mr1,
1992 const MultirangeType *mr2)
1993{
1994 return (!multirange_eq_internal(rangetyp, mr1, mr2));
1995}
1996
1997/* inequality */
1998Datum
1999multirange_ne(PG_FUNCTION_ARGS)
2000{
2001 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2002 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2003 TypeCacheEntry *typcache;
2004
2005 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2006
2007 PG_RETURN_BOOL(multirange_ne_internal(typcache->rngtype, mr1, mr2));
2008}
2009
2010/* overlaps? */
2011Datum
2012range_overlaps_multirange(PG_FUNCTION_ARGS)
2013{
2014 RangeType *r = PG_GETARG_RANGE_P(0);
2015 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2016 TypeCacheEntry *typcache;
2017
2018 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2019
2020 PG_RETURN_BOOL(range_overlaps_multirange_internal(typcache->rngtype, r, mr));
2021}
2022
2023Datum
2024multirange_overlaps_range(PG_FUNCTION_ARGS)
2025{
2026 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2027 RangeType *r = PG_GETARG_RANGE_P(1);
2028 TypeCacheEntry *typcache;
2029
2030 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2031
2032 PG_RETURN_BOOL(range_overlaps_multirange_internal(typcache->rngtype, r, mr));
2033}
2034
2035Datum
2036multirange_overlaps_multirange(PG_FUNCTION_ARGS)
2037{
2038 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2039 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2040 TypeCacheEntry *typcache;
2041
2042 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2043
2044 PG_RETURN_BOOL(multirange_overlaps_multirange_internal(typcache->rngtype, mr1, mr2));
2045}
2046
2047/*
2048 * Comparison function for checking if any range of multirange overlaps given
2049 * key range using binary search.
2050 */
2051static int
2052multirange_range_overlaps_bsearch_comparison(TypeCacheEntry *typcache,
2053 RangeBound *lower, RangeBound *upper,
2054 void *key, bool *match)
2055{
2056 RangeBound *keyLower = (RangeBound *) key;
2057 RangeBound *keyUpper = (RangeBound *) key + 1;
2058
2059 if (range_cmp_bounds(typcache, keyUpper, lower) < 0)
2060 return -1;
2061 if (range_cmp_bounds(typcache, keyLower, upper) > 0)
2062 return 1;
2063
2064 *match = true;
2065 return 0;
2066}
2067
2068bool
2069range_overlaps_multirange_internal(TypeCacheEntry *rangetyp,
2070 const RangeType *r,
2071 const MultirangeType *mr)
2072{
2073 RangeBound bounds[2];
2074 bool empty;
2075
2076 /*
2077 * Empties never overlap, even with empties. (This seems strange since
2078 * they *do* contain each other, but we want to follow how ranges work.)
2079 */
2080 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2081 return false;
2082
2083 range_deserialize(rangetyp, r, &bounds[0], &bounds[1], &empty);
2084 Assert(!empty);
2085
2086 return multirange_bsearch_match(rangetyp, mr, bounds,
2087 multirange_range_overlaps_bsearch_comparison);
2088}
2089
2090bool
2091multirange_overlaps_multirange_internal(TypeCacheEntry *rangetyp,
2092 const MultirangeType *mr1,
2093 const MultirangeType *mr2)
2094{
2095 int32 range_count1;
2096 int32 range_count2;
2097 int32 i1;
2098 int32 i2;
2099 RangeBound lower1,
2100 upper1,
2101 lower2,
2102 upper2;
2103
2104 /*
2105 * Empties never overlap, even with empties. (This seems strange since
2106 * they *do* contain each other, but we want to follow how ranges work.)
2107 */
2108 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
2109 return false;
2110
2111 range_count1 = mr1->rangeCount;
2112 range_count2 = mr2->rangeCount;
2113
2114 /*
2115 * Every range in mr1 gets a chance to overlap with the ranges in mr2, but
2116 * we can use their ordering to avoid O(n^2). This is similar to
2117 * range_overlaps_multirange where r1 : r2 :: mrr : r, but there if we
2118 * don't find an overlap with r we're done, and here if we don't find an
2119 * overlap with r2 we try the next r2.
2120 */
2121 i1 = 0;
2122 multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
2123 for (i1 = 0, i2 = 0; i2 < range_count2; i2++)
2124 {
2125 multirange_get_bounds(rangetyp, mr2, i2, &lower2, &upper2);
2126
2127 /* Discard r1s while r1 << r2 */
2128 while (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0)
2129 {
2130 if (++i1 >= range_count1)
2131 return false;
2132 multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
2133 }
2134
2135 /*
2136 * If r1 && r2, we're done, otherwise we failed to find an overlap for
2137 * r2, so go to the next one.
2138 */
2139 if (range_bounds_overlaps(rangetyp, &lower1, &upper1, &lower2, &upper2))
2140 return true;
2141 }
2142
2143 /* We looked through all of mr2 without finding an overlap */
2144 return false;
2145}
2146
2147/* does not extend to right of? */
2148bool
2149range_overleft_multirange_internal(TypeCacheEntry *rangetyp,
2150 const RangeType *r,
2151 const MultirangeType *mr)
2152{
2153 RangeBound lower1,
2154 upper1,
2155 lower2,
2156 upper2;
2157 bool empty;
2158
2159 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2160 return false;
2161
2162 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
2163 Assert(!empty);
2164 multirange_get_bounds(rangetyp, mr, mr->rangeCount - 1,
2165 &lower2, &upper2);
2166
2167 return (range_cmp_bounds(rangetyp, &upper1, &upper2) <= 0);
2168}
2169
2170Datum
2171range_overleft_multirange(PG_FUNCTION_ARGS)
2172{
2173 RangeType *r = PG_GETARG_RANGE_P(0);
2174 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2175 TypeCacheEntry *typcache;
2176
2177 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2178
2179 PG_RETURN_BOOL(range_overleft_multirange_internal(typcache->rngtype, r, mr));
2180}
2181
2182Datum
2183multirange_overleft_range(PG_FUNCTION_ARGS)
2184{
2185 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2186 RangeType *r = PG_GETARG_RANGE_P(1);
2187 TypeCacheEntry *typcache;
2188 RangeBound lower1,
2189 upper1,
2190 lower2,
2191 upper2;
2192 bool empty;
2193
2194 if (MultirangeIsEmpty(mr) || RangeIsEmpty(r))
2195 PG_RETURN_BOOL(false);
2196
2197 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2198
2199 multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
2200 &lower1, &upper1);
2201 range_deserialize(typcache->rngtype, r, &lower2, &upper2, &empty);
2202 Assert(!empty);
2203
2204 PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &upper1, &upper2) <= 0);
2205}
2206
2207Datum
2208multirange_overleft_multirange(PG_FUNCTION_ARGS)
2209{
2210 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2211 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2212 TypeCacheEntry *typcache;
2213 RangeBound lower1,
2214 upper1,
2215 lower2,
2216 upper2;
2217
2218 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
2219 PG_RETURN_BOOL(false);
2220
2221 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2222
2223 multirange_get_bounds(typcache->rngtype, mr1, mr1->rangeCount - 1,
2224 &lower1, &upper1);
2225 multirange_get_bounds(typcache->rngtype, mr2, mr2->rangeCount - 1,
2226 &lower2, &upper2);
2227
2228 PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &upper1, &upper2) <= 0);
2229}
2230
2231/* does not extend to left of? */
2232bool
2233range_overright_multirange_internal(TypeCacheEntry *rangetyp,
2234 const RangeType *r,
2235 const MultirangeType *mr)
2236{
2237 RangeBound lower1,
2238 upper1,
2239 lower2,
2240 upper2;
2241 bool empty;
2242
2243 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2244 return false;
2245
2246 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
2247 Assert(!empty);
2248 multirange_get_bounds(rangetyp, mr, 0, &lower2, &upper2);
2249
2250 return (range_cmp_bounds(rangetyp, &lower1, &lower2) >= 0);
2251}
2252
2253Datum
2254range_overright_multirange(PG_FUNCTION_ARGS)
2255{
2256 RangeType *r = PG_GETARG_RANGE_P(0);
2257 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2258 TypeCacheEntry *typcache;
2259
2260 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2261
2262 PG_RETURN_BOOL(range_overright_multirange_internal(typcache->rngtype, r, mr));
2263}
2264
2265Datum
2266multirange_overright_range(PG_FUNCTION_ARGS)
2267{
2268 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2269 RangeType *r = PG_GETARG_RANGE_P(1);
2270 TypeCacheEntry *typcache;
2271 RangeBound lower1,
2272 upper1,
2273 lower2,
2274 upper2;
2275 bool empty;
2276
2277 if (MultirangeIsEmpty(mr) || RangeIsEmpty(r))
2278 PG_RETURN_BOOL(false);
2279
2280 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2281
2282 multirange_get_bounds(typcache->rngtype, mr, 0, &lower1, &upper1);
2283 range_deserialize(typcache->rngtype, r, &lower2, &upper2, &empty);
2284 Assert(!empty);
2285
2286 PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &lower1, &lower2) >= 0);
2287}
2288
2289Datum
2290multirange_overright_multirange(PG_FUNCTION_ARGS)
2291{
2292 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2293 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2294 TypeCacheEntry *typcache;
2295 RangeBound lower1,
2296 upper1,
2297 lower2,
2298 upper2;
2299
2300 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
2301 PG_RETURN_BOOL(false);
2302
2303 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2304
2305 multirange_get_bounds(typcache->rngtype, mr1, 0, &lower1, &upper1);
2306 multirange_get_bounds(typcache->rngtype, mr2, 0, &lower2, &upper2);
2307
2308 PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &lower1, &lower2) >= 0);
2309}
2310
2311/* contains? */
2312Datum
2313multirange_contains_multirange(PG_FUNCTION_ARGS)
2314{
2315 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2316 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2317 TypeCacheEntry *typcache;
2318
2319 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2320
2321 PG_RETURN_BOOL(multirange_contains_multirange_internal(typcache->rngtype, mr1, mr2));
2322}
2323
2324/* contained by? */
2325Datum
2326multirange_contained_by_multirange(PG_FUNCTION_ARGS)
2327{
2328 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2329 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2330 TypeCacheEntry *typcache;
2331
2332 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2333
2334 PG_RETURN_BOOL(multirange_contains_multirange_internal(typcache->rngtype, mr2, mr1));
2335}
2336
2337/*
2338 * Test whether multirange mr1 contains every range from another multirange mr2.
2339 */
2340bool
2341multirange_contains_multirange_internal(TypeCacheEntry *rangetyp,
2342 const MultirangeType *mr1,
2343 const MultirangeType *mr2)
2344{
2345 int32 range_count1 = mr1->rangeCount;
2346 int32 range_count2 = mr2->rangeCount;
2347 int i1,
2348 i2;
2349 RangeBound lower1,
2350 upper1,
2351 lower2,
2352 upper2;
2353
2354 /*
2355 * We follow the same logic for empties as ranges: - an empty multirange
2356 * contains an empty range/multirange. - an empty multirange can't contain
2357 * any other range/multirange. - an empty multirange is contained by any
2358 * other range/multirange.
2359 */
2360
2361 if (range_count2 == 0)
2362 return true;
2363 if (range_count1 == 0)
2364 return false;
2365
2366 /*
2367 * Every range in mr2 must be contained by some range in mr1. To avoid
2368 * O(n^2) we walk through both ranges in tandem.
2369 */
2370 i1 = 0;
2371 multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
2372 for (i2 = 0; i2 < range_count2; i2++)
2373 {
2374 multirange_get_bounds(rangetyp, mr2, i2, &lower2, &upper2);
2375
2376 /* Discard r1s while r1 << r2 */
2377 while (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0)
2378 {
2379 if (++i1 >= range_count1)
2380 return false;
2381 multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
2382 }
2383
2384 /*
2385 * If r1 @> r2, go to the next r2, otherwise return false (since every
2386 * r1[n] and r1[n+1] must have a gap). Note this will give weird
2387 * answers if you don't canonicalize, e.g. with a custom
2388 * int2multirange {[1,1], [2,2]} there is a "gap". But that is
2389 * consistent with other range operators, e.g. '[1,1]'::int2range -|-
2390 * '[2,2]'::int2range is false.
2391 */
2392 if (!range_bounds_contains(rangetyp, &lower1, &upper1,
2393 &lower2, &upper2))
2394 return false;
2395 }
2396
2397 /* All ranges in mr2 are satisfied */
2398 return true;
2399}
2400
2401/* strictly left of? */
2402Datum
2403range_before_multirange(PG_FUNCTION_ARGS)
2404{
2405 RangeType *r = PG_GETARG_RANGE_P(0);
2406 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2407 TypeCacheEntry *typcache;
2408
2409 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2410
2411 PG_RETURN_BOOL(range_before_multirange_internal(typcache->rngtype, r, mr));
2412}
2413
2414Datum
2415multirange_before_range(PG_FUNCTION_ARGS)
2416{
2417 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2418 RangeType *r = PG_GETARG_RANGE_P(1);
2419 TypeCacheEntry *typcache;
2420
2421 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2422
2423 PG_RETURN_BOOL(range_after_multirange_internal(typcache->rngtype, r, mr));
2424}
2425
2426Datum
2427multirange_before_multirange(PG_FUNCTION_ARGS)
2428{
2429 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2430 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2431 TypeCacheEntry *typcache;
2432
2433 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2434
2435 PG_RETURN_BOOL(multirange_before_multirange_internal(typcache->rngtype, mr1, mr2));
2436}
2437
2438/* strictly right of? */
2439Datum
2440range_after_multirange(PG_FUNCTION_ARGS)
2441{
2442 RangeType *r = PG_GETARG_RANGE_P(0);
2443 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2444 TypeCacheEntry *typcache;
2445
2446 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2447
2448 PG_RETURN_BOOL(range_after_multirange_internal(typcache->rngtype, r, mr));
2449}
2450
2451Datum
2452multirange_after_range(PG_FUNCTION_ARGS)
2453{
2454 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2455 RangeType *r = PG_GETARG_RANGE_P(1);
2456 TypeCacheEntry *typcache;
2457
2458 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2459
2460 PG_RETURN_BOOL(range_before_multirange_internal(typcache->rngtype, r, mr));
2461}
2462
2463Datum
2464multirange_after_multirange(PG_FUNCTION_ARGS)
2465{
2466 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2467 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2468 TypeCacheEntry *typcache;
2469
2470 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2471
2472 PG_RETURN_BOOL(multirange_before_multirange_internal(typcache->rngtype, mr2, mr1));
2473}
2474
2475/* strictly left of? (internal version) */
2476bool
2477range_before_multirange_internal(TypeCacheEntry *rangetyp,
2478 const RangeType *r,
2479 const MultirangeType *mr)
2480{
2481 RangeBound lower1,
2482 upper1,
2483 lower2,
2484 upper2;
2485 bool empty;
2486
2487 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2488 return false;
2489
2490 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
2491 Assert(!empty);
2492
2493 multirange_get_bounds(rangetyp, mr, 0, &lower2, &upper2);
2494
2495 return (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0);
2496}
2497
2498bool
2499multirange_before_multirange_internal(TypeCacheEntry *rangetyp,
2500 const MultirangeType *mr1,
2501 const MultirangeType *mr2)
2502{
2503 RangeBound lower1,
2504 upper1,
2505 lower2,
2506 upper2;
2507
2508 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
2509 return false;
2510
2511 multirange_get_bounds(rangetyp, mr1, mr1->rangeCount - 1,
2512 &lower1, &upper1);
2513 multirange_get_bounds(rangetyp, mr2, 0,
2514 &lower2, &upper2);
2515
2516 return (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0);
2517}
2518
2519/* strictly right of? (internal version) */
2520bool
2521range_after_multirange_internal(TypeCacheEntry *rangetyp,
2522 const RangeType *r,
2523 const MultirangeType *mr)
2524{
2525 RangeBound lower1,
2526 upper1,
2527 lower2,
2528 upper2;
2529 bool empty;
2530 int32 range_count;
2531
2532 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2533 return false;
2534
2535 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
2536 Assert(!empty);
2537
2538 range_count = mr->rangeCount;
2539 multirange_get_bounds(rangetyp, mr, range_count - 1,
2540 &lower2, &upper2);
2541
2542 return (range_cmp_bounds(rangetyp, &lower1, &upper2) > 0);
2543}
2544
2545bool
2546range_adjacent_multirange_internal(TypeCacheEntry *rangetyp,
2547 const RangeType *r,
2548 const MultirangeType *mr)
2549{
2550 RangeBound lower1,
2551 upper1,
2552 lower2,
2553 upper2;
2554 bool empty;
2555 int32 range_count;
2556
2557 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2558 return false;
2559
2560 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
2561 Assert(!empty);
2562
2563 range_count = mr->rangeCount;
2564 multirange_get_bounds(rangetyp, mr, 0,
2565 &lower2, &upper2);
2566
2567 if (bounds_adjacent(rangetyp, upper1, lower2))
2568 return true;
2569
2570 if (range_count > 1)
2571 multirange_get_bounds(rangetyp, mr, range_count - 1,
2572 &lower2, &upper2);
2573
2574 if (bounds_adjacent(rangetyp, upper2, lower1))
2575 return true;
2576
2577 return false;
2578}
2579
2580/* adjacent to? */
2581Datum
2582range_adjacent_multirange(PG_FUNCTION_ARGS)
2583{
2584 RangeType *r = PG_GETARG_RANGE_P(0);
2585 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2586 TypeCacheEntry *typcache;
2587
2588 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2589
2590 PG_RETURN_BOOL(range_adjacent_multirange_internal(typcache->rngtype, r, mr));
2591}
2592
2593Datum
2594multirange_adjacent_range(PG_FUNCTION_ARGS)
2595{
2596 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2597 RangeType *r = PG_GETARG_RANGE_P(1);
2598 TypeCacheEntry *typcache;
2599
2600 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2601 PG_RETURN_BOOL(false);
2602
2603 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2604
2605 PG_RETURN_BOOL(range_adjacent_multirange_internal(typcache->rngtype, r, mr));
2606}
2607
2608Datum
2609multirange_adjacent_multirange(PG_FUNCTION_ARGS)
2610{
2611 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2612 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2613 TypeCacheEntry *typcache;
2614 int32 range_count1;
2615 int32 range_count2;
2616 RangeBound lower1,
2617 upper1,
2618 lower2,
2619 upper2;
2620
2621 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
2622 PG_RETURN_BOOL(false);
2623
2624 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2625
2626 range_count1 = mr1->rangeCount;
2627 range_count2 = mr2->rangeCount;
2628 multirange_get_bounds(typcache->rngtype, mr1, range_count1 - 1,
2629 &lower1, &upper1);
2630 multirange_get_bounds(typcache->rngtype, mr2, 0,
2631 &lower2, &upper2);
2632 if (bounds_adjacent(typcache->rngtype, upper1, lower2))
2633 PG_RETURN_BOOL(true);
2634
2635 if (range_count1 > 1)
2636 multirange_get_bounds(typcache->rngtype, mr1, 0,
2637 &lower1, &upper1);
2638 if (range_count2 > 1)
2639 multirange_get_bounds(typcache->rngtype, mr2, range_count2 - 1,
2640 &lower2, &upper2);
2641 if (bounds_adjacent(typcache->rngtype, upper2, lower1))
2642 PG_RETURN_BOOL(true);
2643 PG_RETURN_BOOL(false);
2644}
2645
2646/* Btree support */
2647
2648/* btree comparator */
2649Datum
2650multirange_cmp(PG_FUNCTION_ARGS)
2651{
2652 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2653 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2654 int32 range_count_1;
2655 int32 range_count_2;
2656 int32 range_count_max;
2657 int32 i;
2658 TypeCacheEntry *typcache;
2659 int cmp = 0; /* If both are empty we'll use this. */
2660
2661 /* Different types should be prevented by ANYMULTIRANGE matching rules */
2662 if (MultirangeTypeGetOid(mr1) != MultirangeTypeGetOid(mr2))
2663 elog(ERROR, "multirange types do not match");
2664
2665 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2666
2667 range_count_1 = mr1->rangeCount;
2668 range_count_2 = mr2->rangeCount;
2669
2670 /* Loop over source data */
2671 range_count_max = Max(range_count_1, range_count_2);
2672 for (i = 0; i < range_count_max; i++)
2673 {
2674 RangeBound lower1,
2675 upper1,
2676 lower2,
2677 upper2;
2678
2679 /*
2680 * If one multirange is shorter, it's as if it had empty ranges at the
2681 * end to extend its length. An empty range compares earlier than any
2682 * other range, so the shorter multirange comes before the longer.
2683 * This is the same behavior as in other types, e.g. in strings 'aaa'
2684 * < 'aaaaaa'.
2685 */
2686 if (i >= range_count_1)
2687 {
2688 cmp = -1;
2689 break;
2690 }
2691 if (i >= range_count_2)
2692 {
2693 cmp = 1;
2694 break;
2695 }
2696
2697 multirange_get_bounds(typcache->rngtype, mr1, i, &lower1, &upper1);
2698 multirange_get_bounds(typcache->rngtype, mr2, i, &lower2, &upper2);
2699
2700 cmp = range_cmp_bounds(typcache->rngtype, &lower1, &lower2);
2701 if (cmp == 0)
2702 cmp = range_cmp_bounds(typcache->rngtype, &upper1, &upper2);
2703 if (cmp != 0)
2704 break;
2705 }
2706
2707 PG_FREE_IF_COPY(mr1, 0);
2708 PG_FREE_IF_COPY(mr2, 1);
2709
2710 PG_RETURN_INT32(cmp);
2711}
2712
2713/* inequality operators using the multirange_cmp function */
2714Datum
2715multirange_lt(PG_FUNCTION_ARGS)
2716{
2717 int cmp = DatumGetInt32(multirange_cmp(fcinfo));
2718
2719 PG_RETURN_BOOL(cmp < 0);
2720}
2721
2722Datum
2723multirange_le(PG_FUNCTION_ARGS)
2724{
2725 int cmp = DatumGetInt32(multirange_cmp(fcinfo));
2726
2727 PG_RETURN_BOOL(cmp <= 0);
2728}
2729
2730Datum
2731multirange_ge(PG_FUNCTION_ARGS)
2732{
2733 int cmp = DatumGetInt32(multirange_cmp(fcinfo));
2734
2735 PG_RETURN_BOOL(cmp >= 0);
2736}
2737
2738Datum
2739multirange_gt(PG_FUNCTION_ARGS)
2740{
2741 int cmp = DatumGetInt32(multirange_cmp(fcinfo));
2742
2743 PG_RETURN_BOOL(cmp > 0);
2744}
2745
2746/* multirange -> range functions */
2747
2748/* Find the smallest range that includes everything in the multirange */
2749Datum
2750range_merge_from_multirange(PG_FUNCTION_ARGS)
2751{
2752 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2753 Oid mltrngtypoid = MultirangeTypeGetOid(mr);
2754 TypeCacheEntry *typcache;
2755 RangeType *result;
2756
2757 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
2758
2759 if (MultirangeIsEmpty(mr))
2760 {
2761 result = make_empty_range(typcache->rngtype);
2762 }
2763 else if (mr->rangeCount == 1)
2764 {
2765 result = multirange_get_range(typcache->rngtype, mr, 0);
2766 }
2767 else
2768 {
2769 RangeBound firstLower,
2770 firstUpper,
2771 lastLower,
2772 lastUpper;
2773
2774 multirange_get_bounds(typcache->rngtype, mr, 0,
2775 &firstLower, &firstUpper);
2776 multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
2777 &lastLower, &lastUpper);
2778
2779 result = make_range(typcache->rngtype, &firstLower, &lastUpper,
2780 false, NULL);
2781 }
2782
2783 PG_RETURN_RANGE_P(result);
2784}
2785
2786/* Turn multirange into a set of ranges */
2787Datum
2788multirange_unnest(PG_FUNCTION_ARGS)
2789{
2790 typedef struct
2791 {
2792 MultirangeType *mr;
2793 TypeCacheEntry *typcache;
2794 int index;
2795 } multirange_unnest_fctx;
2796
2797 FuncCallContext *funcctx;
2798 multirange_unnest_fctx *fctx;
2799 MemoryContext oldcontext;
2800
2801 /* stuff done only on the first call of the function */
2802 if (SRF_IS_FIRSTCALL())
2803 {
2804 MultirangeType *mr;
2805
2806 /* create a function context for cross-call persistence */
2807 funcctx = SRF_FIRSTCALL_INIT();
2808
2809 /*
2810 * switch to memory context appropriate for multiple function calls
2811 */
2812 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
2813
2814 /*
2815 * Get the multirange value and detoast if needed. We can't do this
2816 * earlier because if we have to detoast, we want the detoasted copy
2817 * to be in multi_call_memory_ctx, so it will go away when we're done
2818 * and not before. (If no detoast happens, we assume the originally
2819 * passed multirange will stick around till then.)
2820 */
2821 mr = PG_GETARG_MULTIRANGE_P(0);
2822
2823 /* allocate memory for user context */
2824 fctx = palloc_object(multirange_unnest_fctx);
2825
2826 /* initialize state */
2827 fctx->mr = mr;
2828 fctx->index = 0;
2829 fctx->typcache = lookup_type_cache(MultirangeTypeGetOid(mr),
2830 TYPECACHE_MULTIRANGE_INFO);
2831
2832 funcctx->user_fctx = fctx;
2833 MemoryContextSwitchTo(oldcontext);
2834 }
2835
2836 /* stuff done on every call of the function */
2837 funcctx = SRF_PERCALL_SETUP();
2838 fctx = funcctx->user_fctx;
2839
2840 if (fctx->index < fctx->mr->rangeCount)
2841 {
2842 RangeType *range;
2843
2844 range = multirange_get_range(fctx->typcache->rngtype,
2845 fctx->mr,
2846 fctx->index);
2847 fctx->index++;
2848
2849 SRF_RETURN_NEXT(funcctx, RangeTypePGetDatum(range));
2850 }
2851 else
2852 {
2853 /* do when there is no more left */
2854 SRF_RETURN_DONE(funcctx);
2855 }
2856}
2857
2858/* Hash support */
2859
2860/* hash a multirange value */
2861Datum
2862hash_multirange(PG_FUNCTION_ARGS)
2863{
2864 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2865 uint32 result = 1;
2866 TypeCacheEntry *typcache,
2867 *scache;
2868 int32 range_count,
2869 i;
2870
2871 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2872 scache = typcache->rngtype->rngelemtype;
2873 if (!OidIsValid(scache->hash_proc_finfo.fn_oid))
2874 {
2875 scache = lookup_type_cache(scache->type_id,
2876 TYPECACHE_HASH_PROC_FINFO);
2877 if (!OidIsValid(scache->hash_proc_finfo.fn_oid))
2878 ereport(ERROR,
2879 (errcode(ERRCODE_UNDEFINED_FUNCTION),
2880 errmsg("could not identify a hash function for type %s",
2881 format_type_be(scache->type_id))));
2882 }
2883
2884 range_count = mr->rangeCount;
2885 for (i = 0; i < range_count; i++)
2886 {
2887 RangeBound lower,
2888 upper;
2889 uint8 flags = MultirangeGetFlagsPtr(mr)[i];
2890 uint32 lower_hash;
2891 uint32 upper_hash;
2892 uint32 range_hash;
2893
2894 multirange_get_bounds(typcache->rngtype, mr, i, &lower, &upper);
2895
2896 if (RANGE_HAS_LBOUND(flags))
2897 lower_hash = DatumGetUInt32(FunctionCall1Coll(&scache->hash_proc_finfo,
2898 typcache->rngtype->rng_collation,
2899 lower.val));
2900 else
2901 lower_hash = 0;
2902
2903 if (RANGE_HAS_UBOUND(flags))
2904 upper_hash = DatumGetUInt32(FunctionCall1Coll(&scache->hash_proc_finfo,
2905 typcache->rngtype->rng_collation,
2906 upper.val));
2907 else
2908 upper_hash = 0;
2909
2910 /* Merge hashes of flags and bounds */
2911 range_hash = hash_bytes_uint32((uint32) flags);
2912 range_hash ^= lower_hash;
2913 range_hash = pg_rotate_left32(range_hash, 1);
2914 range_hash ^= upper_hash;
2915
2916 /*
2917 * Use the same approach as hash_array to combine the individual
2918 * elements' hash values:
2919 */
2920 result = (result << 5) - result + range_hash;
2921 }
2922
2923 PG_FREE_IF_COPY(mr, 0);
2924
2925 PG_RETURN_UINT32(result);
2926}
2927
2928/*
2929 * Returns 64-bit value by hashing a value to a 64-bit value, with a seed.
2930 * Otherwise, similar to hash_multirange.
2931 */
2932Datum
2933hash_multirange_extended(PG_FUNCTION_ARGS)
2934{
2935 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2936 Datum seed = PG_GETARG_DATUM(1);
2937 uint64 result = 1;
2938 TypeCacheEntry *typcache,
2939 *scache;
2940 int32 range_count,
2941 i;
2942
2943 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2944 scache = typcache->rngtype->rngelemtype;
2945 if (!OidIsValid(scache->hash_extended_proc_finfo.fn_oid))
2946 {
2947 scache = lookup_type_cache(scache->type_id,
2948 TYPECACHE_HASH_EXTENDED_PROC_FINFO);
2949 if (!OidIsValid(scache->hash_extended_proc_finfo.fn_oid))
2950 ereport(ERROR,
2951 (errcode(ERRCODE_UNDEFINED_FUNCTION),
2952 errmsg("could not identify a hash function for type %s",
2953 format_type_be(scache->type_id))));
2954 }
2955
2956 range_count = mr->rangeCount;
2957 for (i = 0; i < range_count; i++)
2958 {
2959 RangeBound lower,
2960 upper;
2961 uint8 flags = MultirangeGetFlagsPtr(mr)[i];
2962 uint64 lower_hash;
2963 uint64 upper_hash;
2964 uint64 range_hash;
2965
2966 multirange_get_bounds(typcache->rngtype, mr, i, &lower, &upper);
2967
2968 if (RANGE_HAS_LBOUND(flags))
2969 lower_hash = DatumGetUInt64(FunctionCall2Coll(&scache->hash_extended_proc_finfo,
2970 typcache->rngtype->rng_collation,
2971 lower.val,
2972 seed));
2973 else
2974 lower_hash = 0;
2975
2976 if (RANGE_HAS_UBOUND(flags))
2977 upper_hash = DatumGetUInt64(FunctionCall2Coll(&scache->hash_extended_proc_finfo,
2978 typcache->rngtype->rng_collation,
2979 upper.val,
2980 seed));
2981 else
2982 upper_hash = 0;
2983
2984 /* Merge hashes of flags and bounds */
2985 range_hash = DatumGetUInt64(hash_uint32_extended((uint32) flags,
2986 DatumGetInt64(seed)));
2987 range_hash ^= lower_hash;
2988 range_hash = ROTATE_HIGH_AND_LOW_32BITS(range_hash);
2989 range_hash ^= upper_hash;
2990
2991 /*
2992 * Use the same approach as hash_array to combine the individual
2993 * elements' hash values:
2994 */
2995 result = (result << 5) - result + range_hash;
2996 }
2997
2998 PG_FREE_IF_COPY(mr, 0);
2999
3000 PG_RETURN_UINT64(result);
3001}
idx
Datum idx(PG_FUNCTION_ARGS)
Definition _int_op.c:263
ARR_NDIM
#define ARR_NDIM(a)
Definition array.h:290
PG_GETARG_ARRAYTYPE_P
#define PG_GETARG_ARRAYTYPE_P(n)
Definition array.h:263
ARR_ELEMTYPE
#define ARR_ELEMTYPE(a)
Definition array.h:292
accumArrayResult
ArrayBuildState * accumArrayResult(ArrayBuildState *astate, Datum dvalue, bool disnull, Oid element_type, MemoryContext rcontext)
Definition arrayfuncs.c:5365
initArrayResult
ArrayBuildState * initArrayResult(Oid element_type, MemoryContext rcontext, bool subcontext)
Definition arrayfuncs.c:5308
deconstruct_array
void deconstruct_array(const ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)
Definition arrayfuncs.c:3638
Max
#define Max(x, y)
Definition c.h:1085
VARHDRSZ
#define VARHDRSZ
Definition c.h:781
Assert
#define Assert(condition)
Definition c.h:943
int16
int16_t int16
Definition c.h:619
int32
int32_t int32
Definition c.h:620
uint64
uint64_t uint64
Definition c.h:625
OidIsValid
#define OidIsValid(objectId)
Definition c.h:858
Size
size_t Size
Definition c.h:689
result
uint32 result
Definition checksum_block_internal.h:18
memcpy
memcpy(sums, checksumBaseOffsets, sizeof(checksumBaseOffsets))
errcode
int errcode(int sqlerrcode)
Definition elog.c:875
ereturn
#define ereturn(context, dummy_value,...)
Definition elog.h:280
errdetail
int errdetail(const char *fmt,...) pg_attribute_printf(1
ERROR
#define ERROR
Definition elog.h:40
elog
#define elog(elevel,...)
Definition elog.h:228
ereport
#define ereport(elevel,...)
Definition elog.h:152
palloc_object
#define palloc_object(type)
Definition fe_memutils.h:89
palloc_array
#define palloc_array(type, count)
Definition fe_memutils.h:91
FunctionCall2Coll
Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
Definition fmgr.c:1151
fmgr_info_cxt
void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, MemoryContext mcxt)
Definition fmgr.c:139
SendFunctionCall
bytea * SendFunctionCall(FmgrInfo *flinfo, Datum val)
Definition fmgr.c:1745
InputFunctionCallSafe
bool InputFunctionCallSafe(FmgrInfo *flinfo, char *str, Oid typioparam, int32 typmod, Node *escontext, Datum *result)
Definition fmgr.c:1586
OutputFunctionCall
char * OutputFunctionCall(FmgrInfo *flinfo, Datum val)
Definition fmgr.c:1684
get_fn_expr_argtype
Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum)
Definition fmgr.c:1876
FunctionCall1Coll
Datum FunctionCall1Coll(FmgrInfo *flinfo, Oid collation, Datum arg1)
Definition fmgr.c:1131
get_fn_expr_rettype
Oid get_fn_expr_rettype(FmgrInfo *flinfo)
Definition fmgr.c:1854
ReceiveFunctionCall
Datum ReceiveFunctionCall(FmgrInfo *flinfo, StringInfo buf, Oid typioparam, int32 typmod)
Definition fmgr.c:1698
PG_FREE_IF_COPY
#define PG_FREE_IF_COPY(ptr, n)
Definition fmgr.h:260
PG_GETARG_OID
#define PG_GETARG_OID(n)
Definition fmgr.h:275
PG_RETURN_UINT32
#define PG_RETURN_UINT32(x)
Definition fmgr.h:356
PG_RETURN_BYTEA_P
#define PG_RETURN_BYTEA_P(x)
Definition fmgr.h:373
PG_GETARG_POINTER
#define PG_GETARG_POINTER(n)
Definition fmgr.h:277
PG_RETURN_CSTRING
#define PG_RETURN_CSTRING(x)
Definition fmgr.h:364
PG_ARGISNULL
#define PG_ARGISNULL(n)
Definition fmgr.h:209
PG_GETARG_DATUM
#define PG_GETARG_DATUM(n)
Definition fmgr.h:268
PG_NARGS
#define PG_NARGS()
Definition fmgr.h:203
PG_GETARG_CSTRING
#define PG_GETARG_CSTRING(n)
Definition fmgr.h:278
PG_RETURN_NULL
#define PG_RETURN_NULL()
Definition fmgr.h:346
PG_RETURN_UINT64
#define PG_RETURN_UINT64(x)
Definition fmgr.h:371
PG_RETURN_INT32
#define PG_RETURN_INT32(x)
Definition fmgr.h:355
PG_GETARG_INT32
#define PG_GETARG_INT32(n)
Definition fmgr.h:269
PG_RETURN_DATUM
#define PG_RETURN_DATUM(x)
Definition fmgr.h:354
PG_RETURN_POINTER
#define PG_RETURN_POINTER(x)
Definition fmgr.h:363
PG_FUNCTION_ARGS
#define PG_FUNCTION_ARGS
Definition fmgr.h:193
PG_RETURN_BOOL
#define PG_RETURN_BOOL(x)
Definition fmgr.h:360
format_type_be
char * format_type_be(Oid type_oid)
Definition format_type.c:343
SRF_IS_FIRSTCALL
#define SRF_IS_FIRSTCALL()
Definition funcapi.h:304
SRF_PERCALL_SETUP
#define SRF_PERCALL_SETUP()
Definition funcapi.h:308
SRF_RETURN_NEXT
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition funcapi.h:310
SRF_FIRSTCALL_INIT
#define SRF_FIRSTCALL_INIT()
Definition funcapi.h:306
SRF_RETURN_DONE
#define SRF_RETURN_DONE(_funcctx)
Definition funcapi.h:328
hash_bytes_uint32
uint32 hash_bytes_uint32(uint32 k)
Definition hashfn.c:610
ROTATE_HIGH_AND_LOW_32BITS
#define ROTATE_HIGH_AND_LOW_32BITS(v)
Definition hashfn.h:18
hash_uint32_extended
static Datum hash_uint32_extended(uint32 k, uint64 seed)
Definition hashfn.h:49
val
long val
Definition informix.c:689
i
int i
Definition isn.c:77
type_is_range
bool type_is_range(Oid typid)
Definition lsyscache.c:2921
get_type_io_data
void get_type_io_data(Oid typid, IOFuncSelector which_func, int16 *typlen, bool *typbyval, char *typalign, char *typdelim, Oid *typioparam, Oid *func)
Definition lsyscache.c:2556
type_is_multirange
bool type_is_multirange(Oid typid)
Definition lsyscache.c:2931
IOFuncSelector
IOFuncSelector
Definition lsyscache.h:35
IOFunc_output
@ IOFunc_output
Definition lsyscache.h:37
IOFunc_input
@ IOFunc_input
Definition lsyscache.h:36
IOFunc_send
@ IOFunc_send
Definition lsyscache.h:39
IOFunc_receive
@ IOFunc_receive
Definition lsyscache.h:38
MemoryContextAlloc
void * MemoryContextAlloc(MemoryContext context, Size size)
Definition mcxt.c:1235
repalloc
void * repalloc(void *pointer, Size size)
Definition mcxt.c:1635
pfree
void pfree(void *pointer)
Definition mcxt.c:1619
palloc0
void * palloc0(Size size)
Definition mcxt.c:1420
pnstrdup
char * pnstrdup(const char *in, Size len)
Definition mcxt.c:1921
MULTIRANGE_ITEM_GET_OFFLEN
#define MULTIRANGE_ITEM_GET_OFFLEN(item)
Definition multirangetypes.c:81
multirange_intersect_internal
MultirangeType * multirange_intersect_internal(Oid mltrngtypoid, TypeCacheEntry *rangetyp, int32 range_count1, RangeType **ranges1, int32 range_count2, RangeType **ranges2)
Definition multirangetypes.c:1337
multirange_minus_internal
MultirangeType * multirange_minus_internal(Oid mltrngtypoid, TypeCacheEntry *rangetyp, int32 range_count1, RangeType **ranges1, int32 range_count2, RangeType **ranges2)
Definition multirangetypes.c:1150
multirange_upper
Datum multirange_upper(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1607
multirange_adjacent_range
Datum multirange_adjacent_range(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2595
multirange_before_range
Datum multirange_before_range(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2416
multirange_send
Datum multirange_send(PG_FUNCTION_ARGS)
Definition multirangetypes.c:378
multirange_agg_transfn
Datum multirange_agg_transfn(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1489
multirange_range_contains_bsearch_comparison
static int multirange_range_contains_bsearch_comparison(TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper, void *key, bool *match)
Definition multirangetypes.c:1851
multirange_contains_elem_internal
bool multirange_contains_elem_internal(TypeCacheEntry *rangetyp, const MultirangeType *mr, Datum val)
Definition multirangetypes.c:1784
multirange_upper_inf
Datum multirange_upper_inf(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1699
multirange_intersect_agg_transfn
Datum multirange_intersect_agg_transfn(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1542
range_overleft_multirange
Datum range_overleft_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2172
multirange_get_range
RangeType * multirange_get_range(TypeCacheEntry *rangetyp, const MultirangeType *multirange, int i)
Definition multirangetypes.c:701
range_after_multirange
Datum range_after_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2441
multirange_upper_inc
Datum multirange_upper_inc(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1661
elem_contained_by_multirange
Datum elem_contained_by_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1735
multirange_before_multirange_internal
bool multirange_before_multirange_internal(TypeCacheEntry *rangetyp, const MultirangeType *mr1, const MultirangeType *mr2)
Definition multirangetypes.c:2500
multirange_lt
Datum multirange_lt(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2716
multirange_overlaps_multirange
Datum multirange_overlaps_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2037
range_contained_by_multirange
Datum range_contained_by_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1823
multirange_overright_range
Datum multirange_overright_range(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2267
range_overlaps_multirange
Datum range_overlaps_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2013
make_multirange
MultirangeType * make_multirange(Oid mltrngtypoid, TypeCacheEntry *rangetyp, int32 range_count, RangeType **ranges)
Definition multirangetypes.c:652
multirange_eq_internal
bool multirange_eq_internal(TypeCacheEntry *rangetyp, const MultirangeType *mr1, const MultirangeType *mr2)
Definition multirangetypes.c:1941
multirange_ge
Datum multirange_ge(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2732
multirange_contained_by_range
Datum multirange_contained_by_range(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1835
multirange_canonicalize
static int32 multirange_canonicalize(TypeCacheEntry *rangetyp, int32 input_range_count, RangeType **ranges)
Definition multirangetypes.c:480
MULTIRANGE_ITEM_HAS_OFF
#define MULTIRANGE_ITEM_HAS_OFF(item)
Definition multirangetypes.c:82
multirange_gt
Datum multirange_gt(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2740
multirange_intersect
Datum multirange_intersect(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1307
multirange_contains_multirange_internal
bool multirange_contains_multirange_internal(TypeCacheEntry *rangetyp, const MultirangeType *mr1, const MultirangeType *mr2)
Definition multirangetypes.c:2342
multirange_lower_inc
Datum multirange_lower_inc(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1642
make_empty_multirange
MultirangeType * make_empty_multirange(Oid mltrngtypoid, TypeCacheEntry *rangetyp)
Definition multirangetypes.c:854
multirange_get_bounds
void multirange_get_bounds(TypeCacheEntry *rangetyp, const MultirangeType *multirange, uint32 i, RangeBound *lower, RangeBound *upper)
Definition multirangetypes.c:750
multirange_overlaps_range
Datum multirange_overlaps_range(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2025
multirange_overright_multirange
Datum multirange_overright_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2291
range_adjacent_multirange
Datum range_adjacent_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2583
multirange_out
Datum multirange_out(PG_FUNCTION_ARGS)
Definition multirangetypes.c:299
multirange_constructor1
Datum multirange_constructor1(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1029
multirange_constructor2
Datum multirange_constructor2(PG_FUNCTION_ARGS)
Definition multirangetypes.c:947
multirange_size_estimate
static Size multirange_size_estimate(TypeCacheEntry *rangetyp, int32 range_count, RangeType **ranges)
Definition multirangetypes.c:573
write_multirange_data
static void write_multirange_data(MultirangeType *multirange, TypeCacheEntry *rangetyp, int32 range_count, RangeType **ranges)
Definition multirangetypes.c:601
multirange_overleft_range
Datum multirange_overleft_range(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2184
MULTIRANGE_ITEM_OFFSET_STRIDE
#define MULTIRANGE_ITEM_OFFSET_STRIDE
Definition multirangetypes.c:83
multirange_bsearch_match
static bool multirange_bsearch_match(TypeCacheEntry *typcache, const MultirangeType *mr, void *key, multirange_bsearch_comparison cmp_func)
Definition multirangetypes.c:904
range_adjacent_multirange_internal
bool range_adjacent_multirange_internal(TypeCacheEntry *rangetyp, const RangeType *r, const MultirangeType *mr)
Definition multirangetypes.c:2547
multirange_after_multirange
Datum multirange_after_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2465
multirange_contains_elem
Datum multirange_contains_elem(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1722
range_agg_finalfn
Datum range_agg_finalfn(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1449
range_after_multirange_internal
bool range_after_multirange_internal(TypeCacheEntry *rangetyp, const RangeType *r, const MultirangeType *mr)
Definition multirangetypes.c:2522
multirange_union
Datum multirange_union(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1088
multirange_adjacent_multirange
Datum multirange_adjacent_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2610
multirange_before_multirange
Datum multirange_before_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2428
get_multirange_io_data
static MultirangeIOData * get_multirange_io_data(FunctionCallInfo fcinfo, Oid mltrngtypid, IOFuncSelector func)
Definition multirangetypes.c:419
range_overright_multirange
Datum range_overright_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2255
multirange_lower
Datum multirange_lower(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1584
multirange_minus_multi
Datum multirange_minus_multi(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1239
multirange_overleft_multirange
Datum multirange_overleft_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2209
multirange_ne
Datum multirange_ne(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2000
multirange_contains_range_internal
bool multirange_contains_range_internal(TypeCacheEntry *rangetyp, const MultirangeType *mr, const RangeType *r)
Definition multirangetypes.c:1878
multirange_overlaps_multirange_internal
bool multirange_overlaps_multirange_internal(TypeCacheEntry *rangetyp, const MultirangeType *mr1, const MultirangeType *mr2)
Definition multirangetypes.c:2092
multirange_eq
Datum multirange_eq(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1978
multirange_bsearch_comparison
int(* multirange_bsearch_comparison)(TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper, void *key, bool *match)
Definition multirangetypes.c:85
range_bounds_contains
static bool range_bounds_contains(TypeCacheEntry *typcache, RangeBound *lower1, RangeBound *upper1, RangeBound *lower2, RangeBound *upper2)
Definition multirangetypes.c:884
multirange_deserialize
void multirange_deserialize(TypeCacheEntry *rangetyp, const MultirangeType *multirange, int32 *range_count, RangeType ***ranges)
Definition multirangetypes.c:832
range_bounds_overlaps
static bool range_bounds_overlaps(TypeCacheEntry *typcache, RangeBound *lower1, RangeBound *upper1, RangeBound *lower2, RangeBound *upper2)
Definition multirangetypes.c:864
MultirangeParseState
MultirangeParseState
Definition multirangetypes.c:57
MULTIRANGE_BEFORE_RANGE
@ MULTIRANGE_BEFORE_RANGE
Definition multirangetypes.c:58
MULTIRANGE_IN_RANGE
@ MULTIRANGE_IN_RANGE
Definition multirangetypes.c:59
MULTIRANGE_FINISHED
@ MULTIRANGE_FINISHED
Definition multirangetypes.c:64
MULTIRANGE_AFTER_RANGE
@ MULTIRANGE_AFTER_RANGE
Definition multirangetypes.c:63
MULTIRANGE_IN_RANGE_QUOTED_ESCAPED
@ MULTIRANGE_IN_RANGE_QUOTED_ESCAPED
Definition multirangetypes.c:62
MULTIRANGE_IN_RANGE_ESCAPED
@ MULTIRANGE_IN_RANGE_ESCAPED
Definition multirangetypes.c:60
MULTIRANGE_IN_RANGE_QUOTED
@ MULTIRANGE_IN_RANGE_QUOTED
Definition multirangetypes.c:61
multirange_recv
Datum multirange_recv(PG_FUNCTION_ARGS)
Definition multirangetypes.c:337
multirange_get_typcache
TypeCacheEntry * multirange_get_typcache(FunctionCallInfo fcinfo, Oid mltrngtypid)
Definition multirangetypes.c:552
multirange_minus
Datum multirange_minus(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1120
multirange_contains_multirange
Datum multirange_contains_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2314
MultirangeGetItemsPtr
#define MultirangeGetItemsPtr(mr)
Definition multirangetypes.c:71
multirange_le
Datum multirange_le(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2724
MultirangeGetFlagsPtr
#define MultirangeGetFlagsPtr(mr)
Definition multirangetypes.c:73
hash_multirange
Datum hash_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2863
multirange_get_union_range
RangeType * multirange_get_union_range(TypeCacheEntry *rangetyp, const MultirangeType *mr)
Definition multirangetypes.c:808
hash_multirange_extended
Datum hash_multirange_extended(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2934
multirange_constructor0
Datum multirange_constructor0(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1065
multirange_after_range
Datum multirange_after_range(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2453
multirange_contained_by_multirange
Datum multirange_contained_by_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2327
multirange_empty
Datum multirange_empty(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1633
multirange_range_overlaps_bsearch_comparison
static int multirange_range_overlaps_bsearch_comparison(TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper, void *key, bool *match)
Definition multirangetypes.c:2053
multirange_elem_bsearch_comparison
static int multirange_elem_bsearch_comparison(TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper, void *key, bool *match)
Definition multirangetypes.c:1751
range_before_multirange
Datum range_before_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2404
range_before_multirange_internal
bool range_before_multirange_internal(TypeCacheEntry *rangetyp, const RangeType *r, const MultirangeType *mr)
Definition multirangetypes.c:2478
range_overright_multirange_internal
bool range_overright_multirange_internal(TypeCacheEntry *rangetyp, const RangeType *r, const MultirangeType *mr)
Definition multirangetypes.c:2234
range_contains_multirange_internal
bool range_contains_multirange_internal(TypeCacheEntry *rangetyp, const RangeType *r, const MultirangeType *mr)
Definition multirangetypes.c:1906
multirange_ne_internal
bool multirange_ne_internal(TypeCacheEntry *rangetyp, const MultirangeType *mr1, const MultirangeType *mr2)
Definition multirangetypes.c:1991
multirange_cmp
Datum multirange_cmp(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2651
multirange_get_bounds_offset
static uint32 multirange_get_bounds_offset(const MultirangeType *multirange, int32 i)
Definition multirangetypes.c:679
range_overlaps_multirange_internal
bool range_overlaps_multirange_internal(TypeCacheEntry *rangetyp, const RangeType *r, const MultirangeType *mr)
Definition multirangetypes.c:2070
range_merge_from_multirange
Datum range_merge_from_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2751
range_agg_transfn
Datum range_agg_transfn(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1417
range_contains_multirange
Datum range_contains_multirange(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1810
MULTIRANGE_ITEM_OFF_BIT
#define MULTIRANGE_ITEM_OFF_BIT
Definition multirangetypes.c:80
multirange_unnest
Datum multirange_unnest(PG_FUNCTION_ARGS)
Definition multirangetypes.c:2789
multirange_contains_range
Datum multirange_contains_range(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1798
range_overleft_multirange_internal
bool range_overleft_multirange_internal(TypeCacheEntry *rangetyp, const RangeType *r, const MultirangeType *mr)
Definition multirangetypes.c:2150
MultirangeGetBoundariesPtr
#define MultirangeGetBoundariesPtr(mr, align)
Definition multirangetypes.c:75
multirange_lower_inf
Datum multirange_lower_inf(PG_FUNCTION_ARGS)
Definition multirangetypes.c:1680
MultirangeIsEmpty
#define MultirangeIsEmpty(mr)
Definition multirangetypes.h:42
PG_RETURN_MULTIRANGE_P
#define PG_RETURN_MULTIRANGE_P(x)
Definition multirangetypes.h:67
PG_GETARG_MULTIRANGE_P
#define PG_GETARG_MULTIRANGE_P(n)
Definition multirangetypes.h:65
MultirangeTypeGetOid
#define MultirangeTypeGetOid(mr)
Definition multirangetypes.h:41
MultirangeTypePGetDatum
static Datum MultirangeTypePGetDatum(const MultirangeType *X)
Definition multirangetypes.h:60
AggCheckCallContext
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition nodeAgg.c:4609
errmsg
static char * errmsg
Definition oauth_hook_client.c:61
lower
Datum lower(PG_FUNCTION_ARGS)
Definition oracle_compat.c:49
upper
Datum upper(PG_FUNCTION_ARGS)
Definition oracle_compat.c:80
MemoryContextSwitchTo
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition palloc.h:138
pg_rotate_left32
static uint32 pg_rotate_left32(uint32 word, int n)
Definition pg_bitutils.h:400
len
const void size_t len
Definition pg_crc32c_sse42.c:31
buf
static char buf[DEFAULT_XLOG_SEG_SIZE]
Definition pg_test_fsync.c:71
typalign
char typalign
Definition pg_type.h:178
qsort_arg
void qsort_arg(void *base, size_t nel, size_t elsize, qsort_arg_comparator cmp, void *arg)
pg_strncasecmp
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
Definition pgstrcasecmp.c:65
DatumGetUInt32
static uint32 DatumGetUInt32(Datum X)
Definition postgres.h:222
DatumGetUInt64
static uint64 DatumGetUInt64(Datum X)
Definition postgres.h:436
DatumGetInt64
static int64 DatumGetInt64(Datum X)
Definition postgres.h:416
Datum
uint64_t Datum
Definition postgres.h:70
DatumGetInt32
static int32 DatumGetInt32(Datum X)
Definition postgres.h:202
Oid
unsigned int Oid
Definition postgres_ext.h:32
pq_getmsgint
unsigned int pq_getmsgint(StringInfo msg, int b)
Definition pqformat.c:414
pq_sendbytes
void pq_sendbytes(StringInfo buf, const void *data, int datalen)
Definition pqformat.c:126
pq_getmsgend
void pq_getmsgend(StringInfo msg)
Definition pqformat.c:634
pq_begintypsend
void pq_begintypsend(StringInfo buf)
Definition pqformat.c:325
pq_getmsgbytes
const char * pq_getmsgbytes(StringInfo msg, int datalen)
Definition pqformat.c:507
pq_endtypsend
bytea * pq_endtypsend(StringInfo buf)
Definition pqformat.c:345
pq_sendint32
static void pq_sendint32(StringInfo buf, uint32 i)
Definition pqformat.h:144
range_cmp_bounds
int range_cmp_bounds(TypeCacheEntry *typcache, const RangeBound *b1, const RangeBound *b2)
Definition rangetypes.c:2250
range_split_internal
bool range_split_internal(TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2, RangeType **output1, RangeType **output2)
Definition rangetypes.c:1188
make_range
RangeType * make_range(TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper, bool empty, struct Node *escontext)
Definition rangetypes.c:2186
bounds_adjacent
bool bounds_adjacent(TypeCacheEntry *typcache, RangeBound boundA, RangeBound boundB)
Definition rangetypes.c:763
range_overlaps_internal
bool range_overlaps_internal(TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Definition rangetypes.c:847
range_before_internal
bool range_before_internal(TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Definition rangetypes.c:670
range_intersect_internal
RangeType * range_intersect_internal(TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Definition rangetypes.c:1149
range_minus_internal
RangeType * range_minus_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
Definition rangetypes.c:999
range_deserialize
void range_deserialize(TypeCacheEntry *typcache, const RangeType *range, RangeBound *lower, RangeBound *upper, bool *empty)
Definition rangetypes.c:2090
range_union_internal
RangeType * range_union_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2, bool strict)
Definition rangetypes.c:1058
range_adjacent_internal
bool range_adjacent_internal(TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Definition rangetypes.c:804
range_overleft_internal
bool range_overleft_internal(TypeCacheEntry *typcache, const RangeType *r1, const RangeType *r2)
Definition rangetypes.c:893
range_compare
int range_compare(const void *key1, const void *key2, void *arg)
Definition rangetypes.c:2363
make_empty_range
RangeType * make_empty_range(TypeCacheEntry *typcache)
Definition rangetypes.c:2399
DatumGetRangeTypeP
static RangeType * DatumGetRangeTypeP(Datum X)
Definition rangetypes.h:73
RANGE_HAS_UBOUND
#define RANGE_HAS_UBOUND(flags)
Definition rangetypes.h:51
RANGE_UB_INC
#define RANGE_UB_INC
Definition rangetypes.h:40
RangeIsEmpty
#define RangeIsEmpty(r)
Definition rangetypes.h:55
RangeTypePGetDatum
static Datum RangeTypePGetDatum(const RangeType *X)
Definition rangetypes.h:85
RANGE_LB_INC
#define RANGE_LB_INC
Definition rangetypes.h:39
RANGE_UB_INF
#define RANGE_UB_INF
Definition rangetypes.h:42
PG_RETURN_RANGE_P
#define PG_RETURN_RANGE_P(x)
Definition rangetypes.h:92
RANGE_EMPTY
#define RANGE_EMPTY
Definition rangetypes.h:38
RANGE_HAS_LBOUND
#define RANGE_HAS_LBOUND(flags)
Definition rangetypes.h:47
PG_GETARG_RANGE_P
#define PG_GETARG_RANGE_P(n)
Definition rangetypes.h:90
RANGE_EMPTY_LITERAL
#define RANGE_EMPTY_LITERAL
Definition rangetypes.h:32
RANGE_LB_INF
#define RANGE_LB_INF
Definition rangetypes.h:41
RangeTypeGetOid
#define RangeTypeGetOid(r)
Definition rangetypes.h:35
cmp
static int cmp(const chr *x, const chr *y, size_t len)
Definition regc_locale.c:743
range
static struct cvec * range(struct vars *v, chr a, chr b, int cases)
Definition regc_locale.c:412
StringInfo
struct StringInfoData * StringInfo
Definition string.h:15
resetStringInfo
void resetStringInfo(StringInfo str)
Definition stringinfo.c:126
appendBinaryStringInfo
void appendBinaryStringInfo(StringInfo str, const void *data, int datalen)
Definition stringinfo.c:281
appendStringInfoString
void appendStringInfoString(StringInfo str, const char *s)
Definition stringinfo.c:230
appendStringInfoChar
void appendStringInfoChar(StringInfo str, char ch)
Definition stringinfo.c:242
initStringInfo
void initStringInfo(StringInfo str)
Definition stringinfo.c:97
FmgrInfo::fn_extra
void * fn_extra
Definition fmgr.h:64
FmgrInfo::fn_mcxt
MemoryContext fn_mcxt
Definition fmgr.h:65
FunctionCallInfoBaseData::flinfo
FmgrInfo * flinfo
Definition fmgr.h:87
MultirangeIOData::typcache
TypeCacheEntry * typcache
Definition multirangetypes.c:51
Node
Definition nodes.h:135
TypeCacheEntry::rng_cmp_proc_finfo
FmgrInfo rng_cmp_proc_finfo
Definition typcache.h:102
TypeCacheEntry::rngelemtype
struct TypeCacheEntry * rngelemtype
Definition typcache.h:99
TypeCacheEntry::rngtype
struct TypeCacheEntry * rngtype
Definition typcache.h:109
index
Definition type.h:97
varlena
Definition c.h:776
items
static ItemArray items
Definition test_tidstore.c:48
att_align_pointer
#define att_align_pointer(cur_offset, attalign, attlen, attptr)
Definition tupmacs.h:372
att_nominal_alignby
#define att_nominal_alignby(cur_offset, attalignby)
Definition tupmacs.h:411
att_addlength_pointer
#define att_addlength_pointer(cur_offset, attlen, attptr)
Definition tupmacs.h:431
typalign_to_alignby
static uint8 typalign_to_alignby(char typalign)
Definition tupmacs.h:302
fetch_att
static Datum fetch_att(const void *T, bool attbyval, int attlen)
Definition tupmacs.h:108
lookup_type_cache
TypeCacheEntry * lookup_type_cache(Oid type_id, int flags)
Definition typcache.c:389
TYPECACHE_HASH_PROC_FINFO
#define TYPECACHE_HASH_PROC_FINFO
Definition typcache.h:145
TYPECACHE_MULTIRANGE_INFO
#define TYPECACHE_MULTIRANGE_INFO
Definition typcache.h:154
TYPECACHE_HASH_EXTENDED_PROC_FINFO
#define TYPECACHE_HASH_EXTENDED_PROC_FINFO
Definition typcache.h:153
VARSIZE
static Size VARSIZE(const void *PTR)
Definition varatt.h:298
VARDATA
static char * VARDATA(const void *PTR)
Definition varatt.h:305
SET_VARSIZE
static void SET_VARSIZE(void *PTR, Size len)
Definition varatt.h:432
tmpbuf
static StringInfoData tmpbuf
Definition walsender.c:195

◆ MultirangeGetFlagsPtr

#define MultirangeGetFlagsPtr (   mr)
Value:
((uint8 *) ((char *) (mr) + \
sizeof(MultirangeType) + ((mr)->rangeCount - 1) * sizeof(uint32)))

Definition at line 73 of file multirangetypes.c.

◆ MultirangeGetItemsPtr

#define MultirangeGetItemsPtr (   mr)
Value:
((uint32 *) ((char *) (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.

57{
58 MULTIRANGE_BEFORE_RANGE,
59 MULTIRANGE_IN_RANGE,
60 MULTIRANGE_IN_RANGE_ESCAPED,
61 MULTIRANGE_IN_RANGE_QUOTED,
62 MULTIRANGE_IN_RANGE_QUOTED_ESCAPED,
63 MULTIRANGE_AFTER_RANGE,
64 MULTIRANGE_FINISHED,
65} MultirangeParseState;

Function Documentation

◆ elem_contained_by_multirange()

Datum elem_contained_by_multirange ( PG_FUNCTION_ARGS  )

Definition at line 1735 of file multirangetypes.c.

1736{
1737 Datum val = PG_GETARG_DATUM(0);
1738 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
1739 TypeCacheEntry *typcache;
1740
1741 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1742
1743 PG_RETURN_BOOL(multirange_contains_elem_internal(typcache->rngtype, mr, val));
1744}

References fb(), 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 419 of file multirangetypes.c.

420{
421 MultirangeIOData *cache = (MultirangeIOData *) fcinfo->flinfo->fn_extra;
422
423 if (cache == NULL || cache->typcache->type_id != mltrngtypid)
424 {
425 Oid typiofunc;
426 int16 typlen;
427 bool typbyval;
428 char typalign;
429 char typdelim;
430
431 cache = (MultirangeIOData *) MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
432 sizeof(MultirangeIOData));
433 cache->typcache = lookup_type_cache(mltrngtypid, TYPECACHE_MULTIRANGE_INFO);
434 if (cache->typcache->rngtype == NULL)
435 elog(ERROR, "type %u is not a multirange type", mltrngtypid);
436
437 /* get_type_io_data does more than we need, but is convenient */
438 get_type_io_data(cache->typcache->rngtype->type_id,
439 func,
440 &typlen,
441 &typbyval,
442 &typalign,
443 &typdelim,
444 &cache->typioparam,
445 &typiofunc);
446
447 if (!OidIsValid(typiofunc))
448 {
449 /* this could only happen for receive or send */
450 if (func == IOFunc_receive)
451 ereport(ERROR,
452 (errcode(ERRCODE_UNDEFINED_FUNCTION),
453 errmsg("no binary input function available for type %s",
454 format_type_be(cache->typcache->rngtype->type_id))));
455 else
456 ereport(ERROR,
457 (errcode(ERRCODE_UNDEFINED_FUNCTION),
458 errmsg("no binary output function available for type %s",
459 format_type_be(cache->typcache->rngtype->type_id))));
460 }
461 fmgr_info_cxt(typiofunc, &cache->typioproc,
462 fcinfo->flinfo->fn_mcxt);
463
464 fcinfo->flinfo->fn_extra = cache;
465 }
466
467 return cache;
468}

References elog, ereport, errcode(), errmsg, ERROR, fb(), FunctionCallInfoBaseData::flinfo, fmgr_info_cxt(), FmgrInfo::fn_extra, FmgrInfo::fn_mcxt, format_type_be(), get_type_io_data(), 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 2863 of file multirangetypes.c.

2864{
2865 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2866 uint32 result = 1;
2867 TypeCacheEntry *typcache,
2868 *scache;
2869 int32 range_count,
2870 i;
2871
2872 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2873 scache = typcache->rngtype->rngelemtype;
2874 if (!OidIsValid(scache->hash_proc_finfo.fn_oid))
2875 {
2876 scache = lookup_type_cache(scache->type_id,
2877 TYPECACHE_HASH_PROC_FINFO);
2878 if (!OidIsValid(scache->hash_proc_finfo.fn_oid))
2879 ereport(ERROR,
2880 (errcode(ERRCODE_UNDEFINED_FUNCTION),
2881 errmsg("could not identify a hash function for type %s",
2882 format_type_be(scache->type_id))));
2883 }
2884
2885 range_count = mr->rangeCount;
2886 for (i = 0; i < range_count; i++)
2887 {
2888 RangeBound lower,
2889 upper;
2890 uint8 flags = MultirangeGetFlagsPtr(mr)[i];
2891 uint32 lower_hash;
2892 uint32 upper_hash;
2893 uint32 range_hash;
2894
2895 multirange_get_bounds(typcache->rngtype, mr, i, &lower, &upper);
2896
2897 if (RANGE_HAS_LBOUND(flags))
2898 lower_hash = DatumGetUInt32(FunctionCall1Coll(&scache->hash_proc_finfo,
2899 typcache->rngtype->rng_collation,
2900 lower.val));
2901 else
2902 lower_hash = 0;
2903
2904 if (RANGE_HAS_UBOUND(flags))
2905 upper_hash = DatumGetUInt32(FunctionCall1Coll(&scache->hash_proc_finfo,
2906 typcache->rngtype->rng_collation,
2907 upper.val));
2908 else
2909 upper_hash = 0;
2910
2911 /* Merge hashes of flags and bounds */
2912 range_hash = hash_bytes_uint32((uint32) flags);
2913 range_hash ^= lower_hash;
2914 range_hash = pg_rotate_left32(range_hash, 1);
2915 range_hash ^= upper_hash;
2916
2917 /*
2918 * Use the same approach as hash_array to combine the individual
2919 * elements' hash values:
2920 */
2921 result = (result << 5) - result + range_hash;
2922 }
2923
2924 PG_FREE_IF_COPY(mr, 0);
2925
2926 PG_RETURN_UINT32(result);
2927}

References DatumGetUInt32(), ereport, errcode(), errmsg, ERROR, fb(), format_type_be(), FunctionCall1Coll(), hash_bytes_uint32(), 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, result, TypeCacheEntry::rng_collation, TypeCacheEntry::rngelemtype, TypeCacheEntry::rngtype, TYPECACHE_HASH_PROC_FINFO, and upper().

◆ hash_multirange_extended()

Datum hash_multirange_extended ( PG_FUNCTION_ARGS  )

Definition at line 2934 of file multirangetypes.c.

2935{
2936 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2937 Datum seed = PG_GETARG_DATUM(1);
2938 uint64 result = 1;
2939 TypeCacheEntry *typcache,
2940 *scache;
2941 int32 range_count,
2942 i;
2943
2944 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2945 scache = typcache->rngtype->rngelemtype;
2946 if (!OidIsValid(scache->hash_extended_proc_finfo.fn_oid))
2947 {
2948 scache = lookup_type_cache(scache->type_id,
2949 TYPECACHE_HASH_EXTENDED_PROC_FINFO);
2950 if (!OidIsValid(scache->hash_extended_proc_finfo.fn_oid))
2951 ereport(ERROR,
2952 (errcode(ERRCODE_UNDEFINED_FUNCTION),
2953 errmsg("could not identify a hash function for type %s",
2954 format_type_be(scache->type_id))));
2955 }
2956
2957 range_count = mr->rangeCount;
2958 for (i = 0; i < range_count; i++)
2959 {
2960 RangeBound lower,
2961 upper;
2962 uint8 flags = MultirangeGetFlagsPtr(mr)[i];
2963 uint64 lower_hash;
2964 uint64 upper_hash;
2965 uint64 range_hash;
2966
2967 multirange_get_bounds(typcache->rngtype, mr, i, &lower, &upper);
2968
2969 if (RANGE_HAS_LBOUND(flags))
2970 lower_hash = DatumGetUInt64(FunctionCall2Coll(&scache->hash_extended_proc_finfo,
2971 typcache->rngtype->rng_collation,
2972 lower.val,
2973 seed));
2974 else
2975 lower_hash = 0;
2976
2977 if (RANGE_HAS_UBOUND(flags))
2978 upper_hash = DatumGetUInt64(FunctionCall2Coll(&scache->hash_extended_proc_finfo,
2979 typcache->rngtype->rng_collation,
2980 upper.val,
2981 seed));
2982 else
2983 upper_hash = 0;
2984
2985 /* Merge hashes of flags and bounds */
2986 range_hash = DatumGetUInt64(hash_uint32_extended((uint32) flags,
2987 DatumGetInt64(seed)));
2988 range_hash ^= lower_hash;
2989 range_hash = ROTATE_HIGH_AND_LOW_32BITS(range_hash);
2990 range_hash ^= upper_hash;
2991
2992 /*
2993 * Use the same approach as hash_array to combine the individual
2994 * elements' hash values:
2995 */
2996 result = (result << 5) - result + range_hash;
2997 }
2998
2999 PG_FREE_IF_COPY(mr, 0);
3000
3001 PG_RETURN_UINT64(result);
3002}

References DatumGetInt64(), DatumGetUInt64(), ereport, errcode(), errmsg, ERROR, fb(), format_type_be(), FunctionCall2Coll(), 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, result, TypeCacheEntry::rng_collation, TypeCacheEntry::rngelemtype, TypeCacheEntry::rngtype, ROTATE_HIGH_AND_LOW_32BITS, TYPECACHE_HASH_EXTENDED_PROC_FINFO, and upper().

◆ make_empty_multirange()

MultirangeType * make_empty_multirange ( Oid  mltrngtypoid,
TypeCacheEntry *  rangetyp 
)

Definition at line 854 of file multirangetypes.c.

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

References fb(), and make_multirange().

Referenced by multirange_intersect().

◆ make_multirange()

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

Definition at line 652 of file multirangetypes.c.

654{
655 MultirangeType *multirange;
656 Size size;
657
658 /* Sort and merge input ranges. */
659 range_count = multirange_canonicalize(rangetyp, range_count, ranges);
660
661 /* Note: zero-fill is required here, just as in heap tuples */
662 size = multirange_size_estimate(rangetyp, range_count, ranges);
663 multirange = palloc0(size);
664 SET_VARSIZE(multirange, size);
665
666 /* Now fill in the datum */
667 multirange->multirangetypid = mltrngtypoid;
668 multirange->rangeCount = range_count;
669
670 write_multirange_data(multirange, rangetyp, range_count, ranges);
671
672 return multirange;
673}

References fb(), multirange_canonicalize(), multirange_size_estimate(), palloc0(), 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 2610 of file multirangetypes.c.

2611{
2612 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2613 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2614 TypeCacheEntry *typcache;
2615 int32 range_count1;
2616 int32 range_count2;
2617 RangeBound lower1,
2618 upper1,
2619 lower2,
2620 upper2;
2621
2622 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
2623 PG_RETURN_BOOL(false);
2624
2625 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2626
2627 range_count1 = mr1->rangeCount;
2628 range_count2 = mr2->rangeCount;
2629 multirange_get_bounds(typcache->rngtype, mr1, range_count1 - 1,
2630 &lower1, &upper1);
2631 multirange_get_bounds(typcache->rngtype, mr2, 0,
2632 &lower2, &upper2);
2633 if (bounds_adjacent(typcache->rngtype, upper1, lower2))
2634 PG_RETURN_BOOL(true);
2635
2636 if (range_count1 > 1)
2637 multirange_get_bounds(typcache->rngtype, mr1, 0,
2638 &lower1, &upper1);
2639 if (range_count2 > 1)
2640 multirange_get_bounds(typcache->rngtype, mr2, range_count2 - 1,
2641 &lower2, &upper2);
2642 if (bounds_adjacent(typcache->rngtype, upper2, lower1))
2643 PG_RETURN_BOOL(true);
2644 PG_RETURN_BOOL(false);
2645}

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

◆ multirange_adjacent_range()

Datum multirange_adjacent_range ( PG_FUNCTION_ARGS  )

Definition at line 2595 of file multirangetypes.c.

2596{
2597 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2598 RangeType *r = PG_GETARG_RANGE_P(1);
2599 TypeCacheEntry *typcache;
2600
2601 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2602 PG_RETURN_BOOL(false);
2603
2604 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2605
2606 PG_RETURN_BOOL(range_adjacent_multirange_internal(typcache->rngtype, r, mr));
2607}

References fb(), 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 2465 of file multirangetypes.c.

2466{
2467 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2468 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2469 TypeCacheEntry *typcache;
2470
2471 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2472
2473 PG_RETURN_BOOL(multirange_before_multirange_internal(typcache->rngtype, mr2, mr1));
2474}

References fb(), 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 2453 of file multirangetypes.c.

2454{
2455 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2456 RangeType *r = PG_GETARG_RANGE_P(1);
2457 TypeCacheEntry *typcache;
2458
2459 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2460
2461 PG_RETURN_BOOL(range_before_multirange_internal(typcache->rngtype, r, mr));
2462}

References fb(), 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 1489 of file multirangetypes.c.

1490{
1491 MemoryContext aggContext;
1492 Oid mltrngtypoid;
1493 TypeCacheEntry *typcache;
1494 TypeCacheEntry *rngtypcache;
1495 ArrayBuildState *state;
1496
1497 if (!AggCheckCallContext(fcinfo, &aggContext))
1498 elog(ERROR, "multirange_agg_transfn called in non-aggregate context");
1499
1500 mltrngtypoid = get_fn_expr_argtype(fcinfo->flinfo, 1);
1501 if (!type_is_multirange(mltrngtypoid))
1502 elog(ERROR, "range_agg must be called with a multirange");
1503
1504 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
1505 rngtypcache = typcache->rngtype;
1506
1507 if (PG_ARGISNULL(0))
1508 state = initArrayResult(rngtypcache->type_id, aggContext, false);
1509 else
1510 state = (ArrayBuildState *) PG_GETARG_POINTER(0);
1511
1512 /* skip NULLs */
1513 if (!PG_ARGISNULL(1))
1514 {
1515 MultirangeType *current;
1516 int32 range_count;
1517 RangeType **ranges;
1518
1519 current = PG_GETARG_MULTIRANGE_P(1);
1520 multirange_deserialize(rngtypcache, current, &range_count, &ranges);
1521 if (range_count == 0)
1522 {
1523 /*
1524 * Add an empty range so we get an empty result (not a null
1525 * result).
1526 */
1527 accumArrayResult(state,
1528 RangeTypePGetDatum(make_empty_range(rngtypcache)),
1529 false, rngtypcache->type_id, aggContext);
1530 }
1531 else
1532 {
1533 for (int32 i = 0; i < range_count; i++)
1534 accumArrayResult(state, RangeTypePGetDatum(ranges[i]), false, rngtypcache->type_id, aggContext);
1535 }
1536 }
1537
1538 PG_RETURN_POINTER(state);
1539}

References accumArrayResult(), AggCheckCallContext(), elog, ERROR, fb(), 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, and type_is_multirange().

◆ multirange_before_multirange()

Datum multirange_before_multirange ( PG_FUNCTION_ARGS  )

Definition at line 2428 of file multirangetypes.c.

2429{
2430 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2431 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2432 TypeCacheEntry *typcache;
2433
2434 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2435
2436 PG_RETURN_BOOL(multirange_before_multirange_internal(typcache->rngtype, mr1, mr2));
2437}

References fb(), 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 2500 of file multirangetypes.c.

2503{
2504 RangeBound lower1,
2505 upper1,
2506 lower2,
2507 upper2;
2508
2509 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
2510 return false;
2511
2512 multirange_get_bounds(rangetyp, mr1, mr1->rangeCount - 1,
2513 &lower1, &upper1);
2514 multirange_get_bounds(rangetyp, mr2, 0,
2515 &lower2, &upper2);
2516
2517 return (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0);
2518}

References fb(), multirange_get_bounds(), MultirangeIsEmpty, and range_cmp_bounds().

Referenced by multirange_after_multirange(), and multirange_before_multirange().

◆ multirange_before_range()

Datum multirange_before_range ( PG_FUNCTION_ARGS  )

Definition at line 2416 of file multirangetypes.c.

2417{
2418 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2419 RangeType *r = PG_GETARG_RANGE_P(1);
2420 TypeCacheEntry *typcache;
2421
2422 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2423
2424 PG_RETURN_BOOL(range_after_multirange_internal(typcache->rngtype, r, mr));
2425}

References fb(), 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 904 of file multirangetypes.c.

906{
907 uint32 l,
908 u,
909 idx;
910 int comparison;
911 bool match = false;
912
913 l = 0;
914 u = mr->rangeCount;
915 while (l < u)
916 {
917 RangeBound lower,
918 upper;
919
920 idx = (l + u) / 2;
921 multirange_get_bounds(typcache, mr, idx, &lower, &upper);
922 comparison = (*cmp_func) (typcache, &lower, &upper, key, &match);
923
924 if (comparison < 0)
925 u = idx;
926 else if (comparison > 0)
927 l = idx + 1;
928 else
929 return match;
930 }
931
932 return false;
933}

References fb(), idx(), lower(), multirange_get_bounds(), 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 480 of file multirangetypes.c.

482{
483 RangeType *lastRange = NULL;
484 RangeType *currentRange;
485 int32 i;
486 int32 output_range_count = 0;
487
488 /* Sort the ranges so we can find the ones that overlap/meet. */
489 if (ranges != NULL)
490 qsort_arg(ranges, input_range_count, sizeof(RangeType *),
491 range_compare, rangetyp);
492
493 /* Now merge where possible: */
494 for (i = 0; i < input_range_count; i++)
495 {
496 currentRange = ranges[i];
497 if (RangeIsEmpty(currentRange))
498 continue;
499
500 if (lastRange == NULL)
501 {
502 ranges[output_range_count++] = lastRange = currentRange;
503 continue;
504 }
505
506 /*
507 * range_adjacent_internal gives true if *either* A meets B or B meets
508 * A, which is not quite want we want, but we rely on the sorting
509 * above to rule out B meets A ever happening.
510 */
511 if (range_adjacent_internal(rangetyp, lastRange, currentRange))
512 {
513 /* The two ranges touch (without overlap), so merge them: */
514 ranges[output_range_count - 1] = lastRange =
515 range_union_internal(rangetyp, lastRange, currentRange, false);
516 }
517 else if (range_before_internal(rangetyp, lastRange, currentRange))
518 {
519 /* There's a gap, so make a new entry: */
520 lastRange = ranges[output_range_count] = currentRange;
521 output_range_count++;
522 }
523 else
524 {
525 /* They must overlap, so merge them: */
526 ranges[output_range_count - 1] = lastRange =
527 range_union_internal(rangetyp, lastRange, currentRange, true);
528 }
529 }
530
531 return output_range_count;
532}

References fb(), 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 2651 of file multirangetypes.c.

2652{
2653 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2654 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2655 int32 range_count_1;
2656 int32 range_count_2;
2657 int32 range_count_max;
2658 int32 i;
2659 TypeCacheEntry *typcache;
2660 int cmp = 0; /* If both are empty we'll use this. */
2661
2662 /* Different types should be prevented by ANYMULTIRANGE matching rules */
2663 if (MultirangeTypeGetOid(mr1) != MultirangeTypeGetOid(mr2))
2664 elog(ERROR, "multirange types do not match");
2665
2666 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2667
2668 range_count_1 = mr1->rangeCount;
2669 range_count_2 = mr2->rangeCount;
2670
2671 /* Loop over source data */
2672 range_count_max = Max(range_count_1, range_count_2);
2673 for (i = 0; i < range_count_max; i++)
2674 {
2675 RangeBound lower1,
2676 upper1,
2677 lower2,
2678 upper2;
2679
2680 /*
2681 * If one multirange is shorter, it's as if it had empty ranges at the
2682 * end to extend its length. An empty range compares earlier than any
2683 * other range, so the shorter multirange comes before the longer.
2684 * This is the same behavior as in other types, e.g. in strings 'aaa'
2685 * < 'aaaaaa'.
2686 */
2687 if (i >= range_count_1)
2688 {
2689 cmp = -1;
2690 break;
2691 }
2692 if (i >= range_count_2)
2693 {
2694 cmp = 1;
2695 break;
2696 }
2697
2698 multirange_get_bounds(typcache->rngtype, mr1, i, &lower1, &upper1);
2699 multirange_get_bounds(typcache->rngtype, mr2, i, &lower2, &upper2);
2700
2701 cmp = range_cmp_bounds(typcache->rngtype, &lower1, &lower2);
2702 if (cmp == 0)
2703 cmp = range_cmp_bounds(typcache->rngtype, &upper1, &upper2);
2704 if (cmp != 0)
2705 break;
2706 }
2707
2708 PG_FREE_IF_COPY(mr1, 0);
2709 PG_FREE_IF_COPY(mr2, 1);
2710
2711 PG_RETURN_INT32(cmp);
2712}

References cmp(), elog, ERROR, fb(), i, Max, multirange_get_bounds(), multirange_get_typcache(), MultirangeTypeGetOid, PG_FREE_IF_COPY, PG_GETARG_MULTIRANGE_P, PG_RETURN_INT32, range_cmp_bounds(), 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 1065 of file multirangetypes.c.

1066{
1067 Oid mltrngtypid;
1068 TypeCacheEntry *typcache;
1069 TypeCacheEntry *rangetyp;
1070
1071 /* This should always be called without arguments */
1072 if (PG_NARGS() != 0)
1073 elog(ERROR,
1074 "niladic multirange constructor must not receive arguments");
1075
1076 mltrngtypid = get_fn_expr_rettype(fcinfo->flinfo);
1077 typcache = multirange_get_typcache(fcinfo, mltrngtypid);
1078 rangetyp = typcache->rngtype;
1079
1080 PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, 0, NULL));
1081}

References elog, ERROR, fb(), 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 1029 of file multirangetypes.c.

1030{
1031 Oid mltrngtypid = get_fn_expr_rettype(fcinfo->flinfo);
1032 Oid rngtypid;
1033 TypeCacheEntry *typcache;
1034 TypeCacheEntry *rangetyp;
1035 RangeType *range;
1036
1037 typcache = multirange_get_typcache(fcinfo, mltrngtypid);
1038 rangetyp = typcache->rngtype;
1039
1040 /*
1041 * This check should be guaranteed by our signature, but let's do it just
1042 * in case.
1043 */
1044
1045 if (PG_ARGISNULL(0))
1046 elog(ERROR,
1047 "multirange values cannot contain null members");
1048
1049 range = PG_GETARG_RANGE_P(0);
1050
1051 /* Make sure the range type matches. */
1052 rngtypid = RangeTypeGetOid(range);
1053 if (rngtypid != rangetyp->type_id)
1054 elog(ERROR, "type %u does not match constructor type", rngtypid);
1055
1056 PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, 1, &range));
1057}

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

◆ multirange_constructor2()

Datum multirange_constructor2 ( PG_FUNCTION_ARGS  )

Definition at line 947 of file multirangetypes.c.

948{
949 Oid mltrngtypid = get_fn_expr_rettype(fcinfo->flinfo);
950 Oid rngtypid;
951 TypeCacheEntry *typcache;
952 TypeCacheEntry *rangetyp;
953 ArrayType *rangeArray;
954 int range_count;
955 Datum *elements;
956 bool *nulls;
957 RangeType **ranges;
958 int dims;
959 int i;
960
961 typcache = multirange_get_typcache(fcinfo, mltrngtypid);
962 rangetyp = typcache->rngtype;
963
964 /*
965 * A no-arg invocation should call multirange_constructor0 instead, but
966 * returning an empty range is what that does.
967 */
968
969 if (PG_NARGS() == 0)
970 PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, 0, NULL));
971
972 /*
973 * This check should be guaranteed by our signature, but let's do it just
974 * in case.
975 */
976
977 if (PG_ARGISNULL(0))
978 elog(ERROR,
979 "multirange values cannot contain null members");
980
981 rangeArray = PG_GETARG_ARRAYTYPE_P(0);
982
983 dims = ARR_NDIM(rangeArray);
984 if (dims > 1)
985 ereport(ERROR,
986 (errcode(ERRCODE_CARDINALITY_VIOLATION),
987 errmsg("multiranges cannot be constructed from multidimensional arrays")));
988
989 rngtypid = ARR_ELEMTYPE(rangeArray);
990 if (rngtypid != rangetyp->type_id)
991 elog(ERROR, "type %u does not match constructor type", rngtypid);
992
993 /*
994 * Be careful: we can still be called with zero ranges, like this:
995 * `int4multirange(variadic '{}'::int4range[])
996 */
997 if (dims == 0)
998 {
999 range_count = 0;
1000 ranges = NULL;
1001 }
1002 else
1003 {
1004 deconstruct_array(rangeArray, rngtypid, rangetyp->typlen, rangetyp->typbyval,
1005 rangetyp->typalign, &elements, &nulls, &range_count);
1006
1007 ranges = palloc0(range_count * sizeof(RangeType *));
1008 for (i = 0; i < range_count; i++)
1009 {
1010 if (nulls[i])
1011 ereport(ERROR,
1012 (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
1013 errmsg("multirange values cannot contain null members")));
1014
1015 /* make_multirange will do its own copy */
1016 ranges[i] = DatumGetRangeTypeP(elements[i]);
1017 }
1018 }
1019
1020 PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypid, rangetyp, range_count, ranges));
1021}

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

◆ multirange_contained_by_multirange()

Datum multirange_contained_by_multirange ( PG_FUNCTION_ARGS  )

Definition at line 2327 of file multirangetypes.c.

2328{
2329 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2330 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2331 TypeCacheEntry *typcache;
2332
2333 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2334
2335 PG_RETURN_BOOL(multirange_contains_multirange_internal(typcache->rngtype, mr2, mr1));
2336}

References fb(), 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 1835 of file multirangetypes.c.

1836{
1837 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1838 RangeType *r = PG_GETARG_RANGE_P(1);
1839 TypeCacheEntry *typcache;
1840
1841 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1842
1843 PG_RETURN_BOOL(range_contains_multirange_internal(typcache->rngtype, r, mr));
1844}

References fb(), 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 1722 of file multirangetypes.c.

1723{
1724 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1725 Datum val = PG_GETARG_DATUM(1);
1726 TypeCacheEntry *typcache;
1727
1728 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1729
1730 PG_RETURN_BOOL(multirange_contains_elem_internal(typcache->rngtype, mr, val));
1731}

References fb(), 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 1784 of file multirangetypes.c.

1786{
1787 if (MultirangeIsEmpty(mr))
1788 return false;
1789
1790 return multirange_bsearch_match(rangetyp, mr, &val,
1791 multirange_elem_bsearch_comparison);
1792}

References fb(), 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 2314 of file multirangetypes.c.

2315{
2316 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2317 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2318 TypeCacheEntry *typcache;
2319
2320 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2321
2322 PG_RETURN_BOOL(multirange_contains_multirange_internal(typcache->rngtype, mr1, mr2));
2323}

References fb(), 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 2342 of file multirangetypes.c.

2345{
2346 int32 range_count1 = mr1->rangeCount;
2347 int32 range_count2 = mr2->rangeCount;
2348 int i1,
2349 i2;
2350 RangeBound lower1,
2351 upper1,
2352 lower2,
2353 upper2;
2354
2355 /*
2356 * We follow the same logic for empties as ranges: - an empty multirange
2357 * contains an empty range/multirange. - an empty multirange can't contain
2358 * any other range/multirange. - an empty multirange is contained by any
2359 * other range/multirange.
2360 */
2361
2362 if (range_count2 == 0)
2363 return true;
2364 if (range_count1 == 0)
2365 return false;
2366
2367 /*
2368 * Every range in mr2 must be contained by some range in mr1. To avoid
2369 * O(n^2) we walk through both ranges in tandem.
2370 */
2371 i1 = 0;
2372 multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
2373 for (i2 = 0; i2 < range_count2; i2++)
2374 {
2375 multirange_get_bounds(rangetyp, mr2, i2, &lower2, &upper2);
2376
2377 /* Discard r1s while r1 << r2 */
2378 while (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0)
2379 {
2380 if (++i1 >= range_count1)
2381 return false;
2382 multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
2383 }
2384
2385 /*
2386 * If r1 @> r2, go to the next r2, otherwise return false (since every
2387 * r1[n] and r1[n+1] must have a gap). Note this will give weird
2388 * answers if you don't canonicalize, e.g. with a custom
2389 * int2multirange {[1,1], [2,2]} there is a "gap". But that is
2390 * consistent with other range operators, e.g. '[1,1]'::int2range -|-
2391 * '[2,2]'::int2range is false.
2392 */
2393 if (!range_bounds_contains(rangetyp, &lower1, &upper1,
2394 &lower2, &upper2))
2395 return false;
2396 }
2397
2398 /* All ranges in mr2 are satisfied */
2399 return true;
2400}

References fb(), multirange_get_bounds(), range_bounds_contains(), and range_cmp_bounds().

Referenced by multirange_contained_by_multirange(), and multirange_contains_multirange().

◆ multirange_contains_range()

Datum multirange_contains_range ( PG_FUNCTION_ARGS  )

Definition at line 1798 of file multirangetypes.c.

1799{
1800 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1801 RangeType *r = PG_GETARG_RANGE_P(1);
1802 TypeCacheEntry *typcache;
1803
1804 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1805
1806 PG_RETURN_BOOL(multirange_contains_range_internal(typcache->rngtype, mr, r));
1807}

References fb(), 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 1878 of file multirangetypes.c.

1881{
1882 RangeBound bounds[2];
1883 bool empty;
1884
1885 /*
1886 * Every multirange contains an infinite number of empty ranges, even an
1887 * empty one.
1888 */
1889 if (RangeIsEmpty(r))
1890 return true;
1891
1892 if (MultirangeIsEmpty(mr))
1893 return false;
1894
1895 range_deserialize(rangetyp, r, &bounds[0], &bounds[1], &empty);
1896 Assert(!empty);
1897
1898 return multirange_bsearch_match(rangetyp, mr, bounds,
1899 multirange_range_contains_bsearch_comparison);
1900}

References Assert, fb(), 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 832 of file multirangetypes.c.

835{
836 *range_count = multirange->rangeCount;
837
838 /* Convert each ShortRangeType into a RangeType */
839 if (*range_count > 0)
840 {
841 int i;
842
843 *ranges = palloc_array(RangeType *, *range_count);
844 for (i = 0; i < *range_count; i++)
845 (*ranges)[i] = multirange_get_range(rangetyp, multirange, i);
846 }
847 else
848 {
849 *ranges = NULL;
850 }
851}

References fb(), i, multirange_get_range(), and palloc_array.

Referenced by multirange_agg_transfn(), multirange_intersect(), multirange_intersect_agg_transfn(), multirange_minus(), multirange_minus_multi(), 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 1751 of file multirangetypes.c.

1754{
1755 Datum val = *((Datum *) key);
1756 int cmp;
1757
1758 if (!lower->infinite)
1759 {
1760 cmp = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
1761 typcache->rng_collation,
1762 lower->val, val));
1763 if (cmp > 0 || (cmp == 0 && !lower->inclusive))
1764 return -1;
1765 }
1766
1767 if (!upper->infinite)
1768 {
1769 cmp = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
1770 typcache->rng_collation,
1771 upper->val, val));
1772 if (cmp < 0 || (cmp == 0 && !upper->inclusive))
1773 return 1;
1774 }
1775
1776 *match = true;
1777 return 0;
1778}

References cmp(), DatumGetInt32(), FunctionCall2Coll(), 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 1633 of file multirangetypes.c.

1634{
1635 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1636
1637 PG_RETURN_BOOL(MultirangeIsEmpty(mr));
1638}

References fb(), MultirangeIsEmpty, PG_GETARG_MULTIRANGE_P, and PG_RETURN_BOOL.

◆ multirange_eq()

Datum multirange_eq ( PG_FUNCTION_ARGS  )

Definition at line 1978 of file multirangetypes.c.

1979{
1980 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
1981 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
1982 TypeCacheEntry *typcache;
1983
1984 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
1985
1986 PG_RETURN_BOOL(multirange_eq_internal(typcache->rngtype, mr1, mr2));
1987}

References fb(), 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 1941 of file multirangetypes.c.

1944{
1945 int32 range_count_1;
1946 int32 range_count_2;
1947 int32 i;
1948 RangeBound lower1,
1949 upper1,
1950 lower2,
1951 upper2;
1952
1953 /* Different types should be prevented by ANYMULTIRANGE matching rules */
1954 if (MultirangeTypeGetOid(mr1) != MultirangeTypeGetOid(mr2))
1955 elog(ERROR, "multirange types do not match");
1956
1957 range_count_1 = mr1->rangeCount;
1958 range_count_2 = mr2->rangeCount;
1959
1960 if (range_count_1 != range_count_2)
1961 return false;
1962
1963 for (i = 0; i < range_count_1; i++)
1964 {
1965 multirange_get_bounds(rangetyp, mr1, i, &lower1, &upper1);
1966 multirange_get_bounds(rangetyp, mr2, i, &lower2, &upper2);
1967
1968 if (range_cmp_bounds(rangetyp, &lower1, &lower2) != 0 ||
1969 range_cmp_bounds(rangetyp, &upper1, &upper2) != 0)
1970 return false;
1971 }
1972
1973 return true;
1974}

References elog, ERROR, fb(), i, multirange_get_bounds(), MultirangeTypeGetOid, and range_cmp_bounds().

Referenced by multirange_eq(), and multirange_ne_internal().

◆ multirange_ge()

Datum multirange_ge ( PG_FUNCTION_ARGS  )

Definition at line 2732 of file multirangetypes.c.

2733{
2734 int cmp = DatumGetInt32(multirange_cmp(fcinfo));
2735
2736 PG_RETURN_BOOL(cmp >= 0);
2737}

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 750 of file multirangetypes.c.

753{
754 uint32 offset;
755 uint8 flags;
756 const char *ptr;
757 int16 typlen = rangetyp->rngelemtype->typlen;
758 char typalign = rangetyp->rngelemtype->typalign;
759 bool typbyval = rangetyp->rngelemtype->typbyval;
760 Datum lbound;
761 Datum ubound;
762
763 Assert(i < multirange->rangeCount);
764
765 offset = multirange_get_bounds_offset(multirange, i);
766 flags = MultirangeGetFlagsPtr(multirange)[i];
767 ptr = MultirangeGetBoundariesPtr(multirange, typalign) + offset;
768
769 /* multirange can't contain empty ranges */
770 Assert((flags & RANGE_EMPTY) == 0);
771
772 /* fetch lower bound, if any */
773 if (RANGE_HAS_LBOUND(flags))
774 {
775 /* att_align_pointer cannot be necessary here */
776 lbound = fetch_att(ptr, typbyval, typlen);
777 ptr = (char *) att_addlength_pointer(ptr, typlen, ptr);
778 }
779 else
780 lbound = (Datum) 0;
781
782 /* fetch upper bound, if any */
783 if (RANGE_HAS_UBOUND(flags))
784 {
785 ptr = (char *) att_align_pointer(ptr, typalign, typlen, ptr);
786 ubound = fetch_att(ptr, typbyval, typlen);
787 /* no need for att_addlength_pointer */
788 }
789 else
790 ubound = (Datum) 0;
791
792 /* emit results */
793 lower->val = lbound;
794 lower->infinite = (flags & RANGE_LB_INF) != 0;
795 lower->inclusive = (flags & RANGE_LB_INC) != 0;
796 lower->lower = true;
797
798 upper->val = ubound;
799 upper->infinite = (flags & RANGE_UB_INF) != 0;
800 upper->inclusive = (flags & RANGE_UB_INC) != 0;
801 upper->lower = false;
802}

References Assert, att_addlength_pointer, att_align_pointer, fb(), 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, typalign, 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 679 of file multirangetypes.c.

680{
681 uint32 *items = MultirangeGetItemsPtr(multirange);
682 uint32 offset = 0;
683
684 /*
685 * Summarize lengths till we meet an offset.
686 */
687 while (i > 0)
688 {
689 offset += MULTIRANGE_ITEM_GET_OFFLEN(items[i - 1]);
690 if (MULTIRANGE_ITEM_HAS_OFF(items[i - 1]))
691 break;
692 i--;
693 }
694 return offset;
695}

References fb(), 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 701 of file multirangetypes.c.

703{
704 uint32 offset;
705 uint8 flags;
706 const char *begin;
707 char *ptr;
708 int16 typlen = rangetyp->rngelemtype->typlen;
709 char typalign = rangetyp->rngelemtype->typalign;
710 uint32 len;
711 RangeType *range;
712
713 Assert(i < multirange->rangeCount);
714
715 offset = multirange_get_bounds_offset(multirange, i);
716 flags = MultirangeGetFlagsPtr(multirange)[i];
717 begin = ptr = MultirangeGetBoundariesPtr(multirange, typalign) + offset;
718
719 /*
720 * Calculate the size of bound values. In principle, we could get offset
721 * of the next range bound values and calculate accordingly. But range
722 * bound values are aligned, so we have to walk the values to get the
723 * exact size.
724 */
725 if (RANGE_HAS_LBOUND(flags))
726 ptr = (char *) att_addlength_pointer(ptr, typlen, ptr);
727 if (RANGE_HAS_UBOUND(flags))
728 {
729 ptr = (char *) att_align_pointer(ptr, typalign, typlen, ptr);
730 ptr = (char *) att_addlength_pointer(ptr, typlen, ptr);
731 }
732 len = (ptr - begin) + sizeof(RangeType) + sizeof(uint8);
733
734 range = palloc0(len);
735 SET_VARSIZE(range, len);
736 range->rangetypid = rangetyp->type_id;
737
738 memcpy(range + 1, begin, ptr - begin);
739 *((uint8 *) (range + 1) + (ptr - begin)) = flags;
740
741 return range;
742}

References Assert, att_addlength_pointer, att_align_pointer, fb(), i, len, memcpy(), multirange_get_bounds_offset(), MultirangeGetBoundariesPtr, MultirangeGetFlagsPtr, palloc0(), range(), RANGE_HAS_LBOUND, RANGE_HAS_UBOUND, SET_VARSIZE(), and typalign.

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 552 of file multirangetypes.c.

553{
554 TypeCacheEntry *typcache = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
555
556 if (typcache == NULL ||
557 typcache->type_id != mltrngtypid)
558 {
559 typcache = lookup_type_cache(mltrngtypid, TYPECACHE_MULTIRANGE_INFO);
560 if (typcache->rngtype == NULL)
561 elog(ERROR, "type %u is not a multirange type", mltrngtypid);
562 fcinfo->flinfo->fn_extra = typcache;
563 }
564
565 return typcache;
566}

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

Referenced by elem_contained_by_multirange(), hash_multirange(), hash_multirange_extended(), multirange_adjacent_multirange(), multirange_adjacent_range(), multirange_after_multirange(), multirange_after_range(), multirange_agg_transfn(), multirange_before_multirange(), multirange_before_range(), multirange_cmp(), multirange_constructor0(), multirange_constructor1(), multirange_constructor2(), multirange_contained_by_multirange(), multirange_contained_by_range(), multirange_contains_elem(), multirange_contains_multirange(), multirange_contains_range(), multirange_eq(), multirange_gist_compress(), multirange_intersect(), multirange_intersect_agg_transfn(), multirange_lower(), multirange_lower_inc(), multirange_lower_inf(), multirange_minus(), multirange_ne(), multirange_overlaps_multirange(), multirange_overlaps_range(), multirange_overleft_multirange(), multirange_overleft_range(), multirange_overright_multirange(), multirange_overright_range(), multirange_typanalyze(), multirange_union(), multirange_upper(), multirange_upper_inc(), multirange_upper_inf(), multirangesel(), range_adjacent_multirange(), range_after_multirange(), range_agg_finalfn(), range_before_multirange(), range_contained_by_multirange(), range_contains_multirange(), range_merge_from_multirange(), range_overlaps_multirange(), range_overleft_multirange(), and range_overright_multirange().

◆ multirange_get_union_range()

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

Definition at line 808 of file multirangetypes.c.

810{
811 RangeBound lower,
812 upper,
813 tmp;
814
815 if (MultirangeIsEmpty(mr))
816 return make_empty_range(rangetyp);
817
818 multirange_get_bounds(rangetyp, mr, 0, &lower, &tmp);
819 multirange_get_bounds(rangetyp, mr, mr->rangeCount - 1, &tmp, &upper);
820
821 return make_range(rangetyp, &lower, &upper, false, NULL);
822}

References fb(), lower(), make_empty_range(), make_range(), multirange_get_bounds(), MultirangeIsEmpty, and upper().

Referenced by multirange_gist_compress().

◆ multirange_gt()

Datum multirange_gt ( PG_FUNCTION_ARGS  )

Definition at line 2740 of file multirangetypes.c.

2741{
2742 int cmp = DatumGetInt32(multirange_cmp(fcinfo));
2743
2744 PG_RETURN_BOOL(cmp > 0);
2745}

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.

118{
119 char *input_str = PG_GETARG_CSTRING(0);
120 Oid mltrngtypoid = PG_GETARG_OID(1);
121 Oid typmod = PG_GETARG_INT32(2);
122 Node *escontext = fcinfo->context;
123 TypeCacheEntry *rangetyp;
124 int32 ranges_seen = 0;
125 int32 range_count = 0;
126 int32 range_capacity = 8;
127 RangeType *range;
128 RangeType **ranges = palloc_array(RangeType *, range_capacity);
129 MultirangeIOData *cache;
130 MultirangeType *ret;
131 MultirangeParseState parse_state;
132 const char *ptr = input_str;
133 const char *range_str_begin = NULL;
134 int32 range_str_len;
135 char *range_str;
136 Datum range_datum;
137
138 cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_input);
139 rangetyp = cache->typcache->rngtype;
140
141 /* consume whitespace */
142 while (*ptr != '\0' && isspace((unsigned char) *ptr))
143 ptr++;
144
145 if (*ptr == '{')
146 ptr++;
147 else
148 ereturn(escontext, (Datum) 0,
149 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
150 errmsg("malformed multirange literal: \"%s\"",
151 input_str),
152 errdetail("Missing left brace.")));
153
154 /* consume ranges */
155 parse_state = MULTIRANGE_BEFORE_RANGE;
156 for (; parse_state != MULTIRANGE_FINISHED; ptr++)
157 {
158 char ch = *ptr;
159
160 if (ch == '\0')
161 ereturn(escontext, (Datum) 0,
162 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
163 errmsg("malformed multirange literal: \"%s\"",
164 input_str),
165 errdetail("Unexpected end of input.")));
166
167 /* skip whitespace */
168 if (isspace((unsigned char) ch))
169 continue;
170
171 switch (parse_state)
172 {
173 case MULTIRANGE_BEFORE_RANGE:
174 if (ch == '[' || ch == '(')
175 {
176 range_str_begin = ptr;
177 parse_state = MULTIRANGE_IN_RANGE;
178 }
179 else if (ch == '}' && ranges_seen == 0)
180 parse_state = MULTIRANGE_FINISHED;
181 else if (pg_strncasecmp(ptr, RANGE_EMPTY_LITERAL,
182 strlen(RANGE_EMPTY_LITERAL)) == 0)
183 {
184 ranges_seen++;
185 /* nothing to do with an empty range */
186 ptr += strlen(RANGE_EMPTY_LITERAL) - 1;
187 parse_state = MULTIRANGE_AFTER_RANGE;
188 }
189 else
190 ereturn(escontext, (Datum) 0,
191 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
192 errmsg("malformed multirange literal: \"%s\"",
193 input_str),
194 errdetail("Expected range start.")));
195 break;
196 case MULTIRANGE_IN_RANGE:
197 if (ch == ']' || ch == ')')
198 {
199 range_str_len = ptr - range_str_begin + 1;
200 range_str = pnstrdup(range_str_begin, range_str_len);
201 if (range_capacity == range_count)
202 {
203 range_capacity *= 2;
204 ranges = (RangeType **)
205 repalloc(ranges, range_capacity * sizeof(RangeType *));
206 }
207 ranges_seen++;
208 if (!InputFunctionCallSafe(&cache->typioproc,
209 range_str,
210 cache->typioparam,
211 typmod,
212 escontext,
213 &range_datum))
214 PG_RETURN_NULL();
215 range = DatumGetRangeTypeP(range_datum);
216 if (!RangeIsEmpty(range))
217 ranges[range_count++] = range;
218 parse_state = MULTIRANGE_AFTER_RANGE;
219 }
220 else
221 {
222 if (ch == '"')
223 parse_state = MULTIRANGE_IN_RANGE_QUOTED;
224 else if (ch == '\\')
225 parse_state = MULTIRANGE_IN_RANGE_ESCAPED;
226
227 /*
228 * We will include this character into range_str once we
229 * find the end of the range value.
230 */
231 }
232 break;
233 case MULTIRANGE_IN_RANGE_ESCAPED:
234
235 /*
236 * We will include this character into range_str once we find
237 * the end of the range value.
238 */
239 parse_state = MULTIRANGE_IN_RANGE;
240 break;
241 case MULTIRANGE_IN_RANGE_QUOTED:
242 if (ch == '"')
243 if (*(ptr + 1) == '"')
244 {
245 /* two quote marks means an escaped quote mark */
246 ptr++;
247 }
248 else
249 parse_state = MULTIRANGE_IN_RANGE;
250 else if (ch == '\\')
251 parse_state = MULTIRANGE_IN_RANGE_QUOTED_ESCAPED;
252
253 /*
254 * We will include this character into range_str once we find
255 * the end of the range value.
256 */
257 break;
258 case MULTIRANGE_AFTER_RANGE:
259 if (ch == ',')
260 parse_state = MULTIRANGE_BEFORE_RANGE;
261 else if (ch == '}')
262 parse_state = MULTIRANGE_FINISHED;
263 else
264 ereturn(escontext, (Datum) 0,
265 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
266 errmsg("malformed multirange literal: \"%s\"",
267 input_str),
268 errdetail("Expected comma or end of multirange.")));
269 break;
270 case MULTIRANGE_IN_RANGE_QUOTED_ESCAPED:
271
272 /*
273 * We will include this character into range_str once we find
274 * the end of the range value.
275 */
276 parse_state = MULTIRANGE_IN_RANGE_QUOTED;
277 break;
278 default:
279 elog(ERROR, "unknown parse state: %d", parse_state);
280 }
281 }
282
283 /* consume whitespace */
284 while (*ptr != '\0' && isspace((unsigned char) *ptr))
285 ptr++;
286
287 if (*ptr != '\0')
288 ereturn(escontext, (Datum) 0,
289 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
290 errmsg("malformed multirange literal: \"%s\"",
291 input_str),
292 errdetail("Junk after closing right brace.")));
293
294 ret = make_multirange(mltrngtypoid, rangetyp, range_count, ranges);
295 PG_RETURN_MULTIRANGE_P(ret);
296}

References DatumGetRangeTypeP(), elog, ereturn, errcode(), errdetail(), errmsg, ERROR, fb(), 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_array, 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 1307 of file multirangetypes.c.

1308{
1309 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
1310 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
1311 Oid mltrngtypoid = MultirangeTypeGetOid(mr1);
1312 TypeCacheEntry *typcache;
1313 TypeCacheEntry *rangetyp;
1314 int32 range_count1;
1315 int32 range_count2;
1316 RangeType **ranges1;
1317 RangeType **ranges2;
1318
1319 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
1320 rangetyp = typcache->rngtype;
1321
1322 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
1323 PG_RETURN_MULTIRANGE_P(make_empty_multirange(mltrngtypoid, rangetyp));
1324
1325 multirange_deserialize(rangetyp, mr1, &range_count1, &ranges1);
1326 multirange_deserialize(rangetyp, mr2, &range_count2, &ranges2);
1327
1328 PG_RETURN_MULTIRANGE_P(multirange_intersect_internal(mltrngtypoid,
1329 rangetyp,
1330 range_count1,
1331 ranges1,
1332 range_count2,
1333 ranges2));
1334}

References fb(), 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 1542 of file multirangetypes.c.

1543{
1544 MemoryContext aggContext;
1545 Oid mltrngtypoid;
1546 TypeCacheEntry *typcache;
1547 MultirangeType *result;
1548 MultirangeType *current;
1549 int32 range_count1;
1550 int32 range_count2;
1551 RangeType **ranges1;
1552 RangeType **ranges2;
1553
1554 if (!AggCheckCallContext(fcinfo, &aggContext))
1555 elog(ERROR, "multirange_intersect_agg_transfn called in non-aggregate context");
1556
1557 mltrngtypoid = get_fn_expr_argtype(fcinfo->flinfo, 1);
1558 if (!type_is_multirange(mltrngtypoid))
1559 elog(ERROR, "range_intersect_agg must be called with a multirange");
1560
1561 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
1562
1563 /* strictness ensures these are non-null */
1564 result = PG_GETARG_MULTIRANGE_P(0);
1565 current = PG_GETARG_MULTIRANGE_P(1);
1566
1567 multirange_deserialize(typcache->rngtype, result, &range_count1, &ranges1);
1568 multirange_deserialize(typcache->rngtype, current, &range_count2, &ranges2);
1569
1570 result = multirange_intersect_internal(mltrngtypoid,
1571 typcache->rngtype,
1572 range_count1,
1573 ranges1,
1574 range_count2,
1575 ranges2);
1576 PG_RETURN_MULTIRANGE_P(result);
1577}

References AggCheckCallContext(), elog, ERROR, fb(), get_fn_expr_argtype(), multirange_deserialize(), multirange_get_typcache(), multirange_intersect_internal(), PG_GETARG_MULTIRANGE_P, PG_RETURN_MULTIRANGE_P, result, 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 1337 of file multirangetypes.c.

1340{
1341 RangeType *r1;
1342 RangeType *r2;
1343 RangeType **ranges3;
1344 int32 range_count3;
1345 int32 i1;
1346 int32 i2;
1347
1348 if (range_count1 == 0 || range_count2 == 0)
1349 return make_multirange(mltrngtypoid, rangetyp, 0, NULL);
1350
1351 /*-----------------------------------------------
1352 * Worst case is a stitching pattern like this:
1353 *
1354 * mr1: --- --- --- ---
1355 * mr2: --- --- ---
1356 * mr3: - - - - - -
1357 *
1358 * That seems to be range_count1 + range_count2 - 1,
1359 * but one extra won't hurt.
1360 *-----------------------------------------------
1361 */
1362 ranges3 = palloc0((range_count1 + range_count2) * sizeof(RangeType *));
1363 range_count3 = 0;
1364
1365 /*
1366 * For each range in mr1, keep intersecting until the ranges in mr2 have
1367 * passed it. The parallel progress through mr1 and mr2 is similar to
1368 * multirange_minus_multirange_internal, but we don't have to assign back
1369 * to r1.
1370 */
1371 r2 = ranges2[0];
1372 for (i1 = 0, i2 = 0; i1 < range_count1; i1++)
1373 {
1374 r1 = ranges1[i1];
1375
1376 /* Discard r2s while r2 << r1 */
1377 while (r2 != NULL && range_before_internal(rangetyp, r2, r1))
1378 {
1379 r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
1380 }
1381
1382 while (r2 != NULL)
1383 {
1384 if (range_overlaps_internal(rangetyp, r1, r2))
1385 {
1386 /* Keep the overlapping part */
1387 ranges3[range_count3++] = range_intersect_internal(rangetyp, r1, r2);
1388
1389 /* If we "used up" all of r2, go to the next one... */
1390 if (range_overleft_internal(rangetyp, r2, r1))
1391 r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
1392
1393 /* ...otherwise go to the next r1 */
1394 else
1395 break;
1396 }
1397 else
1398 /* We're past r1, so move to the next one */
1399 break;
1400 }
1401
1402 /* If we're out of r2s, there can be no more intersections */
1403 if (r2 == NULL)
1404 break;
1405 }
1406
1407 return make_multirange(mltrngtypoid, rangetyp, range_count3, ranges3);
1408}

References fb(), 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 2724 of file multirangetypes.c.

2725{
2726 int cmp = DatumGetInt32(multirange_cmp(fcinfo));
2727
2728 PG_RETURN_BOOL(cmp <= 0);
2729}

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

◆ multirange_lower()

Datum multirange_lower ( PG_FUNCTION_ARGS  )

Definition at line 1584 of file multirangetypes.c.

1585{
1586 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1587 TypeCacheEntry *typcache;
1588 RangeBound lower;
1589 RangeBound upper;
1590
1591 if (MultirangeIsEmpty(mr))
1592 PG_RETURN_NULL();
1593
1594 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1595
1596 multirange_get_bounds(typcache->rngtype, mr, 0,
1597 &lower, &upper);
1598
1599 if (!lower.infinite)
1600 PG_RETURN_DATUM(lower.val);
1601 else
1602 PG_RETURN_NULL();
1603}

References fb(), 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 1642 of file multirangetypes.c.

1643{
1644 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1645 TypeCacheEntry *typcache;
1646 RangeBound lower;
1647 RangeBound upper;
1648
1649 if (MultirangeIsEmpty(mr))
1650 PG_RETURN_BOOL(false);
1651
1652 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1653 multirange_get_bounds(typcache->rngtype, mr, 0,
1654 &lower, &upper);
1655
1656 PG_RETURN_BOOL(lower.inclusive);
1657}

References fb(), 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 1680 of file multirangetypes.c.

1681{
1682 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1683 TypeCacheEntry *typcache;
1684 RangeBound lower;
1685 RangeBound upper;
1686
1687 if (MultirangeIsEmpty(mr))
1688 PG_RETURN_BOOL(false);
1689
1690 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1691 multirange_get_bounds(typcache->rngtype, mr, 0,
1692 &lower, &upper);
1693
1694 PG_RETURN_BOOL(lower.infinite);
1695}

References fb(), 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 2716 of file multirangetypes.c.

2717{
2718 int cmp = DatumGetInt32(multirange_cmp(fcinfo));
2719
2720 PG_RETURN_BOOL(cmp < 0);
2721}

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

◆ multirange_minus()

Datum multirange_minus ( PG_FUNCTION_ARGS  )

Definition at line 1120 of file multirangetypes.c.

1121{
1122 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
1123 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
1124 Oid mltrngtypoid = MultirangeTypeGetOid(mr1);
1125 TypeCacheEntry *typcache;
1126 TypeCacheEntry *rangetyp;
1127 int32 range_count1;
1128 int32 range_count2;
1129 RangeType **ranges1;
1130 RangeType **ranges2;
1131
1132 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
1133 rangetyp = typcache->rngtype;
1134
1135 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
1136 PG_RETURN_MULTIRANGE_P(mr1);
1137
1138 multirange_deserialize(typcache->rngtype, mr1, &range_count1, &ranges1);
1139 multirange_deserialize(typcache->rngtype, mr2, &range_count2, &ranges2);
1140
1141 PG_RETURN_MULTIRANGE_P(multirange_minus_internal(mltrngtypoid,
1142 rangetyp,
1143 range_count1,
1144 ranges1,
1145 range_count2,
1146 ranges2));
1147}

References fb(), 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 1150 of file multirangetypes.c.

1153{
1154 RangeType *r1;
1155 RangeType *r2;
1156 RangeType **ranges3;
1157 int32 range_count3;
1158 int32 i1;
1159 int32 i2;
1160
1161 /*
1162 * Worst case: every range in ranges1 makes a different cut to some range
1163 * in ranges2.
1164 */
1165 ranges3 = palloc0((range_count1 + range_count2) * sizeof(RangeType *));
1166 range_count3 = 0;
1167
1168 /*
1169 * For each range in mr1, keep subtracting until it's gone or the ranges
1170 * in mr2 have passed it. After a subtraction we assign what's left back
1171 * to r1. The parallel progress through mr1 and mr2 is similar to
1172 * multirange_overlaps_multirange_internal.
1173 */
1174 r2 = ranges2[0];
1175 for (i1 = 0, i2 = 0; i1 < range_count1; i1++)
1176 {
1177 r1 = ranges1[i1];
1178
1179 /* Discard r2s while r2 << r1 */
1180 while (r2 != NULL && range_before_internal(rangetyp, r2, r1))
1181 {
1182 r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
1183 }
1184
1185 while (r2 != NULL)
1186 {
1187 if (range_split_internal(rangetyp, r1, r2, &ranges3[range_count3], &r1))
1188 {
1189 /*
1190 * If r2 takes a bite out of the middle of r1, we need two
1191 * outputs
1192 */
1193 range_count3++;
1194 r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
1195 }
1196 else if (range_overlaps_internal(rangetyp, r1, r2))
1197 {
1198 /*
1199 * If r2 overlaps r1, replace r1 with r1 - r2.
1200 */
1201 r1 = range_minus_internal(rangetyp, r1, r2);
1202
1203 /*
1204 * If r2 goes past r1, then we need to stay with it, in case
1205 * it hits future r1s. Otherwise we need to keep r1, in case
1206 * future r2s hit it. Since we already subtracted, there's no
1207 * point in using the overright/overleft calls.
1208 */
1209 if (RangeIsEmpty(r1) || range_before_internal(rangetyp, r1, r2))
1210 break;
1211 else
1212 r2 = ++i2 >= range_count2 ? NULL : ranges2[i2];
1213 }
1214 else
1215 {
1216 /*
1217 * This and all future r2s are past r1, so keep them. Also
1218 * assign whatever is left of r1 to the result.
1219 */
1220 break;
1221 }
1222 }
1223
1224 /*
1225 * Nothing else can remove anything from r1, so keep it. Even if r1 is
1226 * empty here, make_multirange will remove it.
1227 */
1228 ranges3[range_count3++] = r1;
1229 }
1230
1231 return make_multirange(mltrngtypoid, rangetyp, range_count3, ranges3);
1232}

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

Referenced by multirange_minus(), and multirange_minus_multi().

◆ multirange_minus_multi()

Datum multirange_minus_multi ( PG_FUNCTION_ARGS  )

Definition at line 1239 of file multirangetypes.c.

1240{
1241 FuncCallContext *funcctx;
1242 MemoryContext oldcontext;
1243
1244 if (!SRF_IS_FIRSTCALL())
1245 {
1246 /* We never have more than one result */
1247 funcctx = SRF_PERCALL_SETUP();
1248 SRF_RETURN_DONE(funcctx);
1249 }
1250 else
1251 {
1252 MultirangeType *mr1;
1253 MultirangeType *mr2;
1254 Oid mltrngtypoid;
1255 TypeCacheEntry *typcache;
1256 TypeCacheEntry *rangetyp;
1257 int32 range_count1;
1258 int32 range_count2;
1259 RangeType **ranges1;
1260 RangeType **ranges2;
1261 MultirangeType *mr;
1262
1263 funcctx = SRF_FIRSTCALL_INIT();
1264
1265 /*
1266 * switch to memory context appropriate for multiple function calls
1267 */
1268 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
1269
1270 /* get args, detoasting into multi-call memory context */
1271 mr1 = PG_GETARG_MULTIRANGE_P(0);
1272 mr2 = PG_GETARG_MULTIRANGE_P(1);
1273
1274 mltrngtypoid = MultirangeTypeGetOid(mr1);
1275 typcache = lookup_type_cache(mltrngtypoid, TYPECACHE_MULTIRANGE_INFO);
1276 if (typcache->rngtype == NULL)
1277 elog(ERROR, "type %u is not a multirange type", mltrngtypoid);
1278 rangetyp = typcache->rngtype;
1279
1280 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
1281 mr = mr1;
1282 else
1283 {
1284 multirange_deserialize(rangetyp, mr1, &range_count1, &ranges1);
1285 multirange_deserialize(rangetyp, mr2, &range_count2, &ranges2);
1286
1287 mr = multirange_minus_internal(mltrngtypoid,
1288 rangetyp,
1289 range_count1,
1290 ranges1,
1291 range_count2,
1292 ranges2);
1293 }
1294
1295 MemoryContextSwitchTo(oldcontext);
1296
1297 funcctx = SRF_PERCALL_SETUP();
1298 if (MultirangeIsEmpty(mr))
1299 SRF_RETURN_DONE(funcctx);
1300 else
1301 SRF_RETURN_NEXT(funcctx, MultirangeTypePGetDatum(mr));
1302 }
1303}

References elog, ERROR, fb(), lookup_type_cache(), MemoryContextSwitchTo(), multirange_deserialize(), multirange_minus_internal(), MultirangeIsEmpty, MultirangeTypeGetOid, MultirangeTypePGetDatum(), PG_GETARG_MULTIRANGE_P, TypeCacheEntry::rngtype, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, and TYPECACHE_MULTIRANGE_INFO.

◆ multirange_ne()

Datum multirange_ne ( PG_FUNCTION_ARGS  )

Definition at line 2000 of file multirangetypes.c.

2001{
2002 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2003 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2004 TypeCacheEntry *typcache;
2005
2006 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2007
2008 PG_RETURN_BOOL(multirange_ne_internal(typcache->rngtype, mr1, mr2));
2009}

References fb(), 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 1991 of file multirangetypes.c.

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

References fb(), and multirange_eq_internal().

Referenced by multirange_ne().

◆ multirange_out()

Datum multirange_out ( PG_FUNCTION_ARGS  )

Definition at line 299 of file multirangetypes.c.

300{
301 MultirangeType *multirange = PG_GETARG_MULTIRANGE_P(0);
302 Oid mltrngtypoid = MultirangeTypeGetOid(multirange);
303 MultirangeIOData *cache;
304 StringInfoData buf;
305 RangeType *range;
306 char *rangeStr;
307 int32 range_count;
308 int32 i;
309 RangeType **ranges;
310
311 cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_output);
312
313 initStringInfo(&buf);
314
315 appendStringInfoChar(&buf, '{');
316
317 multirange_deserialize(cache->typcache->rngtype, multirange, &range_count, &ranges);
318 for (i = 0; i < range_count; i++)
319 {
320 if (i > 0)
321 appendStringInfoChar(&buf, ',');
322 range = ranges[i];
323 rangeStr = OutputFunctionCall(&cache->typioproc, RangeTypePGetDatum(range));
324 appendStringInfoString(&buf, rangeStr);
325 }
326
327 appendStringInfoChar(&buf, '}');
328
329 PG_RETURN_CSTRING(buf.data);
330}

References appendStringInfoChar(), appendStringInfoString(), buf, fb(), 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 2037 of file multirangetypes.c.

2038{
2039 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2040 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2041 TypeCacheEntry *typcache;
2042
2043 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2044
2045 PG_RETURN_BOOL(multirange_overlaps_multirange_internal(typcache->rngtype, mr1, mr2));
2046}

References fb(), 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 2092 of file multirangetypes.c.

2095{
2096 int32 range_count1;
2097 int32 range_count2;
2098 int32 i1;
2099 int32 i2;
2100 RangeBound lower1,
2101 upper1,
2102 lower2,
2103 upper2;
2104
2105 /*
2106 * Empties never overlap, even with empties. (This seems strange since
2107 * they *do* contain each other, but we want to follow how ranges work.)
2108 */
2109 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
2110 return false;
2111
2112 range_count1 = mr1->rangeCount;
2113 range_count2 = mr2->rangeCount;
2114
2115 /*
2116 * Every range in mr1 gets a chance to overlap with the ranges in mr2, but
2117 * we can use their ordering to avoid O(n^2). This is similar to
2118 * range_overlaps_multirange where r1 : r2 :: mrr : r, but there if we
2119 * don't find an overlap with r we're done, and here if we don't find an
2120 * overlap with r2 we try the next r2.
2121 */
2122 i1 = 0;
2123 multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
2124 for (i1 = 0, i2 = 0; i2 < range_count2; i2++)
2125 {
2126 multirange_get_bounds(rangetyp, mr2, i2, &lower2, &upper2);
2127
2128 /* Discard r1s while r1 << r2 */
2129 while (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0)
2130 {
2131 if (++i1 >= range_count1)
2132 return false;
2133 multirange_get_bounds(rangetyp, mr1, i1, &lower1, &upper1);
2134 }
2135
2136 /*
2137 * If r1 && r2, we're done, otherwise we failed to find an overlap for
2138 * r2, so go to the next one.
2139 */
2140 if (range_bounds_overlaps(rangetyp, &lower1, &upper1, &lower2, &upper2))
2141 return true;
2142 }
2143
2144 /* We looked through all of mr2 without finding an overlap */
2145 return false;
2146}

References fb(), multirange_get_bounds(), MultirangeIsEmpty, range_bounds_overlaps(), and range_cmp_bounds().

Referenced by multirange_overlaps_multirange().

◆ multirange_overlaps_range()

Datum multirange_overlaps_range ( PG_FUNCTION_ARGS  )

Definition at line 2025 of file multirangetypes.c.

2026{
2027 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2028 RangeType *r = PG_GETARG_RANGE_P(1);
2029 TypeCacheEntry *typcache;
2030
2031 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2032
2033 PG_RETURN_BOOL(range_overlaps_multirange_internal(typcache->rngtype, r, mr));
2034}

References fb(), 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 2209 of file multirangetypes.c.

2210{
2211 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2212 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2213 TypeCacheEntry *typcache;
2214 RangeBound lower1,
2215 upper1,
2216 lower2,
2217 upper2;
2218
2219 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
2220 PG_RETURN_BOOL(false);
2221
2222 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2223
2224 multirange_get_bounds(typcache->rngtype, mr1, mr1->rangeCount - 1,
2225 &lower1, &upper1);
2226 multirange_get_bounds(typcache->rngtype, mr2, mr2->rangeCount - 1,
2227 &lower2, &upper2);
2228
2229 PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &upper1, &upper2) <= 0);
2230}

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

◆ multirange_overleft_range()

Datum multirange_overleft_range ( PG_FUNCTION_ARGS  )

Definition at line 2184 of file multirangetypes.c.

2185{
2186 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2187 RangeType *r = PG_GETARG_RANGE_P(1);
2188 TypeCacheEntry *typcache;
2189 RangeBound lower1,
2190 upper1,
2191 lower2,
2192 upper2;
2193 bool empty;
2194
2195 if (MultirangeIsEmpty(mr) || RangeIsEmpty(r))
2196 PG_RETURN_BOOL(false);
2197
2198 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2199
2200 multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
2201 &lower1, &upper1);
2202 range_deserialize(typcache->rngtype, r, &lower2, &upper2, &empty);
2203 Assert(!empty);
2204
2205 PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &upper1, &upper2) <= 0);
2206}

References Assert, fb(), 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_overright_multirange()

Datum multirange_overright_multirange ( PG_FUNCTION_ARGS  )

Definition at line 2291 of file multirangetypes.c.

2292{
2293 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
2294 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
2295 TypeCacheEntry *typcache;
2296 RangeBound lower1,
2297 upper1,
2298 lower2,
2299 upper2;
2300
2301 if (MultirangeIsEmpty(mr1) || MultirangeIsEmpty(mr2))
2302 PG_RETURN_BOOL(false);
2303
2304 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
2305
2306 multirange_get_bounds(typcache->rngtype, mr1, 0, &lower1, &upper1);
2307 multirange_get_bounds(typcache->rngtype, mr2, 0, &lower2, &upper2);
2308
2309 PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &lower1, &lower2) >= 0);
2310}

References fb(), 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 2267 of file multirangetypes.c.

2268{
2269 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2270 RangeType *r = PG_GETARG_RANGE_P(1);
2271 TypeCacheEntry *typcache;
2272 RangeBound lower1,
2273 upper1,
2274 lower2,
2275 upper2;
2276 bool empty;
2277
2278 if (MultirangeIsEmpty(mr) || RangeIsEmpty(r))
2279 PG_RETURN_BOOL(false);
2280
2281 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2282
2283 multirange_get_bounds(typcache->rngtype, mr, 0, &lower1, &upper1);
2284 range_deserialize(typcache->rngtype, r, &lower2, &upper2, &empty);
2285 Assert(!empty);
2286
2287 PG_RETURN_BOOL(range_cmp_bounds(typcache->rngtype, &lower1, &lower2) >= 0);
2288}

References Assert, fb(), 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 1851 of file multirangetypes.c.

1854{
1855 RangeBound *keyLower = (RangeBound *) key;
1856 RangeBound *keyUpper = (RangeBound *) key + 1;
1857
1858 /* Check if key range is strictly in the left or in the right */
1859 if (range_cmp_bounds(typcache, keyUpper, lower) < 0)
1860 return -1;
1861 if (range_cmp_bounds(typcache, keyLower, upper) > 0)
1862 return 1;
1863
1864 /*
1865 * At this point we found overlapping range. But we have to check if it
1866 * really contains the key range. Anyway, we have to stop our search
1867 * here, because multirange contains only non-overlapping ranges.
1868 */
1869 *match = range_bounds_contains(typcache, lower, upper, keyLower, keyUpper);
1870
1871 return 0;
1872}

References fb(), 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 2053 of file multirangetypes.c.

2056{
2057 RangeBound *keyLower = (RangeBound *) key;
2058 RangeBound *keyUpper = (RangeBound *) key + 1;
2059
2060 if (range_cmp_bounds(typcache, keyUpper, lower) < 0)
2061 return -1;
2062 if (range_cmp_bounds(typcache, keyLower, upper) > 0)
2063 return 1;
2064
2065 *match = true;
2066 return 0;
2067}

References fb(), 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.

338{
339 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
340 Oid mltrngtypoid = PG_GETARG_OID(1);
341 int32 typmod = PG_GETARG_INT32(2);
342 MultirangeIOData *cache;
343 int32 range_count;
344 RangeType **ranges;
345 MultirangeType *ret;
346 StringInfoData tmpbuf;
347
348 cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_receive);
349
350 range_count = pq_getmsgint(buf, 4);
351 /* palloc_array will enforce a more-or-less-sane range_count value */
352 ranges = palloc_array(RangeType *, range_count);
353
354 initStringInfo(&tmpbuf);
355 for (int i = 0; i < range_count; i++)
356 {
357 uint32 range_len = pq_getmsgint(buf, 4);
358 const char *range_data = pq_getmsgbytes(buf, range_len);
359
360 resetStringInfo(&tmpbuf);
361 appendBinaryStringInfo(&tmpbuf, range_data, range_len);
362
363 ranges[i] = DatumGetRangeTypeP(ReceiveFunctionCall(&cache->typioproc,
364 &tmpbuf,
365 cache->typioparam,
366 typmod));
367 }
368 pfree(tmpbuf.data);
369
370 pq_getmsgend(buf);
371
372 ret = make_multirange(mltrngtypoid, cache->typcache->rngtype,
373 range_count, ranges);
374 PG_RETURN_MULTIRANGE_P(ret);
375}

References appendBinaryStringInfo(), buf, StringInfoData::data, DatumGetRangeTypeP(), fb(), get_multirange_io_data(), i, initStringInfo(), IOFunc_receive, make_multirange(), palloc_array, 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 378 of file multirangetypes.c.

379{
380 MultirangeType *multirange = PG_GETARG_MULTIRANGE_P(0);
381 Oid mltrngtypoid = MultirangeTypeGetOid(multirange);
382 StringInfoData buf;
383 RangeType **ranges;
384 int32 range_count;
385 MultirangeIOData *cache;
386
387 initStringInfo(&buf);
388 cache = get_multirange_io_data(fcinfo, mltrngtypoid, IOFunc_send);
389
390 /* construct output */
391 pq_begintypsend(&buf);
392
393 pq_sendint32(&buf, multirange->rangeCount);
394
395 multirange_deserialize(cache->typcache->rngtype, multirange, &range_count, &ranges);
396 for (int i = 0; i < range_count; i++)
397 {
398 Datum range;
399 bytea *outputbytes;
400
401 range = RangeTypePGetDatum(ranges[i]);
402 outputbytes = SendFunctionCall(&cache->typioproc, range);
403
404 pq_sendint32(&buf, VARSIZE(outputbytes) - VARHDRSZ);
405 pq_sendbytes(&buf, VARDATA(outputbytes), VARSIZE(outputbytes) - VARHDRSZ);
406 }
407
408 PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
409}

References buf, fb(), get_multirange_io_data(), i, initStringInfo(), IOFunc_send, multirange_deserialize(), MultirangeTypeGetOid, PG_GETARG_MULTIRANGE_P, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendbytes(), pq_sendint32(), range(), 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 573 of file multirangetypes.c.

575{
576 char elemalign = rangetyp->rngelemtype->typalign;
577 uint8 elemalignby = typalign_to_alignby(elemalign);
578 Size size;
579 int32 i;
580
581 /*
582 * Count space for MultirangeType struct, items and flags.
583 */
584 size = att_nominal_alignby(sizeof(MultirangeType) +
585 Max(range_count - 1, 0) * sizeof(uint32) +
586 range_count * sizeof(uint8), elemalignby);
587
588 /* Count space for range bounds */
589 for (i = 0; i < range_count; i++)
590 size += att_nominal_alignby(VARSIZE(ranges[i]) -
591 sizeof(RangeType) -
592 sizeof(char), elemalignby);
593
594 return size;
595}

References att_nominal_alignby, fb(), i, Max, TypeCacheEntry::rngelemtype, TypeCacheEntry::typalign, typalign_to_alignby(), and VARSIZE().

Referenced by make_multirange().

◆ multirange_union()

Datum multirange_union ( PG_FUNCTION_ARGS  )

Definition at line 1088 of file multirangetypes.c.

1089{
1090 MultirangeType *mr1 = PG_GETARG_MULTIRANGE_P(0);
1091 MultirangeType *mr2 = PG_GETARG_MULTIRANGE_P(1);
1092 TypeCacheEntry *typcache;
1093 int32 range_count1;
1094 int32 range_count2;
1095 int32 range_count3;
1096 RangeType **ranges1;
1097 RangeType **ranges2;
1098 RangeType **ranges3;
1099
1100 if (MultirangeIsEmpty(mr1))
1101 PG_RETURN_MULTIRANGE_P(mr2);
1102 if (MultirangeIsEmpty(mr2))
1103 PG_RETURN_MULTIRANGE_P(mr1);
1104
1105 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr1));
1106
1107 multirange_deserialize(typcache->rngtype, mr1, &range_count1, &ranges1);
1108 multirange_deserialize(typcache->rngtype, mr2, &range_count2, &ranges2);
1109
1110 range_count3 = range_count1 + range_count2;
1111 ranges3 = palloc0(range_count3 * sizeof(RangeType *));
1112 memcpy(ranges3, ranges1, range_count1 * sizeof(RangeType *));
1113 memcpy(ranges3 + range_count1, ranges2, range_count2 * sizeof(RangeType *));
1114 PG_RETURN_MULTIRANGE_P(make_multirange(typcache->type_id, typcache->rngtype,
1115 range_count3, ranges3));
1116}

References fb(), make_multirange(), memcpy(), 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 2789 of file multirangetypes.c.

2790{
2791 typedef struct
2792 {
2793 MultirangeType *mr;
2794 TypeCacheEntry *typcache;
2795 int index;
2796 } multirange_unnest_fctx;
2797
2798 FuncCallContext *funcctx;
2799 multirange_unnest_fctx *fctx;
2800 MemoryContext oldcontext;
2801
2802 /* stuff done only on the first call of the function */
2803 if (SRF_IS_FIRSTCALL())
2804 {
2805 MultirangeType *mr;
2806
2807 /* create a function context for cross-call persistence */
2808 funcctx = SRF_FIRSTCALL_INIT();
2809
2810 /*
2811 * switch to memory context appropriate for multiple function calls
2812 */
2813 oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
2814
2815 /*
2816 * Get the multirange value and detoast if needed. We can't do this
2817 * earlier because if we have to detoast, we want the detoasted copy
2818 * to be in multi_call_memory_ctx, so it will go away when we're done
2819 * and not before. (If no detoast happens, we assume the originally
2820 * passed multirange will stick around till then.)
2821 */
2822 mr = PG_GETARG_MULTIRANGE_P(0);
2823
2824 /* allocate memory for user context */
2825 fctx = palloc_object(multirange_unnest_fctx);
2826
2827 /* initialize state */
2828 fctx->mr = mr;
2829 fctx->index = 0;
2830 fctx->typcache = lookup_type_cache(MultirangeTypeGetOid(mr),
2831 TYPECACHE_MULTIRANGE_INFO);
2832
2833 funcctx->user_fctx = fctx;
2834 MemoryContextSwitchTo(oldcontext);
2835 }
2836
2837 /* stuff done on every call of the function */
2838 funcctx = SRF_PERCALL_SETUP();
2839 fctx = funcctx->user_fctx;
2840
2841 if (fctx->index < fctx->mr->rangeCount)
2842 {
2843 RangeType *range;
2844
2845 range = multirange_get_range(fctx->typcache->rngtype,
2846 fctx->mr,
2847 fctx->index);
2848 fctx->index++;
2849
2850 SRF_RETURN_NEXT(funcctx, RangeTypePGetDatum(range));
2851 }
2852 else
2853 {
2854 /* do when there is no more left */
2855 SRF_RETURN_DONE(funcctx);
2856 }
2857}

References fb(), lookup_type_cache(), MemoryContextSwitchTo(), multirange_get_range(), MultirangeTypeGetOid, palloc_object, PG_GETARG_MULTIRANGE_P, range(), RangeTypePGetDatum(), SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, and TYPECACHE_MULTIRANGE_INFO.

◆ multirange_upper()

Datum multirange_upper ( PG_FUNCTION_ARGS  )

Definition at line 1607 of file multirangetypes.c.

1608{
1609 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1610 TypeCacheEntry *typcache;
1611 RangeBound lower;
1612 RangeBound upper;
1613
1614 if (MultirangeIsEmpty(mr))
1615 PG_RETURN_NULL();
1616
1617 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1618
1619 multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
1620 &lower, &upper);
1621
1622 if (!upper.infinite)
1623 PG_RETURN_DATUM(upper.val);
1624 else
1625 PG_RETURN_NULL();
1626}

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

◆ multirange_upper_inc()

Datum multirange_upper_inc ( PG_FUNCTION_ARGS  )

Definition at line 1661 of file multirangetypes.c.

1662{
1663 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1664 TypeCacheEntry *typcache;
1665 RangeBound lower;
1666 RangeBound upper;
1667
1668 if (MultirangeIsEmpty(mr))
1669 PG_RETURN_BOOL(false);
1670
1671 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1672 multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
1673 &lower, &upper);
1674
1675 PG_RETURN_BOOL(upper.inclusive);
1676}

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

◆ multirange_upper_inf()

Datum multirange_upper_inf ( PG_FUNCTION_ARGS  )

Definition at line 1699 of file multirangetypes.c.

1700{
1701 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
1702 TypeCacheEntry *typcache;
1703 RangeBound lower;
1704 RangeBound upper;
1705
1706 if (MultirangeIsEmpty(mr))
1707 PG_RETURN_BOOL(false);
1708
1709 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1710 multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
1711 &lower, &upper);
1712
1713 PG_RETURN_BOOL(upper.infinite);
1714}

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

◆ range_adjacent_multirange()

Datum range_adjacent_multirange ( PG_FUNCTION_ARGS  )

Definition at line 2583 of file multirangetypes.c.

2584{
2585 RangeType *r = PG_GETARG_RANGE_P(0);
2586 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2587 TypeCacheEntry *typcache;
2588
2589 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2590
2591 PG_RETURN_BOOL(range_adjacent_multirange_internal(typcache->rngtype, r, mr));
2592}

References fb(), 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 2547 of file multirangetypes.c.

2550{
2551 RangeBound lower1,
2552 upper1,
2553 lower2,
2554 upper2;
2555 bool empty;
2556 int32 range_count;
2557
2558 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2559 return false;
2560
2561 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
2562 Assert(!empty);
2563
2564 range_count = mr->rangeCount;
2565 multirange_get_bounds(rangetyp, mr, 0,
2566 &lower2, &upper2);
2567
2568 if (bounds_adjacent(rangetyp, upper1, lower2))
2569 return true;
2570
2571 if (range_count > 1)
2572 multirange_get_bounds(rangetyp, mr, range_count - 1,
2573 &lower2, &upper2);
2574
2575 if (bounds_adjacent(rangetyp, upper2, lower1))
2576 return true;
2577
2578 return false;
2579}

References Assert, bounds_adjacent(), fb(), multirange_get_bounds(), MultirangeIsEmpty, range_deserialize(), 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 2441 of file multirangetypes.c.

2442{
2443 RangeType *r = PG_GETARG_RANGE_P(0);
2444 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2445 TypeCacheEntry *typcache;
2446
2447 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2448
2449 PG_RETURN_BOOL(range_after_multirange_internal(typcache->rngtype, r, mr));
2450}

References fb(), 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 2522 of file multirangetypes.c.

2525{
2526 RangeBound lower1,
2527 upper1,
2528 lower2,
2529 upper2;
2530 bool empty;
2531 int32 range_count;
2532
2533 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2534 return false;
2535
2536 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
2537 Assert(!empty);
2538
2539 range_count = mr->rangeCount;
2540 multirange_get_bounds(rangetyp, mr, range_count - 1,
2541 &lower2, &upper2);
2542
2543 return (range_cmp_bounds(rangetyp, &lower1, &upper2) > 0);
2544}

References Assert, fb(), multirange_get_bounds(), MultirangeIsEmpty, range_cmp_bounds(), range_deserialize(), 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 1449 of file multirangetypes.c.

1450{
1451 MemoryContext aggContext;
1452 Oid mltrngtypoid;
1453 TypeCacheEntry *typcache;
1454 ArrayBuildState *state;
1455 int32 range_count;
1456 RangeType **ranges;
1457 int i;
1458
1459 if (!AggCheckCallContext(fcinfo, &aggContext))
1460 elog(ERROR, "range_agg_finalfn called in non-aggregate context");
1461
1462 state = PG_ARGISNULL(0) ? NULL : (ArrayBuildState *) PG_GETARG_POINTER(0);
1463 if (state == NULL)
1464 /* This shouldn't be possible, but just in case.... */
1465 PG_RETURN_NULL();
1466
1467 /* Also return NULL if we had zero inputs, like other aggregates */
1468 range_count = state->nelems;
1469 if (range_count == 0)
1470 PG_RETURN_NULL();
1471
1472 mltrngtypoid = get_fn_expr_rettype(fcinfo->flinfo);
1473 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
1474
1475 ranges = palloc0(range_count * sizeof(RangeType *));
1476 for (i = 0; i < range_count; i++)
1477 ranges[i] = DatumGetRangeTypeP(state->dvalues[i]);
1478
1479 PG_RETURN_MULTIRANGE_P(make_multirange(mltrngtypoid, typcache->rngtype, range_count, ranges));
1480}

References AggCheckCallContext(), DatumGetRangeTypeP(), elog, ERROR, fb(), 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 1417 of file multirangetypes.c.

1418{
1419 MemoryContext aggContext;
1420 Oid rngtypoid;
1421 ArrayBuildState *state;
1422
1423 if (!AggCheckCallContext(fcinfo, &aggContext))
1424 elog(ERROR, "range_agg_transfn called in non-aggregate context");
1425
1426 rngtypoid = get_fn_expr_argtype(fcinfo->flinfo, 1);
1427 if (!type_is_range(rngtypoid))
1428 elog(ERROR, "range_agg must be called with a range");
1429
1430 if (PG_ARGISNULL(0))
1431 state = initArrayResult(rngtypoid, aggContext, false);
1432 else
1433 state = (ArrayBuildState *) PG_GETARG_POINTER(0);
1434
1435 /* skip NULLs */
1436 if (!PG_ARGISNULL(1))
1437 accumArrayResult(state, PG_GETARG_DATUM(1), false, rngtypoid, aggContext);
1438
1439 PG_RETURN_POINTER(state);
1440}

References accumArrayResult(), AggCheckCallContext(), elog, ERROR, fb(), 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 2404 of file multirangetypes.c.

2405{
2406 RangeType *r = PG_GETARG_RANGE_P(0);
2407 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2408 TypeCacheEntry *typcache;
2409
2410 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2411
2412 PG_RETURN_BOOL(range_before_multirange_internal(typcache->rngtype, r, mr));
2413}

References fb(), 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 2478 of file multirangetypes.c.

2481{
2482 RangeBound lower1,
2483 upper1,
2484 lower2,
2485 upper2;
2486 bool empty;
2487
2488 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2489 return false;
2490
2491 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
2492 Assert(!empty);
2493
2494 multirange_get_bounds(rangetyp, mr, 0, &lower2, &upper2);
2495
2496 return (range_cmp_bounds(rangetyp, &upper1, &lower2) < 0);
2497}

References Assert, fb(), 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 884 of file multirangetypes.c.

887{
888 if (range_cmp_bounds(typcache, lower1, lower2) <= 0 &&
889 range_cmp_bounds(typcache, upper1, upper2) >= 0)
890 return true;
891
892 return false;
893}

References fb(), and 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 864 of file multirangetypes.c.

867{
868 if (range_cmp_bounds(typcache, lower1, lower2) >= 0 &&
869 range_cmp_bounds(typcache, lower1, upper2) <= 0)
870 return true;
871
872 if (range_cmp_bounds(typcache, lower2, lower1) >= 0 &&
873 range_cmp_bounds(typcache, lower2, upper1) <= 0)
874 return true;
875
876 return false;
877}

References fb(), and range_cmp_bounds().

Referenced by multirange_overlaps_multirange_internal().

◆ range_contained_by_multirange()

Datum range_contained_by_multirange ( PG_FUNCTION_ARGS  )

Definition at line 1823 of file multirangetypes.c.

1824{
1825 RangeType *r = PG_GETARG_RANGE_P(0);
1826 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
1827 TypeCacheEntry *typcache;
1828
1829 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1830
1831 PG_RETURN_BOOL(multirange_contains_range_internal(typcache->rngtype, mr, r));
1832}

References fb(), 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 1810 of file multirangetypes.c.

1811{
1812 RangeType *r = PG_GETARG_RANGE_P(0);
1813 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
1814 TypeCacheEntry *typcache;
1815
1816 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
1817
1818 PG_RETURN_BOOL(range_contains_multirange_internal(typcache->rngtype, r, mr));
1819}

References fb(), 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 1906 of file multirangetypes.c.

1909{
1910 RangeBound lower1,
1911 upper1,
1912 lower2,
1913 upper2,
1914 tmp;
1915 bool empty;
1916
1917 /*
1918 * Every range contains an infinite number of empty multiranges, even an
1919 * empty one.
1920 */
1921 if (MultirangeIsEmpty(mr))
1922 return true;
1923
1924 if (RangeIsEmpty(r))
1925 return false;
1926
1927 /* Range contains multirange iff it contains its union range. */
1928 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
1929 Assert(!empty);
1930 multirange_get_bounds(rangetyp, mr, 0, &lower2, &tmp);
1931 multirange_get_bounds(rangetyp, mr, mr->rangeCount - 1, &tmp, &upper2);
1932
1933 return range_bounds_contains(rangetyp, &lower1, &upper1, &lower2, &upper2);
1934}

References Assert, fb(), multirange_get_bounds(), MultirangeIsEmpty, range_bounds_contains(), range_deserialize(), 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 2751 of file multirangetypes.c.

2752{
2753 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(0);
2754 Oid mltrngtypoid = MultirangeTypeGetOid(mr);
2755 TypeCacheEntry *typcache;
2756 RangeType *result;
2757
2758 typcache = multirange_get_typcache(fcinfo, mltrngtypoid);
2759
2760 if (MultirangeIsEmpty(mr))
2761 {
2762 result = make_empty_range(typcache->rngtype);
2763 }
2764 else if (mr->rangeCount == 1)
2765 {
2766 result = multirange_get_range(typcache->rngtype, mr, 0);
2767 }
2768 else
2769 {
2770 RangeBound firstLower,
2771 firstUpper,
2772 lastLower,
2773 lastUpper;
2774
2775 multirange_get_bounds(typcache->rngtype, mr, 0,
2776 &firstLower, &firstUpper);
2777 multirange_get_bounds(typcache->rngtype, mr, mr->rangeCount - 1,
2778 &lastLower, &lastUpper);
2779
2780 result = make_range(typcache->rngtype, &firstLower, &lastUpper,
2781 false, NULL);
2782 }
2783
2784 PG_RETURN_RANGE_P(result);
2785}

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

◆ range_overlaps_multirange()

Datum range_overlaps_multirange ( PG_FUNCTION_ARGS  )

Definition at line 2013 of file multirangetypes.c.

2014{
2015 RangeType *r = PG_GETARG_RANGE_P(0);
2016 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2017 TypeCacheEntry *typcache;
2018
2019 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2020
2021 PG_RETURN_BOOL(range_overlaps_multirange_internal(typcache->rngtype, r, mr));
2022}

References fb(), 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 2070 of file multirangetypes.c.

2073{
2074 RangeBound bounds[2];
2075 bool empty;
2076
2077 /*
2078 * Empties never overlap, even with empties. (This seems strange since
2079 * they *do* contain each other, but we want to follow how ranges work.)
2080 */
2081 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2082 return false;
2083
2084 range_deserialize(rangetyp, r, &bounds[0], &bounds[1], &empty);
2085 Assert(!empty);
2086
2087 return multirange_bsearch_match(rangetyp, mr, bounds,
2088 multirange_range_overlaps_bsearch_comparison);
2089}

References Assert, fb(), 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 2172 of file multirangetypes.c.

2173{
2174 RangeType *r = PG_GETARG_RANGE_P(0);
2175 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2176 TypeCacheEntry *typcache;
2177
2178 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2179
2180 PG_RETURN_BOOL(range_overleft_multirange_internal(typcache->rngtype, r, mr));
2181}

References fb(), 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 2150 of file multirangetypes.c.

2153{
2154 RangeBound lower1,
2155 upper1,
2156 lower2,
2157 upper2;
2158 bool empty;
2159
2160 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2161 return false;
2162
2163 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
2164 Assert(!empty);
2165 multirange_get_bounds(rangetyp, mr, mr->rangeCount - 1,
2166 &lower2, &upper2);
2167
2168 return (range_cmp_bounds(rangetyp, &upper1, &upper2) <= 0);
2169}

References Assert, fb(), 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_overleft_multirange().

◆ range_overright_multirange()

Datum range_overright_multirange ( PG_FUNCTION_ARGS  )

Definition at line 2255 of file multirangetypes.c.

2256{
2257 RangeType *r = PG_GETARG_RANGE_P(0);
2258 MultirangeType *mr = PG_GETARG_MULTIRANGE_P(1);
2259 TypeCacheEntry *typcache;
2260
2261 typcache = multirange_get_typcache(fcinfo, MultirangeTypeGetOid(mr));
2262
2263 PG_RETURN_BOOL(range_overright_multirange_internal(typcache->rngtype, r, mr));
2264}

References fb(), 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 2234 of file multirangetypes.c.

2237{
2238 RangeBound lower1,
2239 upper1,
2240 lower2,
2241 upper2;
2242 bool empty;
2243
2244 if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
2245 return false;
2246
2247 range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
2248 Assert(!empty);
2249 multirange_get_bounds(rangetyp, mr, 0, &lower2, &upper2);
2250
2251 return (range_cmp_bounds(rangetyp, &lower1, &lower2) >= 0);
2252}

References Assert, fb(), 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 601 of file multirangetypes.c.

603{
604 uint32 *items;
605 uint32 prev_offset = 0;
606 uint8 *flags;
607 int32 i;
608 const char *begin;
609 char *ptr;
610 char elemalign = rangetyp->rngelemtype->typalign;
611 uint8 elemalignby = typalign_to_alignby(elemalign);
612
613 items = MultirangeGetItemsPtr(multirange);
614 flags = MultirangeGetFlagsPtr(multirange);
615 begin = ptr = MultirangeGetBoundariesPtr(multirange, elemalign);
616 for (i = 0; i < range_count; i++)
617 {
618 uint32 len;
619
620 if (i > 0)
621 {
622 /*
623 * Every range, except the first one, has an item. Every
624 * MULTIRANGE_ITEM_OFFSET_STRIDE item contains an offset, others
625 * contain lengths.
626 */
627 items[i - 1] = ptr - begin;
628 if ((i % MULTIRANGE_ITEM_OFFSET_STRIDE) != 0)
629 items[i - 1] -= prev_offset;
630 else
631 items[i - 1] |= MULTIRANGE_ITEM_OFF_BIT;
632 prev_offset = ptr - begin;
633 }
634 flags[i] = *((char *) ranges[i] + VARSIZE(ranges[i]) - sizeof(char));
635 len = VARSIZE(ranges[i]) - sizeof(RangeType) - sizeof(char);
636 memcpy(ptr, ranges[i] + 1, len);
637 ptr += att_nominal_alignby(len, elemalignby);
638 }
639}

References att_nominal_alignby, fb(), i, items, len, memcpy(), MULTIRANGE_ITEM_OFF_BIT, MULTIRANGE_ITEM_OFFSET_STRIDE, MultirangeGetBoundariesPtr, MultirangeGetFlagsPtr, MultirangeGetItemsPtr, typalign_to_alignby(), and VARSIZE().

Referenced by make_multirange().