1 /*-------------------------------------------------------------------------
2 *
3 * rangetypes.c
4 * I/O functions, operators, and support functions for range types.
5 *
6 * The stored (serialized) format of a range value is:
7 *
8 * 4 bytes: varlena header
9 * 4 bytes: range type's OID
10 * Lower boundary value, if any, aligned according to subtype's typalign
11 * Upper boundary value, if any, aligned according to subtype's typalign
12 * 1 byte for flags
13 *
14 * This representation is chosen to avoid needing any padding before the
15 * lower boundary value, even when it requires double alignment. We can
16 * expect that the varlena header is presented to us on a suitably aligned
17 * boundary (possibly after detoasting), and then the lower boundary is too.
18 * Note that this means we can't work with a packed (short varlena header)
19 * value; we must detoast it first.
20 *
21 *
22 * Portions Copyright (c) 1996-2017, PostgreSQL Global Development Group
23 * Portions Copyright (c) 1994, Regents of the University of California
24 *
25 *
26 * IDENTIFICATION
27 * src/backend/utils/adt/rangetypes.c
28 *
29 *-------------------------------------------------------------------------
30 */
31 #include "postgres.h"
32
33 #include "access/hash.h"
34 #include "lib/stringinfo.h"
35 #include "libpq/pqformat.h"
36 #include "miscadmin.h"
37 #include "utils/builtins.h"
38 #include "utils/date.h"
39 #include "utils/int8.h"
40 #include "utils/lsyscache.h"
41 #include "utils/rangetypes.h"
42 #include "utils/timestamp.h"
43
44
45 #define RANGE_EMPTY_LITERAL "empty"
46
47 /* fn_extra cache entry for one of the range I/O functions */
48 typedef struct RangeIOData
49 {
50 TypeCacheEntry *typcache; /* range type's typcache entry */
51 Oid typiofunc; /* element type's I/O function */
52 Oid typioparam; /* element type's I/O parameter */
53 FmgrInfo proc; /* lookup result for typiofunc */
54 } RangeIOData;
55
56
57 static RangeIOData *get_range_io_data(FunctionCallInfo fcinfo, Oid rngtypid,
58 IOFuncSelector func);
59 static char range_parse_flags(const char *flags_str);
60 static void range_parse(const char *input_str, char *flags, char **lbound_str,
61 char **ubound_str);
62 static const char *range_parse_bound(const char *string, const char *ptr,
63 char **bound_str, bool *infinite);
64 static char *range_deparse(char flags, const char *lbound_str,
65 const char *ubound_str);
66 static char *range_bound_escape(const char *value);
67 static Size datum_compute_size(Size sz, Datum datum, bool typbyval,
68 char typalign, int16 typlen, char typstorage);
69 static Pointer datum_write(Pointer ptr, Datum datum, bool typbyval,
70 char typalign, int16 typlen, char typstorage);
71
72
73 /*
74 *----------------------------------------------------------
75 * I/O FUNCTIONS
76 *----------------------------------------------------------
77 */
78
79 Datum
range_in(PG_FUNCTION_ARGS)80 range_in(PG_FUNCTION_ARGS)
81 {
82 char *input_str = PG_GETARG_CSTRING(0);
83 Oid rngtypoid = PG_GETARG_OID(1);
84 Oid typmod = PG_GETARG_INT32(2);
85 RangeType *range;
86 RangeIOData *cache;
87 char flags;
88 char *lbound_str;
89 char *ubound_str;
90 RangeBound lower;
91 RangeBound upper;
92
93 check_stack_depth(); /* recurses when subtype is a range type */
94
95 cache = get_range_io_data(fcinfo, rngtypoid, IOFunc_input);
96
97 /* parse */
98 range_parse(input_str, &flags, &lbound_str, &ubound_str);
99
100 /* call element type's input function */
101 if (RANGE_HAS_LBOUND(flags))
102 lower.val = InputFunctionCall(&cache->proc, lbound_str,
103 cache->typioparam, typmod);
104 if (RANGE_HAS_UBOUND(flags))
105 upper.val = InputFunctionCall(&cache->proc, ubound_str,
106 cache->typioparam, typmod);
107
108 lower.infinite = (flags & RANGE_LB_INF) != 0;
109 lower.inclusive = (flags & RANGE_LB_INC) != 0;
110 lower.lower = true;
111 upper.infinite = (flags & RANGE_UB_INF) != 0;
112 upper.inclusive = (flags & RANGE_UB_INC) != 0;
113 upper.lower = false;
114
115 /* serialize and canonicalize */
116 range = make_range(cache->typcache, &lower, &upper, flags & RANGE_EMPTY);
117
118 PG_RETURN_RANGE(range);
119 }
120
121 Datum
range_out(PG_FUNCTION_ARGS)122 range_out(PG_FUNCTION_ARGS)
123 {
124 RangeType *range = PG_GETARG_RANGE(0);
125 char *output_str;
126 RangeIOData *cache;
127 char flags;
128 char *lbound_str = NULL;
129 char *ubound_str = NULL;
130 RangeBound lower;
131 RangeBound upper;
132 bool empty;
133
134 check_stack_depth(); /* recurses when subtype is a range type */
135
136 cache = get_range_io_data(fcinfo, RangeTypeGetOid(range), IOFunc_output);
137
138 /* deserialize */
139 range_deserialize(cache->typcache, range, &lower, &upper, &empty);
140 flags = range_get_flags(range);
141
142 /* call element type's output function */
143 if (RANGE_HAS_LBOUND(flags))
144 lbound_str = OutputFunctionCall(&cache->proc, lower.val);
145 if (RANGE_HAS_UBOUND(flags))
146 ubound_str = OutputFunctionCall(&cache->proc, upper.val);
147
148 /* construct result string */
149 output_str = range_deparse(flags, lbound_str, ubound_str);
150
151 PG_RETURN_CSTRING(output_str);
152 }
153
154 /*
155 * Binary representation: The first byte is the flags, then the lower bound
156 * (if present), then the upper bound (if present). Each bound is represented
157 * by a 4-byte length header and the binary representation of that bound (as
158 * returned by a call to the send function for the subtype).
159 */
160
161 Datum
range_recv(PG_FUNCTION_ARGS)162 range_recv(PG_FUNCTION_ARGS)
163 {
164 StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
165 Oid rngtypoid = PG_GETARG_OID(1);
166 int32 typmod = PG_GETARG_INT32(2);
167 RangeType *range;
168 RangeIOData *cache;
169 char flags;
170 RangeBound lower;
171 RangeBound upper;
172
173 check_stack_depth(); /* recurses when subtype is a range type */
174
175 cache = get_range_io_data(fcinfo, rngtypoid, IOFunc_receive);
176
177 /* receive the flags... */
178 flags = (unsigned char) pq_getmsgbyte(buf);
179
180 /*
181 * Mask out any unsupported flags, particularly RANGE_xB_NULL which would
182 * confuse following tests. Note that range_serialize will take care of
183 * cleaning up any inconsistencies in the remaining flags.
184 */
185 flags &= (RANGE_EMPTY |
186 RANGE_LB_INC |
187 RANGE_LB_INF |
188 RANGE_UB_INC |
189 RANGE_UB_INF);
190
191 /* receive the bounds ... */
192 if (RANGE_HAS_LBOUND(flags))
193 {
194 uint32 bound_len = pq_getmsgint(buf, 4);
195 const char *bound_data = pq_getmsgbytes(buf, bound_len);
196 StringInfoData bound_buf;
197
198 initStringInfo(&bound_buf);
199 appendBinaryStringInfo(&bound_buf, bound_data, bound_len);
200
201 lower.val = ReceiveFunctionCall(&cache->proc,
202 &bound_buf,
203 cache->typioparam,
204 typmod);
205 pfree(bound_buf.data);
206 }
207 else
208 lower.val = (Datum) 0;
209
210 if (RANGE_HAS_UBOUND(flags))
211 {
212 uint32 bound_len = pq_getmsgint(buf, 4);
213 const char *bound_data = pq_getmsgbytes(buf, bound_len);
214 StringInfoData bound_buf;
215
216 initStringInfo(&bound_buf);
217 appendBinaryStringInfo(&bound_buf, bound_data, bound_len);
218
219 upper.val = ReceiveFunctionCall(&cache->proc,
220 &bound_buf,
221 cache->typioparam,
222 typmod);
223 pfree(bound_buf.data);
224 }
225 else
226 upper.val = (Datum) 0;
227
228 pq_getmsgend(buf);
229
230 /* finish constructing RangeBound representation */
231 lower.infinite = (flags & RANGE_LB_INF) != 0;
232 lower.inclusive = (flags & RANGE_LB_INC) != 0;
233 lower.lower = true;
234 upper.infinite = (flags & RANGE_UB_INF) != 0;
235 upper.inclusive = (flags & RANGE_UB_INC) != 0;
236 upper.lower = false;
237
238 /* serialize and canonicalize */
239 range = make_range(cache->typcache, &lower, &upper, flags & RANGE_EMPTY);
240
241 PG_RETURN_RANGE(range);
242 }
243
244 Datum
range_send(PG_FUNCTION_ARGS)245 range_send(PG_FUNCTION_ARGS)
246 {
247 RangeType *range = PG_GETARG_RANGE(0);
248 StringInfo buf = makeStringInfo();
249 RangeIOData *cache;
250 char flags;
251 RangeBound lower;
252 RangeBound upper;
253 bool empty;
254
255 check_stack_depth(); /* recurses when subtype is a range type */
256
257 cache = get_range_io_data(fcinfo, RangeTypeGetOid(range), IOFunc_send);
258
259 /* deserialize */
260 range_deserialize(cache->typcache, range, &lower, &upper, &empty);
261 flags = range_get_flags(range);
262
263 /* construct output */
264 pq_begintypsend(buf);
265
266 pq_sendbyte(buf, flags);
267
268 if (RANGE_HAS_LBOUND(flags))
269 {
270 Datum bound = PointerGetDatum(SendFunctionCall(&cache->proc,
271 lower.val));
272 uint32 bound_len = VARSIZE(bound) - VARHDRSZ;
273 char *bound_data = VARDATA(bound);
274
275 pq_sendint(buf, bound_len, 4);
276 pq_sendbytes(buf, bound_data, bound_len);
277 }
278
279 if (RANGE_HAS_UBOUND(flags))
280 {
281 Datum bound = PointerGetDatum(SendFunctionCall(&cache->proc,
282 upper.val));
283 uint32 bound_len = VARSIZE(bound) - VARHDRSZ;
284 char *bound_data = VARDATA(bound);
285
286 pq_sendint(buf, bound_len, 4);
287 pq_sendbytes(buf, bound_data, bound_len);
288 }
289
290 PG_RETURN_BYTEA_P(pq_endtypsend(buf));
291 }
292
293 /*
294 * get_range_io_data: get cached information needed for range type I/O
295 *
296 * The range I/O functions need a bit more cached info than other range
297 * functions, so they store a RangeIOData struct in fn_extra, not just a
298 * pointer to a type cache entry.
299 */
300 static RangeIOData *
get_range_io_data(FunctionCallInfo fcinfo,Oid rngtypid,IOFuncSelector func)301 get_range_io_data(FunctionCallInfo fcinfo, Oid rngtypid, IOFuncSelector func)
302 {
303 RangeIOData *cache = (RangeIOData *) fcinfo->flinfo->fn_extra;
304
305 if (cache == NULL || cache->typcache->type_id != rngtypid)
306 {
307 int16 typlen;
308 bool typbyval;
309 char typalign;
310 char typdelim;
311
312 cache = (RangeIOData *) MemoryContextAlloc(fcinfo->flinfo->fn_mcxt,
313 sizeof(RangeIOData));
314 cache->typcache = lookup_type_cache(rngtypid, TYPECACHE_RANGE_INFO);
315 if (cache->typcache->rngelemtype == NULL)
316 elog(ERROR, "type %u is not a range type", rngtypid);
317
318 /* get_type_io_data does more than we need, but is convenient */
319 get_type_io_data(cache->typcache->rngelemtype->type_id,
320 func,
321 &typlen,
322 &typbyval,
323 &typalign,
324 &typdelim,
325 &cache->typioparam,
326 &cache->typiofunc);
327
328 if (!OidIsValid(cache->typiofunc))
329 {
330 /* this could only happen for receive or send */
331 if (func == IOFunc_receive)
332 ereport(ERROR,
333 (errcode(ERRCODE_UNDEFINED_FUNCTION),
334 errmsg("no binary input function available for type %s",
335 format_type_be(cache->typcache->rngelemtype->type_id))));
336 else
337 ereport(ERROR,
338 (errcode(ERRCODE_UNDEFINED_FUNCTION),
339 errmsg("no binary output function available for type %s",
340 format_type_be(cache->typcache->rngelemtype->type_id))));
341 }
342 fmgr_info_cxt(cache->typiofunc, &cache->proc,
343 fcinfo->flinfo->fn_mcxt);
344
345 fcinfo->flinfo->fn_extra = (void *) cache;
346 }
347
348 return cache;
349 }
350
351
352 /*
353 *----------------------------------------------------------
354 * GENERIC FUNCTIONS
355 *----------------------------------------------------------
356 */
357
358 /* Construct standard-form range value from two arguments */
359 Datum
range_constructor2(PG_FUNCTION_ARGS)360 range_constructor2(PG_FUNCTION_ARGS)
361 {
362 Datum arg1 = PG_GETARG_DATUM(0);
363 Datum arg2 = PG_GETARG_DATUM(1);
364 Oid rngtypid = get_fn_expr_rettype(fcinfo->flinfo);
365 RangeType *range;
366 TypeCacheEntry *typcache;
367 RangeBound lower;
368 RangeBound upper;
369
370 typcache = range_get_typcache(fcinfo, rngtypid);
371
372 lower.val = PG_ARGISNULL(0) ? (Datum) 0 : arg1;
373 lower.infinite = PG_ARGISNULL(0);
374 lower.inclusive = true;
375 lower.lower = true;
376
377 upper.val = PG_ARGISNULL(1) ? (Datum) 0 : arg2;
378 upper.infinite = PG_ARGISNULL(1);
379 upper.inclusive = false;
380 upper.lower = false;
381
382 range = make_range(typcache, &lower, &upper, false);
383
384 PG_RETURN_RANGE(range);
385 }
386
387 /* Construct general range value from three arguments */
388 Datum
range_constructor3(PG_FUNCTION_ARGS)389 range_constructor3(PG_FUNCTION_ARGS)
390 {
391 Datum arg1 = PG_GETARG_DATUM(0);
392 Datum arg2 = PG_GETARG_DATUM(1);
393 Oid rngtypid = get_fn_expr_rettype(fcinfo->flinfo);
394 RangeType *range;
395 TypeCacheEntry *typcache;
396 RangeBound lower;
397 RangeBound upper;
398 char flags;
399
400 typcache = range_get_typcache(fcinfo, rngtypid);
401
402 if (PG_ARGISNULL(2))
403 ereport(ERROR,
404 (errcode(ERRCODE_DATA_EXCEPTION),
405 errmsg("range constructor flags argument must not be null")));
406
407 flags = range_parse_flags(text_to_cstring(PG_GETARG_TEXT_PP(2)));
408
409 lower.val = PG_ARGISNULL(0) ? (Datum) 0 : arg1;
410 lower.infinite = PG_ARGISNULL(0);
411 lower.inclusive = (flags & RANGE_LB_INC) != 0;
412 lower.lower = true;
413
414 upper.val = PG_ARGISNULL(1) ? (Datum) 0 : arg2;
415 upper.infinite = PG_ARGISNULL(1);
416 upper.inclusive = (flags & RANGE_UB_INC) != 0;
417 upper.lower = false;
418
419 range = make_range(typcache, &lower, &upper, false);
420
421 PG_RETURN_RANGE(range);
422 }
423
424
425 /* range -> subtype functions */
426
427 /* extract lower bound value */
428 Datum
range_lower(PG_FUNCTION_ARGS)429 range_lower(PG_FUNCTION_ARGS)
430 {
431 RangeType *r1 = PG_GETARG_RANGE(0);
432 TypeCacheEntry *typcache;
433 RangeBound lower;
434 RangeBound upper;
435 bool empty;
436
437 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
438
439 range_deserialize(typcache, r1, &lower, &upper, &empty);
440
441 /* Return NULL if there's no finite lower bound */
442 if (empty || lower.infinite)
443 PG_RETURN_NULL();
444
445 PG_RETURN_DATUM(lower.val);
446 }
447
448 /* extract upper bound value */
449 Datum
range_upper(PG_FUNCTION_ARGS)450 range_upper(PG_FUNCTION_ARGS)
451 {
452 RangeType *r1 = PG_GETARG_RANGE(0);
453 TypeCacheEntry *typcache;
454 RangeBound lower;
455 RangeBound upper;
456 bool empty;
457
458 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
459
460 range_deserialize(typcache, r1, &lower, &upper, &empty);
461
462 /* Return NULL if there's no finite upper bound */
463 if (empty || upper.infinite)
464 PG_RETURN_NULL();
465
466 PG_RETURN_DATUM(upper.val);
467 }
468
469
470 /* range -> bool functions */
471
472 /* is range empty? */
473 Datum
range_empty(PG_FUNCTION_ARGS)474 range_empty(PG_FUNCTION_ARGS)
475 {
476 RangeType *r1 = PG_GETARG_RANGE(0);
477 char flags = range_get_flags(r1);
478
479 PG_RETURN_BOOL(flags & RANGE_EMPTY);
480 }
481
482 /* is lower bound inclusive? */
483 Datum
range_lower_inc(PG_FUNCTION_ARGS)484 range_lower_inc(PG_FUNCTION_ARGS)
485 {
486 RangeType *r1 = PG_GETARG_RANGE(0);
487 char flags = range_get_flags(r1);
488
489 PG_RETURN_BOOL(flags & RANGE_LB_INC);
490 }
491
492 /* is upper bound inclusive? */
493 Datum
range_upper_inc(PG_FUNCTION_ARGS)494 range_upper_inc(PG_FUNCTION_ARGS)
495 {
496 RangeType *r1 = PG_GETARG_RANGE(0);
497 char flags = range_get_flags(r1);
498
499 PG_RETURN_BOOL(flags & RANGE_UB_INC);
500 }
501
502 /* is lower bound infinite? */
503 Datum
range_lower_inf(PG_FUNCTION_ARGS)504 range_lower_inf(PG_FUNCTION_ARGS)
505 {
506 RangeType *r1 = PG_GETARG_RANGE(0);
507 char flags = range_get_flags(r1);
508
509 PG_RETURN_BOOL(flags & RANGE_LB_INF);
510 }
511
512 /* is upper bound infinite? */
513 Datum
range_upper_inf(PG_FUNCTION_ARGS)514 range_upper_inf(PG_FUNCTION_ARGS)
515 {
516 RangeType *r1 = PG_GETARG_RANGE(0);
517 char flags = range_get_flags(r1);
518
519 PG_RETURN_BOOL(flags & RANGE_UB_INF);
520 }
521
522
523 /* range, element -> bool functions */
524
525 /* contains? */
526 Datum
range_contains_elem(PG_FUNCTION_ARGS)527 range_contains_elem(PG_FUNCTION_ARGS)
528 {
529 RangeType *r = PG_GETARG_RANGE(0);
530 Datum val = PG_GETARG_DATUM(1);
531 TypeCacheEntry *typcache;
532
533 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
534
535 PG_RETURN_BOOL(range_contains_elem_internal(typcache, r, val));
536 }
537
538 /* contained by? */
539 Datum
elem_contained_by_range(PG_FUNCTION_ARGS)540 elem_contained_by_range(PG_FUNCTION_ARGS)
541 {
542 Datum val = PG_GETARG_DATUM(0);
543 RangeType *r = PG_GETARG_RANGE(1);
544 TypeCacheEntry *typcache;
545
546 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
547
548 PG_RETURN_BOOL(range_contains_elem_internal(typcache, r, val));
549 }
550
551
552 /* range, range -> bool functions */
553
554 /* equality (internal version) */
555 bool
range_eq_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2)556 range_eq_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
557 {
558 RangeBound lower1,
559 lower2;
560 RangeBound upper1,
561 upper2;
562 bool empty1,
563 empty2;
564
565 /* Different types should be prevented by ANYRANGE matching rules */
566 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
567 elog(ERROR, "range types do not match");
568
569 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
570 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
571
572 if (empty1 && empty2)
573 return true;
574 if (empty1 != empty2)
575 return false;
576
577 if (range_cmp_bounds(typcache, &lower1, &lower2) != 0)
578 return false;
579
580 if (range_cmp_bounds(typcache, &upper1, &upper2) != 0)
581 return false;
582
583 return true;
584 }
585
586 /* equality */
587 Datum
range_eq(PG_FUNCTION_ARGS)588 range_eq(PG_FUNCTION_ARGS)
589 {
590 RangeType *r1 = PG_GETARG_RANGE(0);
591 RangeType *r2 = PG_GETARG_RANGE(1);
592 TypeCacheEntry *typcache;
593
594 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
595
596 PG_RETURN_BOOL(range_eq_internal(typcache, r1, r2));
597 }
598
599 /* inequality (internal version) */
600 bool
range_ne_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2)601 range_ne_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
602 {
603 return (!range_eq_internal(typcache, r1, r2));
604 }
605
606 /* inequality */
607 Datum
range_ne(PG_FUNCTION_ARGS)608 range_ne(PG_FUNCTION_ARGS)
609 {
610 RangeType *r1 = PG_GETARG_RANGE(0);
611 RangeType *r2 = PG_GETARG_RANGE(1);
612 TypeCacheEntry *typcache;
613
614 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
615
616 PG_RETURN_BOOL(range_ne_internal(typcache, r1, r2));
617 }
618
619 /* contains? */
620 Datum
range_contains(PG_FUNCTION_ARGS)621 range_contains(PG_FUNCTION_ARGS)
622 {
623 RangeType *r1 = PG_GETARG_RANGE(0);
624 RangeType *r2 = PG_GETARG_RANGE(1);
625 TypeCacheEntry *typcache;
626
627 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
628
629 PG_RETURN_BOOL(range_contains_internal(typcache, r1, r2));
630 }
631
632 /* contained by? */
633 Datum
range_contained_by(PG_FUNCTION_ARGS)634 range_contained_by(PG_FUNCTION_ARGS)
635 {
636 RangeType *r1 = PG_GETARG_RANGE(0);
637 RangeType *r2 = PG_GETARG_RANGE(1);
638 TypeCacheEntry *typcache;
639
640 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
641
642 PG_RETURN_BOOL(range_contained_by_internal(typcache, r1, r2));
643 }
644
645 /* strictly left of? (internal version) */
646 bool
range_before_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2)647 range_before_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
648 {
649 RangeBound lower1,
650 lower2;
651 RangeBound upper1,
652 upper2;
653 bool empty1,
654 empty2;
655
656 /* Different types should be prevented by ANYRANGE matching rules */
657 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
658 elog(ERROR, "range types do not match");
659
660 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
661 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
662
663 /* An empty range is neither before nor after any other range */
664 if (empty1 || empty2)
665 return false;
666
667 return (range_cmp_bounds(typcache, &upper1, &lower2) < 0);
668 }
669
670 /* strictly left of? */
671 Datum
range_before(PG_FUNCTION_ARGS)672 range_before(PG_FUNCTION_ARGS)
673 {
674 RangeType *r1 = PG_GETARG_RANGE(0);
675 RangeType *r2 = PG_GETARG_RANGE(1);
676 TypeCacheEntry *typcache;
677
678 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
679
680 PG_RETURN_BOOL(range_before_internal(typcache, r1, r2));
681 }
682
683 /* strictly right of? (internal version) */
684 bool
range_after_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2)685 range_after_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
686 {
687 RangeBound lower1,
688 lower2;
689 RangeBound upper1,
690 upper2;
691 bool empty1,
692 empty2;
693
694 /* Different types should be prevented by ANYRANGE matching rules */
695 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
696 elog(ERROR, "range types do not match");
697
698 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
699 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
700
701 /* An empty range is neither before nor after any other range */
702 if (empty1 || empty2)
703 return false;
704
705 return (range_cmp_bounds(typcache, &lower1, &upper2) > 0);
706 }
707
708 /* strictly right of? */
709 Datum
range_after(PG_FUNCTION_ARGS)710 range_after(PG_FUNCTION_ARGS)
711 {
712 RangeType *r1 = PG_GETARG_RANGE(0);
713 RangeType *r2 = PG_GETARG_RANGE(1);
714 TypeCacheEntry *typcache;
715
716 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
717
718 PG_RETURN_BOOL(range_after_internal(typcache, r1, r2));
719 }
720
721 /*
722 * Check if two bounds A and B are "adjacent", where A is an upper bound and B
723 * is a lower bound. For the bounds to be adjacent, each subtype value must
724 * satisfy strictly one of the bounds: there are no values which satisfy both
725 * bounds (i.e. less than A and greater than B); and there are no values which
726 * satisfy neither bound (i.e. greater than A and less than B).
727 *
728 * For discrete ranges, we rely on the canonicalization function to see if A..B
729 * normalizes to empty. (If there is no canonicalization function, it's
730 * impossible for such a range to normalize to empty, so we needn't bother to
731 * try.)
732 *
733 * If A == B, the ranges are adjacent only if the bounds have different
734 * inclusive flags (i.e., exactly one of the ranges includes the common
735 * boundary point).
736 *
737 * And if A > B then the ranges are not adjacent in this order.
738 */
739 bool
bounds_adjacent(TypeCacheEntry * typcache,RangeBound boundA,RangeBound boundB)740 bounds_adjacent(TypeCacheEntry *typcache, RangeBound boundA, RangeBound boundB)
741 {
742 int cmp;
743
744 Assert(!boundA.lower && boundB.lower);
745
746 cmp = range_cmp_bound_values(typcache, &boundA, &boundB);
747 if (cmp < 0)
748 {
749 RangeType *r;
750
751 /*
752 * Bounds do not overlap; see if there are points in between.
753 */
754
755 /* in a continuous subtype, there are assumed to be points between */
756 if (!OidIsValid(typcache->rng_canonical_finfo.fn_oid))
757 return false;
758
759 /*
760 * The bounds are of a discrete range type; so make a range A..B and
761 * see if it's empty.
762 */
763
764 /* flip the inclusion flags */
765 boundA.inclusive = !boundA.inclusive;
766 boundB.inclusive = !boundB.inclusive;
767 /* change upper/lower labels to avoid Assert failures */
768 boundA.lower = true;
769 boundB.lower = false;
770 r = make_range(typcache, &boundA, &boundB, false);
771 return RangeIsEmpty(r);
772 }
773 else if (cmp == 0)
774 return boundA.inclusive != boundB.inclusive;
775 else
776 return false; /* bounds overlap */
777 }
778
779 /* adjacent to (but not overlapping)? (internal version) */
780 bool
range_adjacent_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2)781 range_adjacent_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
782 {
783 RangeBound lower1,
784 lower2;
785 RangeBound upper1,
786 upper2;
787 bool empty1,
788 empty2;
789
790 /* Different types should be prevented by ANYRANGE matching rules */
791 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
792 elog(ERROR, "range types do not match");
793
794 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
795 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
796
797 /* An empty range is not adjacent to any other range */
798 if (empty1 || empty2)
799 return false;
800
801 /*
802 * Given two ranges A..B and C..D, the ranges are adjacent if and only if
803 * B is adjacent to C, or D is adjacent to A.
804 */
805 return (bounds_adjacent(typcache, upper1, lower2) ||
806 bounds_adjacent(typcache, upper2, lower1));
807 }
808
809 /* adjacent to (but not overlapping)? */
810 Datum
range_adjacent(PG_FUNCTION_ARGS)811 range_adjacent(PG_FUNCTION_ARGS)
812 {
813 RangeType *r1 = PG_GETARG_RANGE(0);
814 RangeType *r2 = PG_GETARG_RANGE(1);
815 TypeCacheEntry *typcache;
816
817 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
818
819 PG_RETURN_BOOL(range_adjacent_internal(typcache, r1, r2));
820 }
821
822 /* overlaps? (internal version) */
823 bool
range_overlaps_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2)824 range_overlaps_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
825 {
826 RangeBound lower1,
827 lower2;
828 RangeBound upper1,
829 upper2;
830 bool empty1,
831 empty2;
832
833 /* Different types should be prevented by ANYRANGE matching rules */
834 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
835 elog(ERROR, "range types do not match");
836
837 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
838 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
839
840 /* An empty range does not overlap any other range */
841 if (empty1 || empty2)
842 return false;
843
844 if (range_cmp_bounds(typcache, &lower1, &lower2) >= 0 &&
845 range_cmp_bounds(typcache, &lower1, &upper2) <= 0)
846 return true;
847
848 if (range_cmp_bounds(typcache, &lower2, &lower1) >= 0 &&
849 range_cmp_bounds(typcache, &lower2, &upper1) <= 0)
850 return true;
851
852 return false;
853 }
854
855 /* overlaps? */
856 Datum
range_overlaps(PG_FUNCTION_ARGS)857 range_overlaps(PG_FUNCTION_ARGS)
858 {
859 RangeType *r1 = PG_GETARG_RANGE(0);
860 RangeType *r2 = PG_GETARG_RANGE(1);
861 TypeCacheEntry *typcache;
862
863 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
864
865 PG_RETURN_BOOL(range_overlaps_internal(typcache, r1, r2));
866 }
867
868 /* does not extend to right of? (internal version) */
869 bool
range_overleft_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2)870 range_overleft_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
871 {
872 RangeBound lower1,
873 lower2;
874 RangeBound upper1,
875 upper2;
876 bool empty1,
877 empty2;
878
879 /* Different types should be prevented by ANYRANGE matching rules */
880 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
881 elog(ERROR, "range types do not match");
882
883 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
884 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
885
886 /* An empty range is neither before nor after any other range */
887 if (empty1 || empty2)
888 return false;
889
890 if (range_cmp_bounds(typcache, &upper1, &upper2) <= 0)
891 return true;
892
893 return false;
894 }
895
896 /* does not extend to right of? */
897 Datum
range_overleft(PG_FUNCTION_ARGS)898 range_overleft(PG_FUNCTION_ARGS)
899 {
900 RangeType *r1 = PG_GETARG_RANGE(0);
901 RangeType *r2 = PG_GETARG_RANGE(1);
902 TypeCacheEntry *typcache;
903
904 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
905
906 PG_RETURN_BOOL(range_overleft_internal(typcache, r1, r2));
907 }
908
909 /* does not extend to left of? (internal version) */
910 bool
range_overright_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2)911 range_overright_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
912 {
913 RangeBound lower1,
914 lower2;
915 RangeBound upper1,
916 upper2;
917 bool empty1,
918 empty2;
919
920 /* Different types should be prevented by ANYRANGE matching rules */
921 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
922 elog(ERROR, "range types do not match");
923
924 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
925 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
926
927 /* An empty range is neither before nor after any other range */
928 if (empty1 || empty2)
929 return false;
930
931 if (range_cmp_bounds(typcache, &lower1, &lower2) >= 0)
932 return true;
933
934 return false;
935 }
936
937 /* does not extend to left of? */
938 Datum
range_overright(PG_FUNCTION_ARGS)939 range_overright(PG_FUNCTION_ARGS)
940 {
941 RangeType *r1 = PG_GETARG_RANGE(0);
942 RangeType *r2 = PG_GETARG_RANGE(1);
943 TypeCacheEntry *typcache;
944
945 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
946
947 PG_RETURN_BOOL(range_overright_internal(typcache, r1, r2));
948 }
949
950
951 /* range, range -> range functions */
952
953 /* set difference */
954 Datum
range_minus(PG_FUNCTION_ARGS)955 range_minus(PG_FUNCTION_ARGS)
956 {
957 RangeType *r1 = PG_GETARG_RANGE(0);
958 RangeType *r2 = PG_GETARG_RANGE(1);
959 TypeCacheEntry *typcache;
960 RangeBound lower1,
961 lower2;
962 RangeBound upper1,
963 upper2;
964 bool empty1,
965 empty2;
966 int cmp_l1l2,
967 cmp_l1u2,
968 cmp_u1l2,
969 cmp_u1u2;
970
971 /* Different types should be prevented by ANYRANGE matching rules */
972 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
973 elog(ERROR, "range types do not match");
974
975 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
976
977 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
978 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
979
980 /* if either is empty, r1 is the correct answer */
981 if (empty1 || empty2)
982 PG_RETURN_RANGE(r1);
983
984 cmp_l1l2 = range_cmp_bounds(typcache, &lower1, &lower2);
985 cmp_l1u2 = range_cmp_bounds(typcache, &lower1, &upper2);
986 cmp_u1l2 = range_cmp_bounds(typcache, &upper1, &lower2);
987 cmp_u1u2 = range_cmp_bounds(typcache, &upper1, &upper2);
988
989 if (cmp_l1l2 < 0 && cmp_u1u2 > 0)
990 ereport(ERROR,
991 (errcode(ERRCODE_DATA_EXCEPTION),
992 errmsg("result of range difference would not be contiguous")));
993
994 if (cmp_l1u2 > 0 || cmp_u1l2 < 0)
995 PG_RETURN_RANGE(r1);
996
997 if (cmp_l1l2 >= 0 && cmp_u1u2 <= 0)
998 PG_RETURN_RANGE(make_empty_range(typcache));
999
1000 if (cmp_l1l2 <= 0 && cmp_u1l2 >= 0 && cmp_u1u2 <= 0)
1001 {
1002 lower2.inclusive = !lower2.inclusive;
1003 lower2.lower = false; /* it will become the upper bound */
1004 PG_RETURN_RANGE(make_range(typcache, &lower1, &lower2, false));
1005 }
1006
1007 if (cmp_l1l2 >= 0 && cmp_u1u2 >= 0 && cmp_l1u2 <= 0)
1008 {
1009 upper2.inclusive = !upper2.inclusive;
1010 upper2.lower = true; /* it will become the lower bound */
1011 PG_RETURN_RANGE(make_range(typcache, &upper2, &upper1, false));
1012 }
1013
1014 elog(ERROR, "unexpected case in range_minus");
1015 PG_RETURN_NULL();
1016 }
1017
1018 /*
1019 * Set union. If strict is true, it is an error that the two input ranges
1020 * are not adjacent or overlapping.
1021 */
1022 static RangeType *
range_union_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2,bool strict)1023 range_union_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2,
1024 bool strict)
1025 {
1026 RangeBound lower1,
1027 lower2;
1028 RangeBound upper1,
1029 upper2;
1030 bool empty1,
1031 empty2;
1032 RangeBound *result_lower;
1033 RangeBound *result_upper;
1034
1035 /* Different types should be prevented by ANYRANGE matching rules */
1036 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
1037 elog(ERROR, "range types do not match");
1038
1039 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
1040 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
1041
1042 /* if either is empty, the other is the correct answer */
1043 if (empty1)
1044 return r2;
1045 if (empty2)
1046 return r1;
1047
1048 if (strict &&
1049 !DatumGetBool(range_overlaps_internal(typcache, r1, r2)) &&
1050 !DatumGetBool(range_adjacent_internal(typcache, r1, r2)))
1051 ereport(ERROR,
1052 (errcode(ERRCODE_DATA_EXCEPTION),
1053 errmsg("result of range union would not be contiguous")));
1054
1055 if (range_cmp_bounds(typcache, &lower1, &lower2) < 0)
1056 result_lower = &lower1;
1057 else
1058 result_lower = &lower2;
1059
1060 if (range_cmp_bounds(typcache, &upper1, &upper2) > 0)
1061 result_upper = &upper1;
1062 else
1063 result_upper = &upper2;
1064
1065 return make_range(typcache, result_lower, result_upper, false);
1066 }
1067
1068 Datum
range_union(PG_FUNCTION_ARGS)1069 range_union(PG_FUNCTION_ARGS)
1070 {
1071 RangeType *r1 = PG_GETARG_RANGE(0);
1072 RangeType *r2 = PG_GETARG_RANGE(1);
1073 TypeCacheEntry *typcache;
1074
1075 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
1076
1077 PG_RETURN_RANGE(range_union_internal(typcache, r1, r2, true));
1078 }
1079
1080 /*
1081 * range merge: like set union, except also allow and account for non-adjacent
1082 * input ranges.
1083 */
1084 Datum
range_merge(PG_FUNCTION_ARGS)1085 range_merge(PG_FUNCTION_ARGS)
1086 {
1087 RangeType *r1 = PG_GETARG_RANGE(0);
1088 RangeType *r2 = PG_GETARG_RANGE(1);
1089 TypeCacheEntry *typcache;
1090
1091 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
1092
1093 PG_RETURN_RANGE(range_union_internal(typcache, r1, r2, false));
1094 }
1095
1096 /* set intersection */
1097 Datum
range_intersect(PG_FUNCTION_ARGS)1098 range_intersect(PG_FUNCTION_ARGS)
1099 {
1100 RangeType *r1 = PG_GETARG_RANGE(0);
1101 RangeType *r2 = PG_GETARG_RANGE(1);
1102 TypeCacheEntry *typcache;
1103 RangeBound lower1,
1104 lower2;
1105 RangeBound upper1,
1106 upper2;
1107 bool empty1,
1108 empty2;
1109 RangeBound *result_lower;
1110 RangeBound *result_upper;
1111
1112 /* Different types should be prevented by ANYRANGE matching rules */
1113 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
1114 elog(ERROR, "range types do not match");
1115
1116 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
1117
1118 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
1119 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
1120
1121 if (empty1 || empty2 || !DatumGetBool(range_overlaps(fcinfo)))
1122 PG_RETURN_RANGE(make_empty_range(typcache));
1123
1124 if (range_cmp_bounds(typcache, &lower1, &lower2) >= 0)
1125 result_lower = &lower1;
1126 else
1127 result_lower = &lower2;
1128
1129 if (range_cmp_bounds(typcache, &upper1, &upper2) <= 0)
1130 result_upper = &upper1;
1131 else
1132 result_upper = &upper2;
1133
1134 PG_RETURN_RANGE(make_range(typcache, result_lower, result_upper, false));
1135 }
1136
1137 /* Btree support */
1138
1139 /* btree comparator */
1140 Datum
range_cmp(PG_FUNCTION_ARGS)1141 range_cmp(PG_FUNCTION_ARGS)
1142 {
1143 RangeType *r1 = PG_GETARG_RANGE(0);
1144 RangeType *r2 = PG_GETARG_RANGE(1);
1145 TypeCacheEntry *typcache;
1146 RangeBound lower1,
1147 lower2;
1148 RangeBound upper1,
1149 upper2;
1150 bool empty1,
1151 empty2;
1152 int cmp;
1153
1154 check_stack_depth(); /* recurses when subtype is a range type */
1155
1156 /* Different types should be prevented by ANYRANGE matching rules */
1157 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
1158 elog(ERROR, "range types do not match");
1159
1160 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r1));
1161
1162 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
1163 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
1164
1165 /* For b-tree use, empty ranges sort before all else */
1166 if (empty1 && empty2)
1167 cmp = 0;
1168 else if (empty1)
1169 cmp = -1;
1170 else if (empty2)
1171 cmp = 1;
1172 else
1173 {
1174 cmp = range_cmp_bounds(typcache, &lower1, &lower2);
1175 if (cmp == 0)
1176 cmp = range_cmp_bounds(typcache, &upper1, &upper2);
1177 }
1178
1179 PG_FREE_IF_COPY(r1, 0);
1180 PG_FREE_IF_COPY(r2, 1);
1181
1182 PG_RETURN_INT32(cmp);
1183 }
1184
1185 /* inequality operators using the range_cmp function */
1186 Datum
range_lt(PG_FUNCTION_ARGS)1187 range_lt(PG_FUNCTION_ARGS)
1188 {
1189 int cmp = range_cmp(fcinfo);
1190
1191 PG_RETURN_BOOL(cmp < 0);
1192 }
1193
1194 Datum
range_le(PG_FUNCTION_ARGS)1195 range_le(PG_FUNCTION_ARGS)
1196 {
1197 int cmp = range_cmp(fcinfo);
1198
1199 PG_RETURN_BOOL(cmp <= 0);
1200 }
1201
1202 Datum
range_ge(PG_FUNCTION_ARGS)1203 range_ge(PG_FUNCTION_ARGS)
1204 {
1205 int cmp = range_cmp(fcinfo);
1206
1207 PG_RETURN_BOOL(cmp >= 0);
1208 }
1209
1210 Datum
range_gt(PG_FUNCTION_ARGS)1211 range_gt(PG_FUNCTION_ARGS)
1212 {
1213 int cmp = range_cmp(fcinfo);
1214
1215 PG_RETURN_BOOL(cmp > 0);
1216 }
1217
1218 /* Hash support */
1219
1220 /* hash a range value */
1221 Datum
hash_range(PG_FUNCTION_ARGS)1222 hash_range(PG_FUNCTION_ARGS)
1223 {
1224 RangeType *r = PG_GETARG_RANGE(0);
1225 uint32 result;
1226 TypeCacheEntry *typcache;
1227 TypeCacheEntry *scache;
1228 RangeBound lower;
1229 RangeBound upper;
1230 bool empty;
1231 char flags;
1232 uint32 lower_hash;
1233 uint32 upper_hash;
1234
1235 check_stack_depth(); /* recurses when subtype is a range type */
1236
1237 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
1238
1239 /* deserialize */
1240 range_deserialize(typcache, r, &lower, &upper, &empty);
1241 flags = range_get_flags(r);
1242
1243 /*
1244 * Look up the element type's hash function, if not done already.
1245 */
1246 scache = typcache->rngelemtype;
1247 if (!OidIsValid(scache->hash_proc_finfo.fn_oid))
1248 {
1249 scache = lookup_type_cache(scache->type_id, TYPECACHE_HASH_PROC_FINFO);
1250 if (!OidIsValid(scache->hash_proc_finfo.fn_oid))
1251 ereport(ERROR,
1252 (errcode(ERRCODE_UNDEFINED_FUNCTION),
1253 errmsg("could not identify a hash function for type %s",
1254 format_type_be(scache->type_id))));
1255 }
1256
1257 /*
1258 * Apply the hash function to each bound.
1259 */
1260 if (RANGE_HAS_LBOUND(flags))
1261 lower_hash = DatumGetUInt32(FunctionCall1Coll(&scache->hash_proc_finfo,
1262 typcache->rng_collation,
1263 lower.val));
1264 else
1265 lower_hash = 0;
1266
1267 if (RANGE_HAS_UBOUND(flags))
1268 upper_hash = DatumGetUInt32(FunctionCall1Coll(&scache->hash_proc_finfo,
1269 typcache->rng_collation,
1270 upper.val));
1271 else
1272 upper_hash = 0;
1273
1274 /* Merge hashes of flags and bounds */
1275 result = hash_uint32((uint32) flags);
1276 result ^= lower_hash;
1277 result = (result << 1) | (result >> 31);
1278 result ^= upper_hash;
1279
1280 PG_RETURN_INT32(result);
1281 }
1282
1283 /*
1284 *----------------------------------------------------------
1285 * CANONICAL FUNCTIONS
1286 *
1287 * Functions for specific built-in range types.
1288 *----------------------------------------------------------
1289 */
1290
1291 Datum
int4range_canonical(PG_FUNCTION_ARGS)1292 int4range_canonical(PG_FUNCTION_ARGS)
1293 {
1294 RangeType *r = PG_GETARG_RANGE(0);
1295 TypeCacheEntry *typcache;
1296 RangeBound lower;
1297 RangeBound upper;
1298 bool empty;
1299
1300 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
1301
1302 range_deserialize(typcache, r, &lower, &upper, &empty);
1303
1304 if (empty)
1305 PG_RETURN_RANGE(r);
1306
1307 if (!lower.infinite && !lower.inclusive)
1308 {
1309 lower.val = DirectFunctionCall2(int4pl, lower.val, Int32GetDatum(1));
1310 lower.inclusive = true;
1311 }
1312
1313 if (!upper.infinite && upper.inclusive)
1314 {
1315 upper.val = DirectFunctionCall2(int4pl, upper.val, Int32GetDatum(1));
1316 upper.inclusive = false;
1317 }
1318
1319 PG_RETURN_RANGE(range_serialize(typcache, &lower, &upper, false));
1320 }
1321
1322 Datum
int8range_canonical(PG_FUNCTION_ARGS)1323 int8range_canonical(PG_FUNCTION_ARGS)
1324 {
1325 RangeType *r = PG_GETARG_RANGE(0);
1326 TypeCacheEntry *typcache;
1327 RangeBound lower;
1328 RangeBound upper;
1329 bool empty;
1330
1331 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
1332
1333 range_deserialize(typcache, r, &lower, &upper, &empty);
1334
1335 if (empty)
1336 PG_RETURN_RANGE(r);
1337
1338 if (!lower.infinite && !lower.inclusive)
1339 {
1340 lower.val = DirectFunctionCall2(int8pl, lower.val, Int64GetDatum(1));
1341 lower.inclusive = true;
1342 }
1343
1344 if (!upper.infinite && upper.inclusive)
1345 {
1346 upper.val = DirectFunctionCall2(int8pl, upper.val, Int64GetDatum(1));
1347 upper.inclusive = false;
1348 }
1349
1350 PG_RETURN_RANGE(range_serialize(typcache, &lower, &upper, false));
1351 }
1352
1353 Datum
daterange_canonical(PG_FUNCTION_ARGS)1354 daterange_canonical(PG_FUNCTION_ARGS)
1355 {
1356 RangeType *r = PG_GETARG_RANGE(0);
1357 TypeCacheEntry *typcache;
1358 RangeBound lower;
1359 RangeBound upper;
1360 bool empty;
1361
1362 typcache = range_get_typcache(fcinfo, RangeTypeGetOid(r));
1363
1364 range_deserialize(typcache, r, &lower, &upper, &empty);
1365
1366 if (empty)
1367 PG_RETURN_RANGE(r);
1368
1369 if (!lower.infinite && !DATE_NOT_FINITE(DatumGetDateADT(lower.val)) &&
1370 !lower.inclusive)
1371 {
1372 lower.val = DirectFunctionCall2(date_pli, lower.val, Int32GetDatum(1));
1373 lower.inclusive = true;
1374 }
1375
1376 if (!upper.infinite && !DATE_NOT_FINITE(DatumGetDateADT(upper.val)) &&
1377 upper.inclusive)
1378 {
1379 upper.val = DirectFunctionCall2(date_pli, upper.val, Int32GetDatum(1));
1380 upper.inclusive = false;
1381 }
1382
1383 PG_RETURN_RANGE(range_serialize(typcache, &lower, &upper, false));
1384 }
1385
1386 /*
1387 *----------------------------------------------------------
1388 * SUBTYPE_DIFF FUNCTIONS
1389 *
1390 * Functions for specific built-in range types.
1391 *
1392 * Note that subtype_diff does return the difference, not the absolute value
1393 * of the difference, and it must take care to avoid overflow.
1394 * (numrange_subdiff is at some risk there ...)
1395 *----------------------------------------------------------
1396 */
1397
1398 Datum
int4range_subdiff(PG_FUNCTION_ARGS)1399 int4range_subdiff(PG_FUNCTION_ARGS)
1400 {
1401 int32 v1 = PG_GETARG_INT32(0);
1402 int32 v2 = PG_GETARG_INT32(1);
1403
1404 PG_RETURN_FLOAT8((float8) v1 - (float8) v2);
1405 }
1406
1407 Datum
int8range_subdiff(PG_FUNCTION_ARGS)1408 int8range_subdiff(PG_FUNCTION_ARGS)
1409 {
1410 int64 v1 = PG_GETARG_INT64(0);
1411 int64 v2 = PG_GETARG_INT64(1);
1412
1413 PG_RETURN_FLOAT8((float8) v1 - (float8) v2);
1414 }
1415
1416 Datum
numrange_subdiff(PG_FUNCTION_ARGS)1417 numrange_subdiff(PG_FUNCTION_ARGS)
1418 {
1419 Datum v1 = PG_GETARG_DATUM(0);
1420 Datum v2 = PG_GETARG_DATUM(1);
1421 Datum numresult;
1422 float8 floatresult;
1423
1424 numresult = DirectFunctionCall2(numeric_sub, v1, v2);
1425
1426 floatresult = DatumGetFloat8(DirectFunctionCall1(numeric_float8,
1427 numresult));
1428
1429 PG_RETURN_FLOAT8(floatresult);
1430 }
1431
1432 Datum
daterange_subdiff(PG_FUNCTION_ARGS)1433 daterange_subdiff(PG_FUNCTION_ARGS)
1434 {
1435 int32 v1 = PG_GETARG_INT32(0);
1436 int32 v2 = PG_GETARG_INT32(1);
1437
1438 PG_RETURN_FLOAT8((float8) v1 - (float8) v2);
1439 }
1440
1441 Datum
tsrange_subdiff(PG_FUNCTION_ARGS)1442 tsrange_subdiff(PG_FUNCTION_ARGS)
1443 {
1444 Timestamp v1 = PG_GETARG_TIMESTAMP(0);
1445 Timestamp v2 = PG_GETARG_TIMESTAMP(1);
1446 float8 result;
1447
1448 result = ((float8) v1 - (float8) v2) / USECS_PER_SEC;
1449 PG_RETURN_FLOAT8(result);
1450 }
1451
1452 Datum
tstzrange_subdiff(PG_FUNCTION_ARGS)1453 tstzrange_subdiff(PG_FUNCTION_ARGS)
1454 {
1455 Timestamp v1 = PG_GETARG_TIMESTAMP(0);
1456 Timestamp v2 = PG_GETARG_TIMESTAMP(1);
1457 float8 result;
1458
1459 result = ((float8) v1 - (float8) v2) / USECS_PER_SEC;
1460 PG_RETURN_FLOAT8(result);
1461 }
1462
1463 /*
1464 *----------------------------------------------------------
1465 * SUPPORT FUNCTIONS
1466 *
1467 * These functions aren't in pg_proc, but are useful for
1468 * defining new generic range functions in C.
1469 *----------------------------------------------------------
1470 */
1471
1472 /*
1473 * range_get_typcache: get cached information about a range type
1474 *
1475 * This is for use by range-related functions that follow the convention
1476 * of using the fn_extra field as a pointer to the type cache entry for
1477 * the range type. Functions that need to cache more information than
1478 * that must fend for themselves.
1479 */
1480 TypeCacheEntry *
range_get_typcache(FunctionCallInfo fcinfo,Oid rngtypid)1481 range_get_typcache(FunctionCallInfo fcinfo, Oid rngtypid)
1482 {
1483 TypeCacheEntry *typcache = (TypeCacheEntry *) fcinfo->flinfo->fn_extra;
1484
1485 if (typcache == NULL ||
1486 typcache->type_id != rngtypid)
1487 {
1488 typcache = lookup_type_cache(rngtypid, TYPECACHE_RANGE_INFO);
1489 if (typcache->rngelemtype == NULL)
1490 elog(ERROR, "type %u is not a range type", rngtypid);
1491 fcinfo->flinfo->fn_extra = (void *) typcache;
1492 }
1493
1494 return typcache;
1495 }
1496
1497 /*
1498 * range_serialize: construct a range value from bounds and empty-flag
1499 *
1500 * This does not force canonicalization of the range value. In most cases,
1501 * external callers should only be canonicalization functions. Note that
1502 * we perform some datatype-independent canonicalization checks anyway.
1503 */
1504 RangeType *
range_serialize(TypeCacheEntry * typcache,RangeBound * lower,RangeBound * upper,bool empty)1505 range_serialize(TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper,
1506 bool empty)
1507 {
1508 RangeType *range;
1509 int cmp;
1510 Size msize;
1511 Pointer ptr;
1512 int16 typlen;
1513 bool typbyval;
1514 char typalign;
1515 char typstorage;
1516 char flags = 0;
1517
1518 /*
1519 * Verify range is not invalid on its face, and construct flags value,
1520 * preventing any non-canonical combinations such as infinite+inclusive.
1521 */
1522 Assert(lower->lower);
1523 Assert(!upper->lower);
1524
1525 if (empty)
1526 flags |= RANGE_EMPTY;
1527 else
1528 {
1529 cmp = range_cmp_bound_values(typcache, lower, upper);
1530
1531 /* error check: if lower bound value is above upper, it's wrong */
1532 if (cmp > 0)
1533 ereport(ERROR,
1534 (errcode(ERRCODE_DATA_EXCEPTION),
1535 errmsg("range lower bound must be less than or equal to range upper bound")));
1536
1537 /* if bounds are equal, and not both inclusive, range is empty */
1538 if (cmp == 0 && !(lower->inclusive && upper->inclusive))
1539 flags |= RANGE_EMPTY;
1540 else
1541 {
1542 /* infinite boundaries are never inclusive */
1543 if (lower->infinite)
1544 flags |= RANGE_LB_INF;
1545 else if (lower->inclusive)
1546 flags |= RANGE_LB_INC;
1547 if (upper->infinite)
1548 flags |= RANGE_UB_INF;
1549 else if (upper->inclusive)
1550 flags |= RANGE_UB_INC;
1551 }
1552 }
1553
1554 /* Fetch information about range's element type */
1555 typlen = typcache->rngelemtype->typlen;
1556 typbyval = typcache->rngelemtype->typbyval;
1557 typalign = typcache->rngelemtype->typalign;
1558 typstorage = typcache->rngelemtype->typstorage;
1559
1560 /* Count space for varlena header and range type's OID */
1561 msize = sizeof(RangeType);
1562 Assert(msize == MAXALIGN(msize));
1563
1564 /* Count space for bounds */
1565 if (RANGE_HAS_LBOUND(flags))
1566 {
1567 /*
1568 * Make sure item to be inserted is not toasted. It is essential that
1569 * we not insert an out-of-line toast value pointer into a range
1570 * object, for the same reasons that arrays and records can't contain
1571 * them. It would work to store a compressed-in-line value, but we
1572 * prefer to decompress and then let compression be applied to the
1573 * whole range object if necessary. But, unlike arrays, we do allow
1574 * short-header varlena objects to stay as-is.
1575 */
1576 if (typlen == -1)
1577 lower->val = PointerGetDatum(PG_DETOAST_DATUM_PACKED(lower->val));
1578
1579 msize = datum_compute_size(msize, lower->val, typbyval, typalign,
1580 typlen, typstorage);
1581 }
1582
1583 if (RANGE_HAS_UBOUND(flags))
1584 {
1585 /* Make sure item to be inserted is not toasted */
1586 if (typlen == -1)
1587 upper->val = PointerGetDatum(PG_DETOAST_DATUM_PACKED(upper->val));
1588
1589 msize = datum_compute_size(msize, upper->val, typbyval, typalign,
1590 typlen, typstorage);
1591 }
1592
1593 /* Add space for flag byte */
1594 msize += sizeof(char);
1595
1596 /* Note: zero-fill is required here, just as in heap tuples */
1597 range = (RangeType *) palloc0(msize);
1598 SET_VARSIZE(range, msize);
1599
1600 /* Now fill in the datum */
1601 range->rangetypid = typcache->type_id;
1602
1603 ptr = (char *) (range + 1);
1604
1605 if (RANGE_HAS_LBOUND(flags))
1606 {
1607 Assert(lower->lower);
1608 ptr = datum_write(ptr, lower->val, typbyval, typalign, typlen,
1609 typstorage);
1610 }
1611
1612 if (RANGE_HAS_UBOUND(flags))
1613 {
1614 Assert(!upper->lower);
1615 ptr = datum_write(ptr, upper->val, typbyval, typalign, typlen,
1616 typstorage);
1617 }
1618
1619 *((char *) ptr) = flags;
1620
1621 return range;
1622 }
1623
1624 /*
1625 * range_deserialize: deconstruct a range value
1626 *
1627 * NB: the given range object must be fully detoasted; it cannot have a
1628 * short varlena header.
1629 *
1630 * Note that if the element type is pass-by-reference, the datums in the
1631 * RangeBound structs will be pointers into the given range object.
1632 */
1633 void
range_deserialize(TypeCacheEntry * typcache,RangeType * range,RangeBound * lower,RangeBound * upper,bool * empty)1634 range_deserialize(TypeCacheEntry *typcache, RangeType *range,
1635 RangeBound *lower, RangeBound *upper, bool *empty)
1636 {
1637 char flags;
1638 int16 typlen;
1639 bool typbyval;
1640 char typalign;
1641 Pointer ptr;
1642 Datum lbound;
1643 Datum ubound;
1644
1645 /* assert caller passed the right typcache entry */
1646 Assert(RangeTypeGetOid(range) == typcache->type_id);
1647
1648 /* fetch the flag byte from datum's last byte */
1649 flags = *((char *) range + VARSIZE(range) - 1);
1650
1651 /* fetch information about range's element type */
1652 typlen = typcache->rngelemtype->typlen;
1653 typbyval = typcache->rngelemtype->typbyval;
1654 typalign = typcache->rngelemtype->typalign;
1655
1656 /* initialize data pointer just after the range OID */
1657 ptr = (Pointer) (range + 1);
1658
1659 /* fetch lower bound, if any */
1660 if (RANGE_HAS_LBOUND(flags))
1661 {
1662 /* att_align_pointer cannot be necessary here */
1663 lbound = fetch_att(ptr, typbyval, typlen);
1664 ptr = (Pointer) att_addlength_pointer(ptr, typlen, ptr);
1665 }
1666 else
1667 lbound = (Datum) 0;
1668
1669 /* fetch upper bound, if any */
1670 if (RANGE_HAS_UBOUND(flags))
1671 {
1672 ptr = (Pointer) att_align_pointer(ptr, typalign, typlen, ptr);
1673 ubound = fetch_att(ptr, typbyval, typlen);
1674 /* no need for att_addlength_pointer */
1675 }
1676 else
1677 ubound = (Datum) 0;
1678
1679 /* emit results */
1680
1681 *empty = (flags & RANGE_EMPTY) != 0;
1682
1683 lower->val = lbound;
1684 lower->infinite = (flags & RANGE_LB_INF) != 0;
1685 lower->inclusive = (flags & RANGE_LB_INC) != 0;
1686 lower->lower = true;
1687
1688 upper->val = ubound;
1689 upper->infinite = (flags & RANGE_UB_INF) != 0;
1690 upper->inclusive = (flags & RANGE_UB_INC) != 0;
1691 upper->lower = false;
1692 }
1693
1694 /*
1695 * range_get_flags: just get the flags from a RangeType value.
1696 *
1697 * This is frequently useful in places that only need the flags and not
1698 * the full results of range_deserialize.
1699 */
1700 char
range_get_flags(RangeType * range)1701 range_get_flags(RangeType *range)
1702 {
1703 /* fetch the flag byte from datum's last byte */
1704 return *((char *) range + VARSIZE(range) - 1);
1705 }
1706
1707 /*
1708 * range_set_contain_empty: set the RANGE_CONTAIN_EMPTY bit in the value.
1709 *
1710 * This is only needed in GiST operations, so we don't include a provision
1711 * for setting it in range_serialize; rather, this function must be applied
1712 * afterwards.
1713 */
1714 void
range_set_contain_empty(RangeType * range)1715 range_set_contain_empty(RangeType *range)
1716 {
1717 char *flagsp;
1718
1719 /* flag byte is datum's last byte */
1720 flagsp = (char *) range + VARSIZE(range) - 1;
1721
1722 *flagsp |= RANGE_CONTAIN_EMPTY;
1723 }
1724
1725 /*
1726 * This both serializes and canonicalizes (if applicable) the range.
1727 * This should be used by most callers.
1728 */
1729 RangeType *
make_range(TypeCacheEntry * typcache,RangeBound * lower,RangeBound * upper,bool empty)1730 make_range(TypeCacheEntry *typcache, RangeBound *lower, RangeBound *upper,
1731 bool empty)
1732 {
1733 RangeType *range;
1734
1735 range = range_serialize(typcache, lower, upper, empty);
1736
1737 /* no need to call canonical on empty ranges ... */
1738 if (OidIsValid(typcache->rng_canonical_finfo.fn_oid) &&
1739 !RangeIsEmpty(range))
1740 range = DatumGetRangeType(FunctionCall1(&typcache->rng_canonical_finfo,
1741 RangeTypeGetDatum(range)));
1742
1743 return range;
1744 }
1745
1746 /*
1747 * Compare two range boundary points, returning <0, 0, or >0 according to
1748 * whether b1 is less than, equal to, or greater than b2.
1749 *
1750 * The boundaries can be any combination of upper and lower; so it's useful
1751 * for a variety of operators.
1752 *
1753 * The simple case is when b1 and b2 are both finite and inclusive, in which
1754 * case the result is just a comparison of the values held in b1 and b2.
1755 *
1756 * If a bound is exclusive, then we need to know whether it's a lower bound,
1757 * in which case we treat the boundary point as "just greater than" the held
1758 * value; or an upper bound, in which case we treat the boundary point as
1759 * "just less than" the held value.
1760 *
1761 * If a bound is infinite, it represents minus infinity (less than every other
1762 * point) if it's a lower bound; or plus infinity (greater than every other
1763 * point) if it's an upper bound.
1764 *
1765 * There is only one case where two boundaries compare equal but are not
1766 * identical: when both bounds are inclusive and hold the same finite value,
1767 * but one is an upper bound and the other a lower bound.
1768 */
1769 int
range_cmp_bounds(TypeCacheEntry * typcache,RangeBound * b1,RangeBound * b2)1770 range_cmp_bounds(TypeCacheEntry *typcache, RangeBound *b1, RangeBound *b2)
1771 {
1772 int32 result;
1773
1774 /*
1775 * First, handle cases involving infinity, which don't require invoking
1776 * the comparison proc.
1777 */
1778 if (b1->infinite && b2->infinite)
1779 {
1780 /*
1781 * Both are infinity, so they are equal unless one is lower and the
1782 * other not.
1783 */
1784 if (b1->lower == b2->lower)
1785 return 0;
1786 else
1787 return b1->lower ? -1 : 1;
1788 }
1789 else if (b1->infinite)
1790 return b1->lower ? -1 : 1;
1791 else if (b2->infinite)
1792 return b2->lower ? 1 : -1;
1793
1794 /*
1795 * Both boundaries are finite, so compare the held values.
1796 */
1797 result = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
1798 typcache->rng_collation,
1799 b1->val, b2->val));
1800
1801 /*
1802 * If the comparison is anything other than equal, we're done. If they
1803 * compare equal though, we still have to consider whether the boundaries
1804 * are inclusive or exclusive.
1805 */
1806 if (result == 0)
1807 {
1808 if (!b1->inclusive && !b2->inclusive)
1809 {
1810 /* both are exclusive */
1811 if (b1->lower == b2->lower)
1812 return 0;
1813 else
1814 return b1->lower ? 1 : -1;
1815 }
1816 else if (!b1->inclusive)
1817 return b1->lower ? 1 : -1;
1818 else if (!b2->inclusive)
1819 return b2->lower ? -1 : 1;
1820 else
1821 {
1822 /*
1823 * Both are inclusive and the values held are equal, so they are
1824 * equal regardless of whether they are upper or lower boundaries,
1825 * or a mix.
1826 */
1827 return 0;
1828 }
1829 }
1830
1831 return result;
1832 }
1833
1834 /*
1835 * Compare two range boundary point values, returning <0, 0, or >0 according
1836 * to whether b1 is less than, equal to, or greater than b2.
1837 *
1838 * This is similar to but simpler than range_cmp_bounds(). We just compare
1839 * the values held in b1 and b2, ignoring inclusive/exclusive flags. The
1840 * lower/upper flags only matter for infinities, where they tell us if the
1841 * infinity is plus or minus.
1842 */
1843 int
range_cmp_bound_values(TypeCacheEntry * typcache,RangeBound * b1,RangeBound * b2)1844 range_cmp_bound_values(TypeCacheEntry *typcache, RangeBound *b1,
1845 RangeBound *b2)
1846 {
1847 /*
1848 * First, handle cases involving infinity, which don't require invoking
1849 * the comparison proc.
1850 */
1851 if (b1->infinite && b2->infinite)
1852 {
1853 /*
1854 * Both are infinity, so they are equal unless one is lower and the
1855 * other not.
1856 */
1857 if (b1->lower == b2->lower)
1858 return 0;
1859 else
1860 return b1->lower ? -1 : 1;
1861 }
1862 else if (b1->infinite)
1863 return b1->lower ? -1 : 1;
1864 else if (b2->infinite)
1865 return b2->lower ? 1 : -1;
1866
1867 /*
1868 * Both boundaries are finite, so compare the held values.
1869 */
1870 return DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
1871 typcache->rng_collation,
1872 b1->val, b2->val));
1873 }
1874
1875 /*
1876 * Build an empty range value of the type indicated by the typcache entry.
1877 */
1878 RangeType *
make_empty_range(TypeCacheEntry * typcache)1879 make_empty_range(TypeCacheEntry *typcache)
1880 {
1881 RangeBound lower;
1882 RangeBound upper;
1883
1884 lower.val = (Datum) 0;
1885 lower.infinite = false;
1886 lower.inclusive = false;
1887 lower.lower = true;
1888
1889 upper.val = (Datum) 0;
1890 upper.infinite = false;
1891 upper.inclusive = false;
1892 upper.lower = false;
1893
1894 return make_range(typcache, &lower, &upper, true);
1895 }
1896
1897
1898 /*
1899 *----------------------------------------------------------
1900 * STATIC FUNCTIONS
1901 *----------------------------------------------------------
1902 */
1903
1904 /*
1905 * Given a string representing the flags for the range type, return the flags
1906 * represented as a char.
1907 */
1908 static char
range_parse_flags(const char * flags_str)1909 range_parse_flags(const char *flags_str)
1910 {
1911 char flags = 0;
1912
1913 if (flags_str[0] == '\0' ||
1914 flags_str[1] == '\0' ||
1915 flags_str[2] != '\0')
1916 ereport(ERROR,
1917 (errcode(ERRCODE_SYNTAX_ERROR),
1918 errmsg("invalid range bound flags"),
1919 errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
1920
1921 switch (flags_str[0])
1922 {
1923 case '[':
1924 flags |= RANGE_LB_INC;
1925 break;
1926 case '(':
1927 break;
1928 default:
1929 ereport(ERROR,
1930 (errcode(ERRCODE_SYNTAX_ERROR),
1931 errmsg("invalid range bound flags"),
1932 errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
1933 }
1934
1935 switch (flags_str[1])
1936 {
1937 case ']':
1938 flags |= RANGE_UB_INC;
1939 break;
1940 case ')':
1941 break;
1942 default:
1943 ereport(ERROR,
1944 (errcode(ERRCODE_SYNTAX_ERROR),
1945 errmsg("invalid range bound flags"),
1946 errhint("Valid values are \"[]\", \"[)\", \"(]\", and \"()\".")));
1947 }
1948
1949 return flags;
1950 }
1951
1952 /*
1953 * Parse range input.
1954 *
1955 * Input parameters:
1956 * string: input string to be parsed
1957 * Output parameters:
1958 * *flags: receives flags bitmask
1959 * *lbound_str: receives palloc'd lower bound string, or NULL if none
1960 * *ubound_str: receives palloc'd upper bound string, or NULL if none
1961 *
1962 * This is modeled somewhat after record_in in rowtypes.c.
1963 * The input syntax is:
1964 * <range> := EMPTY
1965 * | <lb-inc> <string>, <string> <ub-inc>
1966 * <lb-inc> := '[' | '('
1967 * <ub-inc> := ']' | ')'
1968 *
1969 * Whitespace before or after <range> is ignored. Whitespace within a <string>
1970 * is taken literally and becomes part of the input string for that bound.
1971 *
1972 * A <string> of length zero is taken as "infinite" (i.e. no bound), unless it
1973 * is surrounded by double-quotes, in which case it is the literal empty
1974 * string.
1975 *
1976 * Within a <string>, special characters (such as comma, parenthesis, or
1977 * brackets) can be enclosed in double-quotes or escaped with backslash. Within
1978 * double-quotes, a double-quote can be escaped with double-quote or backslash.
1979 */
1980 static void
range_parse(const char * string,char * flags,char ** lbound_str,char ** ubound_str)1981 range_parse(const char *string, char *flags, char **lbound_str,
1982 char **ubound_str)
1983 {
1984 const char *ptr = string;
1985 bool infinite;
1986
1987 *flags = 0;
1988
1989 /* consume whitespace */
1990 while (*ptr != '\0' && isspace((unsigned char) *ptr))
1991 ptr++;
1992
1993 /* check for empty range */
1994 if (pg_strncasecmp(ptr, RANGE_EMPTY_LITERAL,
1995 strlen(RANGE_EMPTY_LITERAL)) == 0)
1996 {
1997 *flags = RANGE_EMPTY;
1998 *lbound_str = NULL;
1999 *ubound_str = NULL;
2000
2001 ptr += strlen(RANGE_EMPTY_LITERAL);
2002
2003 /* the rest should be whitespace */
2004 while (*ptr != '\0' && isspace((unsigned char) *ptr))
2005 ptr++;
2006
2007 /* should have consumed everything */
2008 if (*ptr != '\0')
2009 ereport(ERROR,
2010 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
2011 errmsg("malformed range literal: \"%s\"",
2012 string),
2013 errdetail("Junk after \"empty\" key word.")));
2014
2015 return;
2016 }
2017
2018 if (*ptr == '[')
2019 {
2020 *flags |= RANGE_LB_INC;
2021 ptr++;
2022 }
2023 else if (*ptr == '(')
2024 ptr++;
2025 else
2026 ereport(ERROR,
2027 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
2028 errmsg("malformed range literal: \"%s\"",
2029 string),
2030 errdetail("Missing left parenthesis or bracket.")));
2031
2032 ptr = range_parse_bound(string, ptr, lbound_str, &infinite);
2033 if (infinite)
2034 *flags |= RANGE_LB_INF;
2035
2036 if (*ptr == ',')
2037 ptr++;
2038 else
2039 ereport(ERROR,
2040 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
2041 errmsg("malformed range literal: \"%s\"",
2042 string),
2043 errdetail("Missing comma after lower bound.")));
2044
2045 ptr = range_parse_bound(string, ptr, ubound_str, &infinite);
2046 if (infinite)
2047 *flags |= RANGE_UB_INF;
2048
2049 if (*ptr == ']')
2050 {
2051 *flags |= RANGE_UB_INC;
2052 ptr++;
2053 }
2054 else if (*ptr == ')')
2055 ptr++;
2056 else /* must be a comma */
2057 ereport(ERROR,
2058 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
2059 errmsg("malformed range literal: \"%s\"",
2060 string),
2061 errdetail("Too many commas.")));
2062
2063 /* consume whitespace */
2064 while (*ptr != '\0' && isspace((unsigned char) *ptr))
2065 ptr++;
2066
2067 if (*ptr != '\0')
2068 ereport(ERROR,
2069 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
2070 errmsg("malformed range literal: \"%s\"",
2071 string),
2072 errdetail("Junk after right parenthesis or bracket.")));
2073 }
2074
2075 /*
2076 * Helper for range_parse: parse and de-quote one bound string.
2077 *
2078 * We scan until finding comma, right parenthesis, or right bracket.
2079 *
2080 * Input parameters:
2081 * string: entire input string (used only for error reports)
2082 * ptr: where to start parsing bound
2083 * Output parameters:
2084 * *bound_str: receives palloc'd bound string, or NULL if none
2085 * *infinite: set true if no bound, else false
2086 *
2087 * The return value is the scan ptr, advanced past the bound string.
2088 */
2089 static const char *
range_parse_bound(const char * string,const char * ptr,char ** bound_str,bool * infinite)2090 range_parse_bound(const char *string, const char *ptr,
2091 char **bound_str, bool *infinite)
2092 {
2093 StringInfoData buf;
2094
2095 /* Check for null: completely empty input means null */
2096 if (*ptr == ',' || *ptr == ')' || *ptr == ']')
2097 {
2098 *bound_str = NULL;
2099 *infinite = true;
2100 }
2101 else
2102 {
2103 /* Extract string for this bound */
2104 bool inquote = false;
2105
2106 initStringInfo(&buf);
2107 while (inquote || !(*ptr == ',' || *ptr == ')' || *ptr == ']'))
2108 {
2109 char ch = *ptr++;
2110
2111 if (ch == '\0')
2112 ereport(ERROR,
2113 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
2114 errmsg("malformed range literal: \"%s\"",
2115 string),
2116 errdetail("Unexpected end of input.")));
2117 if (ch == '\\')
2118 {
2119 if (*ptr == '\0')
2120 ereport(ERROR,
2121 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
2122 errmsg("malformed range literal: \"%s\"",
2123 string),
2124 errdetail("Unexpected end of input.")));
2125 appendStringInfoChar(&buf, *ptr++);
2126 }
2127 else if (ch == '"')
2128 {
2129 if (!inquote)
2130 inquote = true;
2131 else if (*ptr == '"')
2132 {
2133 /* doubled quote within quote sequence */
2134 appendStringInfoChar(&buf, *ptr++);
2135 }
2136 else
2137 inquote = false;
2138 }
2139 else
2140 appendStringInfoChar(&buf, ch);
2141 }
2142
2143 *bound_str = buf.data;
2144 *infinite = false;
2145 }
2146
2147 return ptr;
2148 }
2149
2150 /*
2151 * Convert a deserialized range value to text form
2152 *
2153 * Inputs are the flags byte, and the two bound values already converted to
2154 * text (but not yet quoted). If no bound value, pass NULL.
2155 *
2156 * Result is a palloc'd string
2157 */
2158 static char *
range_deparse(char flags,const char * lbound_str,const char * ubound_str)2159 range_deparse(char flags, const char *lbound_str, const char *ubound_str)
2160 {
2161 StringInfoData buf;
2162
2163 if (flags & RANGE_EMPTY)
2164 return pstrdup(RANGE_EMPTY_LITERAL);
2165
2166 initStringInfo(&buf);
2167
2168 appendStringInfoChar(&buf, (flags & RANGE_LB_INC) ? '[' : '(');
2169
2170 if (RANGE_HAS_LBOUND(flags))
2171 appendStringInfoString(&buf, range_bound_escape(lbound_str));
2172
2173 appendStringInfoChar(&buf, ',');
2174
2175 if (RANGE_HAS_UBOUND(flags))
2176 appendStringInfoString(&buf, range_bound_escape(ubound_str));
2177
2178 appendStringInfoChar(&buf, (flags & RANGE_UB_INC) ? ']' : ')');
2179
2180 return buf.data;
2181 }
2182
2183 /*
2184 * Helper for range_deparse: quote a bound value as needed
2185 *
2186 * Result is a palloc'd string
2187 */
2188 static char *
range_bound_escape(const char * value)2189 range_bound_escape(const char *value)
2190 {
2191 bool nq;
2192 const char *ptr;
2193 StringInfoData buf;
2194
2195 initStringInfo(&buf);
2196
2197 /* Detect whether we need double quotes for this value */
2198 nq = (value[0] == '\0'); /* force quotes for empty string */
2199 for (ptr = value; *ptr; ptr++)
2200 {
2201 char ch = *ptr;
2202
2203 if (ch == '"' || ch == '\\' ||
2204 ch == '(' || ch == ')' ||
2205 ch == '[' || ch == ']' ||
2206 ch == ',' ||
2207 isspace((unsigned char) ch))
2208 {
2209 nq = true;
2210 break;
2211 }
2212 }
2213
2214 /* And emit the string */
2215 if (nq)
2216 appendStringInfoChar(&buf, '"');
2217 for (ptr = value; *ptr; ptr++)
2218 {
2219 char ch = *ptr;
2220
2221 if (ch == '"' || ch == '\\')
2222 appendStringInfoChar(&buf, ch);
2223 appendStringInfoChar(&buf, ch);
2224 }
2225 if (nq)
2226 appendStringInfoChar(&buf, '"');
2227
2228 return buf.data;
2229 }
2230
2231 /*
2232 * Test whether range r1 contains range r2.
2233 *
2234 * Caller has already checked that they are the same range type, and looked up
2235 * the necessary typcache entry.
2236 */
2237 bool
range_contains_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2)2238 range_contains_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
2239 {
2240 RangeBound lower1;
2241 RangeBound upper1;
2242 bool empty1;
2243 RangeBound lower2;
2244 RangeBound upper2;
2245 bool empty2;
2246
2247 /* Different types should be prevented by ANYRANGE matching rules */
2248 if (RangeTypeGetOid(r1) != RangeTypeGetOid(r2))
2249 elog(ERROR, "range types do not match");
2250
2251 range_deserialize(typcache, r1, &lower1, &upper1, &empty1);
2252 range_deserialize(typcache, r2, &lower2, &upper2, &empty2);
2253
2254 /* If either range is empty, the answer is easy */
2255 if (empty2)
2256 return true;
2257 else if (empty1)
2258 return false;
2259
2260 /* Else we must have lower1 <= lower2 and upper1 >= upper2 */
2261 if (range_cmp_bounds(typcache, &lower1, &lower2) > 0)
2262 return false;
2263 if (range_cmp_bounds(typcache, &upper1, &upper2) < 0)
2264 return false;
2265
2266 return true;
2267 }
2268
2269 bool
range_contained_by_internal(TypeCacheEntry * typcache,RangeType * r1,RangeType * r2)2270 range_contained_by_internal(TypeCacheEntry *typcache, RangeType *r1, RangeType *r2)
2271 {
2272 return range_contains_internal(typcache, r2, r1);
2273 }
2274
2275 /*
2276 * Test whether range r contains a specific element value.
2277 */
2278 bool
range_contains_elem_internal(TypeCacheEntry * typcache,RangeType * r,Datum val)2279 range_contains_elem_internal(TypeCacheEntry *typcache, RangeType *r, Datum val)
2280 {
2281 RangeBound lower;
2282 RangeBound upper;
2283 bool empty;
2284 int32 cmp;
2285
2286 range_deserialize(typcache, r, &lower, &upper, &empty);
2287
2288 if (empty)
2289 return false;
2290
2291 if (!lower.infinite)
2292 {
2293 cmp = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
2294 typcache->rng_collation,
2295 lower.val, val));
2296 if (cmp > 0)
2297 return false;
2298 if (cmp == 0 && !lower.inclusive)
2299 return false;
2300 }
2301
2302 if (!upper.infinite)
2303 {
2304 cmp = DatumGetInt32(FunctionCall2Coll(&typcache->rng_cmp_proc_finfo,
2305 typcache->rng_collation,
2306 upper.val, val));
2307 if (cmp < 0)
2308 return false;
2309 if (cmp == 0 && !upper.inclusive)
2310 return false;
2311 }
2312
2313 return true;
2314 }
2315
2316
2317 /*
2318 * datum_compute_size() and datum_write() are used to insert the bound
2319 * values into a range object. They are modeled after heaptuple.c's
2320 * heap_compute_data_size() and heap_fill_tuple(), but we need not handle
2321 * null values here. TYPE_IS_PACKABLE must test the same conditions as
2322 * heaptuple.c's ATT_IS_PACKABLE macro.
2323 */
2324
2325 /* Does datatype allow packing into the 1-byte-header varlena format? */
2326 #define TYPE_IS_PACKABLE(typlen, typstorage) \
2327 ((typlen) == -1 && (typstorage) != 'p')
2328
2329 /*
2330 * Increment data_length by the space needed by the datum, including any
2331 * preceding alignment padding.
2332 */
2333 static Size
datum_compute_size(Size data_length,Datum val,bool typbyval,char typalign,int16 typlen,char typstorage)2334 datum_compute_size(Size data_length, Datum val, bool typbyval, char typalign,
2335 int16 typlen, char typstorage)
2336 {
2337 if (TYPE_IS_PACKABLE(typlen, typstorage) &&
2338 VARATT_CAN_MAKE_SHORT(DatumGetPointer(val)))
2339 {
2340 /*
2341 * we're anticipating converting to a short varlena header, so adjust
2342 * length and don't count any alignment
2343 */
2344 data_length += VARATT_CONVERTED_SHORT_SIZE(DatumGetPointer(val));
2345 }
2346 else
2347 {
2348 data_length = att_align_datum(data_length, typalign, typlen, val);
2349 data_length = att_addlength_datum(data_length, typlen, val);
2350 }
2351
2352 return data_length;
2353 }
2354
2355 /*
2356 * Write the given datum beginning at ptr (after advancing to correct
2357 * alignment, if needed). Return the pointer incremented by space used.
2358 */
2359 static Pointer
datum_write(Pointer ptr,Datum datum,bool typbyval,char typalign,int16 typlen,char typstorage)2360 datum_write(Pointer ptr, Datum datum, bool typbyval, char typalign,
2361 int16 typlen, char typstorage)
2362 {
2363 Size data_length;
2364
2365 if (typbyval)
2366 {
2367 /* pass-by-value */
2368 ptr = (char *) att_align_nominal(ptr, typalign);
2369 store_att_byval(ptr, datum, typlen);
2370 data_length = typlen;
2371 }
2372 else if (typlen == -1)
2373 {
2374 /* varlena */
2375 Pointer val = DatumGetPointer(datum);
2376
2377 if (VARATT_IS_EXTERNAL(val))
2378 {
2379 /*
2380 * Throw error, because we must never put a toast pointer inside a
2381 * range object. Caller should have detoasted it.
2382 */
2383 elog(ERROR, "cannot store a toast pointer inside a range");
2384 data_length = 0; /* keep compiler quiet */
2385 }
2386 else if (VARATT_IS_SHORT(val))
2387 {
2388 /* no alignment for short varlenas */
2389 data_length = VARSIZE_SHORT(val);
2390 memcpy(ptr, val, data_length);
2391 }
2392 else if (TYPE_IS_PACKABLE(typlen, typstorage) &&
2393 VARATT_CAN_MAKE_SHORT(val))
2394 {
2395 /* convert to short varlena -- no alignment */
2396 data_length = VARATT_CONVERTED_SHORT_SIZE(val);
2397 SET_VARSIZE_SHORT(ptr, data_length);
2398 memcpy(ptr + 1, VARDATA(val), data_length - 1);
2399 }
2400 else
2401 {
2402 /* full 4-byte header varlena */
2403 ptr = (char *) att_align_nominal(ptr, typalign);
2404 data_length = VARSIZE(val);
2405 memcpy(ptr, val, data_length);
2406 }
2407 }
2408 else if (typlen == -2)
2409 {
2410 /* cstring ... never needs alignment */
2411 Assert(typalign == 'c');
2412 data_length = strlen(DatumGetCString(datum)) + 1;
2413 memcpy(ptr, DatumGetPointer(datum), data_length);
2414 }
2415 else
2416 {
2417 /* fixed-length pass-by-reference */
2418 ptr = (char *) att_align_nominal(ptr, typalign);
2419 Assert(typlen > 0);
2420 data_length = typlen;
2421 memcpy(ptr, DatumGetPointer(datum), data_length);
2422 }
2423
2424 ptr += data_length;
2425
2426 return ptr;
2427 }
2428