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