PostgreSQL Source Code  git master
int.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * int.c
4  * Functions for the built-in integer types (except int8).
5  *
6  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  *
10  * IDENTIFICATION
11  * src/backend/utils/adt/int.c
12  *
13  *-------------------------------------------------------------------------
14  */
15 /*
16  * OLD COMMENTS
17  * I/O routines:
18  * int2in, int2out, int2recv, int2send
19  * int4in, int4out, int4recv, int4send
20  * int2vectorin, int2vectorout, int2vectorrecv, int2vectorsend
21  * Boolean operators:
22  * inteq, intne, intlt, intle, intgt, intge
23  * Arithmetic operators:
24  * intpl, intmi, int4mul, intdiv
25  *
26  * Arithmetic operators:
27  * intmod
28  */
29 #include "postgres.h"
30 
31 #include <ctype.h>
32 #include <limits.h>
33 #include <math.h>
34 
35 #include "catalog/pg_type.h"
36 #include "common/int.h"
37 #include "funcapi.h"
38 #include "libpq/pqformat.h"
39 #include "nodes/nodeFuncs.h"
40 #include "nodes/supportnodes.h"
41 #include "optimizer/optimizer.h"
42 #include "utils/array.h"
43 #include "utils/builtins.h"
44 
45 #define Int2VectorSize(n) (offsetof(int2vector, values) + (n) * sizeof(int16))
46 
47 typedef struct
48 {
53 
54 
55 /*****************************************************************************
56  * USER I/O ROUTINES *
57  *****************************************************************************/
58 
59 /*
60  * int2in - converts "num" to short
61  */
62 Datum
64 {
65  char *num = PG_GETARG_CSTRING(0);
66 
67  PG_RETURN_INT16(pg_strtoint16_safe(num, fcinfo->context));
68 }
69 
70 /*
71  * int2out - converts short to "num"
72  */
73 Datum
75 {
76  int16 arg1 = PG_GETARG_INT16(0);
77  char *result = (char *) palloc(7); /* sign, 5 digits, '\0' */
78 
79  pg_itoa(arg1, result);
80  PG_RETURN_CSTRING(result);
81 }
82 
83 /*
84  * int2recv - converts external binary format to int2
85  */
86 Datum
88 {
90 
92 }
93 
94 /*
95  * int2send - converts int2 to binary format
96  */
97 Datum
99 {
100  int16 arg1 = PG_GETARG_INT16(0);
102 
104  pq_sendint16(&buf, arg1);
106 }
107 
108 /*
109  * construct int2vector given a raw array of int2s
110  *
111  * If int2s is NULL then caller must fill values[] afterward
112  */
113 int2vector *
114 buildint2vector(const int16 *int2s, int n)
115 {
116  int2vector *result;
117 
118  result = (int2vector *) palloc0(Int2VectorSize(n));
119 
120  if (n > 0 && int2s)
121  memcpy(result->values, int2s, n * sizeof(int16));
122 
123  /*
124  * Attach standard array header. For historical reasons, we set the index
125  * lower bound to 0 not 1.
126  */
127  SET_VARSIZE(result, Int2VectorSize(n));
128  result->ndim = 1;
129  result->dataoffset = 0; /* never any nulls */
130  result->elemtype = INT2OID;
131  result->dim1 = n;
132  result->lbound1 = 0;
133 
134  return result;
135 }
136 
137 /*
138  * int2vectorin - converts "num num ..." to internal form
139  */
140 Datum
142 {
143  char *intString = PG_GETARG_CSTRING(0);
144  Node *escontext = fcinfo->context;
145  int2vector *result;
146  int nalloc;
147  int n;
148 
149  nalloc = 32; /* arbitrary initial size guess */
150  result = (int2vector *) palloc0(Int2VectorSize(nalloc));
151 
152  for (n = 0;; n++)
153  {
154  long l;
155  char *endp;
156 
157  while (*intString && isspace((unsigned char) *intString))
158  intString++;
159  if (*intString == '\0')
160  break;
161 
162  if (n >= nalloc)
163  {
164  nalloc *= 2;
165  result = (int2vector *) repalloc(result, Int2VectorSize(nalloc));
166  }
167 
168  errno = 0;
169  l = strtol(intString, &endp, 10);
170 
171  if (intString == endp)
172  ereturn(escontext, (Datum) 0,
173  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
174  errmsg("invalid input syntax for type %s: \"%s\"",
175  "smallint", intString)));
176 
177  if (errno == ERANGE || l < SHRT_MIN || l > SHRT_MAX)
178  ereturn(escontext, (Datum) 0,
179  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
180  errmsg("value \"%s\" is out of range for type %s", intString,
181  "smallint")));
182 
183  if (*endp && *endp != ' ')
184  ereturn(escontext, (Datum) 0,
185  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
186  errmsg("invalid input syntax for type %s: \"%s\"",
187  "smallint", intString)));
188 
189  result->values[n] = l;
190  intString = endp;
191  }
192 
193  SET_VARSIZE(result, Int2VectorSize(n));
194  result->ndim = 1;
195  result->dataoffset = 0; /* never any nulls */
196  result->elemtype = INT2OID;
197  result->dim1 = n;
198  result->lbound1 = 0;
199 
200  PG_RETURN_POINTER(result);
201 }
202 
203 /*
204  * int2vectorout - converts internal form to "num num ..."
205  */
206 Datum
208 {
209  int2vector *int2Array = (int2vector *) PG_GETARG_POINTER(0);
210  int num,
211  nnums = int2Array->dim1;
212  char *rp;
213  char *result;
214 
215  /* assumes sign, 5 digits, ' ' */
216  rp = result = (char *) palloc(nnums * 7 + 1);
217  for (num = 0; num < nnums; num++)
218  {
219  if (num != 0)
220  *rp++ = ' ';
221  rp += pg_itoa(int2Array->values[num], rp);
222  }
223  *rp = '\0';
224  PG_RETURN_CSTRING(result);
225 }
226 
227 /*
228  * int2vectorrecv - converts external binary format to int2vector
229  */
230 Datum
232 {
233  LOCAL_FCINFO(locfcinfo, 3);
235  int2vector *result;
236 
237  /*
238  * Normally one would call array_recv() using DirectFunctionCall3, but
239  * that does not work since array_recv wants to cache some data using
240  * fcinfo->flinfo->fn_extra. So we need to pass it our own flinfo
241  * parameter.
242  */
243  InitFunctionCallInfoData(*locfcinfo, fcinfo->flinfo, 3,
244  InvalidOid, NULL, NULL);
245 
246  locfcinfo->args[0].value = PointerGetDatum(buf);
247  locfcinfo->args[0].isnull = false;
248  locfcinfo->args[1].value = ObjectIdGetDatum(INT2OID);
249  locfcinfo->args[1].isnull = false;
250  locfcinfo->args[2].value = Int32GetDatum(-1);
251  locfcinfo->args[2].isnull = false;
252 
253  result = (int2vector *) DatumGetPointer(array_recv(locfcinfo));
254 
255  Assert(!locfcinfo->isnull);
256 
257  /* sanity checks: int2vector must be 1-D, 0-based, no nulls */
258  if (ARR_NDIM(result) != 1 ||
259  ARR_HASNULL(result) ||
260  ARR_ELEMTYPE(result) != INT2OID ||
261  ARR_LBOUND(result)[0] != 0)
262  ereport(ERROR,
263  (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
264  errmsg("invalid int2vector data")));
265 
266  PG_RETURN_POINTER(result);
267 }
268 
269 /*
270  * int2vectorsend - converts int2vector to binary format
271  */
272 Datum
274 {
275  return array_send(fcinfo);
276 }
277 
278 
279 /*****************************************************************************
280  * PUBLIC ROUTINES *
281  *****************************************************************************/
282 
283 /*
284  * int4in - converts "num" to int4
285  */
286 Datum
288 {
289  char *num = PG_GETARG_CSTRING(0);
290 
291  PG_RETURN_INT32(pg_strtoint32_safe(num, fcinfo->context));
292 }
293 
294 /*
295  * int4out - converts int4 to "num"
296  */
297 Datum
299 {
300  int32 arg1 = PG_GETARG_INT32(0);
301  char *result = (char *) palloc(12); /* sign, 10 digits, '\0' */
302 
303  pg_ltoa(arg1, result);
304  PG_RETURN_CSTRING(result);
305 }
306 
307 /*
308  * int4recv - converts external binary format to int4
309  */
310 Datum
312 {
314 
316 }
317 
318 /*
319  * int4send - converts int4 to binary format
320  */
321 Datum
323 {
324  int32 arg1 = PG_GETARG_INT32(0);
326 
328  pq_sendint32(&buf, arg1);
330 }
331 
332 
333 /*
334  * ===================
335  * CONVERSION ROUTINES
336  * ===================
337  */
338 
339 Datum
341 {
342  int16 arg1 = PG_GETARG_INT16(0);
343 
344  PG_RETURN_INT32((int32) arg1);
345 }
346 
347 Datum
349 {
350  int32 arg1 = PG_GETARG_INT32(0);
351 
352  if (unlikely(arg1 < SHRT_MIN) || unlikely(arg1 > SHRT_MAX))
353  ereport(ERROR,
354  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
355  errmsg("smallint out of range")));
356 
357  PG_RETURN_INT16((int16) arg1);
358 }
359 
360 /* Cast int4 -> bool */
361 Datum
363 {
364  if (PG_GETARG_INT32(0) == 0)
365  PG_RETURN_BOOL(false);
366  else
367  PG_RETURN_BOOL(true);
368 }
369 
370 /* Cast bool -> int4 */
371 Datum
373 {
374  if (PG_GETARG_BOOL(0) == false)
375  PG_RETURN_INT32(0);
376  else
377  PG_RETURN_INT32(1);
378 }
379 
380 /*
381  * ============================
382  * COMPARISON OPERATOR ROUTINES
383  * ============================
384  */
385 
386 /*
387  * inteq - returns 1 iff arg1 == arg2
388  * intne - returns 1 iff arg1 != arg2
389  * intlt - returns 1 iff arg1 < arg2
390  * intle - returns 1 iff arg1 <= arg2
391  * intgt - returns 1 iff arg1 > arg2
392  * intge - returns 1 iff arg1 >= arg2
393  */
394 
395 Datum
397 {
398  int32 arg1 = PG_GETARG_INT32(0);
399  int32 arg2 = PG_GETARG_INT32(1);
400 
401  PG_RETURN_BOOL(arg1 == arg2);
402 }
403 
404 Datum
406 {
407  int32 arg1 = PG_GETARG_INT32(0);
408  int32 arg2 = PG_GETARG_INT32(1);
409 
410  PG_RETURN_BOOL(arg1 != arg2);
411 }
412 
413 Datum
415 {
416  int32 arg1 = PG_GETARG_INT32(0);
417  int32 arg2 = PG_GETARG_INT32(1);
418 
419  PG_RETURN_BOOL(arg1 < arg2);
420 }
421 
422 Datum
424 {
425  int32 arg1 = PG_GETARG_INT32(0);
426  int32 arg2 = PG_GETARG_INT32(1);
427 
428  PG_RETURN_BOOL(arg1 <= arg2);
429 }
430 
431 Datum
433 {
434  int32 arg1 = PG_GETARG_INT32(0);
435  int32 arg2 = PG_GETARG_INT32(1);
436 
437  PG_RETURN_BOOL(arg1 > arg2);
438 }
439 
440 Datum
442 {
443  int32 arg1 = PG_GETARG_INT32(0);
444  int32 arg2 = PG_GETARG_INT32(1);
445 
446  PG_RETURN_BOOL(arg1 >= arg2);
447 }
448 
449 Datum
451 {
452  int16 arg1 = PG_GETARG_INT16(0);
453  int16 arg2 = PG_GETARG_INT16(1);
454 
455  PG_RETURN_BOOL(arg1 == arg2);
456 }
457 
458 Datum
460 {
461  int16 arg1 = PG_GETARG_INT16(0);
462  int16 arg2 = PG_GETARG_INT16(1);
463 
464  PG_RETURN_BOOL(arg1 != arg2);
465 }
466 
467 Datum
469 {
470  int16 arg1 = PG_GETARG_INT16(0);
471  int16 arg2 = PG_GETARG_INT16(1);
472 
473  PG_RETURN_BOOL(arg1 < arg2);
474 }
475 
476 Datum
478 {
479  int16 arg1 = PG_GETARG_INT16(0);
480  int16 arg2 = PG_GETARG_INT16(1);
481 
482  PG_RETURN_BOOL(arg1 <= arg2);
483 }
484 
485 Datum
487 {
488  int16 arg1 = PG_GETARG_INT16(0);
489  int16 arg2 = PG_GETARG_INT16(1);
490 
491  PG_RETURN_BOOL(arg1 > arg2);
492 }
493 
494 Datum
496 {
497  int16 arg1 = PG_GETARG_INT16(0);
498  int16 arg2 = PG_GETARG_INT16(1);
499 
500  PG_RETURN_BOOL(arg1 >= arg2);
501 }
502 
503 Datum
505 {
506  int16 arg1 = PG_GETARG_INT16(0);
507  int32 arg2 = PG_GETARG_INT32(1);
508 
509  PG_RETURN_BOOL(arg1 == arg2);
510 }
511 
512 Datum
514 {
515  int16 arg1 = PG_GETARG_INT16(0);
516  int32 arg2 = PG_GETARG_INT32(1);
517 
518  PG_RETURN_BOOL(arg1 != arg2);
519 }
520 
521 Datum
523 {
524  int16 arg1 = PG_GETARG_INT16(0);
525  int32 arg2 = PG_GETARG_INT32(1);
526 
527  PG_RETURN_BOOL(arg1 < arg2);
528 }
529 
530 Datum
532 {
533  int16 arg1 = PG_GETARG_INT16(0);
534  int32 arg2 = PG_GETARG_INT32(1);
535 
536  PG_RETURN_BOOL(arg1 <= arg2);
537 }
538 
539 Datum
541 {
542  int16 arg1 = PG_GETARG_INT16(0);
543  int32 arg2 = PG_GETARG_INT32(1);
544 
545  PG_RETURN_BOOL(arg1 > arg2);
546 }
547 
548 Datum
550 {
551  int16 arg1 = PG_GETARG_INT16(0);
552  int32 arg2 = PG_GETARG_INT32(1);
553 
554  PG_RETURN_BOOL(arg1 >= arg2);
555 }
556 
557 Datum
559 {
560  int32 arg1 = PG_GETARG_INT32(0);
561  int16 arg2 = PG_GETARG_INT16(1);
562 
563  PG_RETURN_BOOL(arg1 == arg2);
564 }
565 
566 Datum
568 {
569  int32 arg1 = PG_GETARG_INT32(0);
570  int16 arg2 = PG_GETARG_INT16(1);
571 
572  PG_RETURN_BOOL(arg1 != arg2);
573 }
574 
575 Datum
577 {
578  int32 arg1 = PG_GETARG_INT32(0);
579  int16 arg2 = PG_GETARG_INT16(1);
580 
581  PG_RETURN_BOOL(arg1 < arg2);
582 }
583 
584 Datum
586 {
587  int32 arg1 = PG_GETARG_INT32(0);
588  int16 arg2 = PG_GETARG_INT16(1);
589 
590  PG_RETURN_BOOL(arg1 <= arg2);
591 }
592 
593 Datum
595 {
596  int32 arg1 = PG_GETARG_INT32(0);
597  int16 arg2 = PG_GETARG_INT16(1);
598 
599  PG_RETURN_BOOL(arg1 > arg2);
600 }
601 
602 Datum
604 {
605  int32 arg1 = PG_GETARG_INT32(0);
606  int16 arg2 = PG_GETARG_INT16(1);
607 
608  PG_RETURN_BOOL(arg1 >= arg2);
609 }
610 
611 
612 /*----------------------------------------------------------
613  * in_range functions for int4 and int2,
614  * including cross-data-type comparisons.
615  *
616  * Note: we provide separate intN_int8 functions for performance
617  * reasons. This forces also providing intN_int2, else cases with a
618  * smallint offset value would fail to resolve which function to use.
619  * But that's an unlikely situation, so don't duplicate code for it.
620  *---------------------------------------------------------*/
621 
622 Datum
624 {
626  int32 base = PG_GETARG_INT32(1);
627  int32 offset = PG_GETARG_INT32(2);
628  bool sub = PG_GETARG_BOOL(3);
629  bool less = PG_GETARG_BOOL(4);
630  int32 sum;
631 
632  if (offset < 0)
633  ereport(ERROR,
634  (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
635  errmsg("invalid preceding or following size in window function")));
636 
637  if (sub)
638  offset = -offset; /* cannot overflow */
639 
640  if (unlikely(pg_add_s32_overflow(base, offset, &sum)))
641  {
642  /*
643  * If sub is false, the true sum is surely more than val, so correct
644  * answer is the same as "less". If sub is true, the true sum is
645  * surely less than val, so the answer is "!less".
646  */
647  PG_RETURN_BOOL(sub ? !less : less);
648  }
649 
650  if (less)
651  PG_RETURN_BOOL(val <= sum);
652  else
653  PG_RETURN_BOOL(val >= sum);
654 }
655 
656 Datum
658 {
659  /* Doesn't seem worth duplicating code for, so just invoke int4_int4 */
661  PG_GETARG_DATUM(0),
662  PG_GETARG_DATUM(1),
664  PG_GETARG_DATUM(3),
665  PG_GETARG_DATUM(4));
666 }
667 
668 Datum
670 {
671  /* We must do all the math in int64 */
672  int64 val = (int64) PG_GETARG_INT32(0);
673  int64 base = (int64) PG_GETARG_INT32(1);
674  int64 offset = PG_GETARG_INT64(2);
675  bool sub = PG_GETARG_BOOL(3);
676  bool less = PG_GETARG_BOOL(4);
677  int64 sum;
678 
679  if (offset < 0)
680  ereport(ERROR,
681  (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
682  errmsg("invalid preceding or following size in window function")));
683 
684  if (sub)
685  offset = -offset; /* cannot overflow */
686 
687  if (unlikely(pg_add_s64_overflow(base, offset, &sum)))
688  {
689  /*
690  * If sub is false, the true sum is surely more than val, so correct
691  * answer is the same as "less". If sub is true, the true sum is
692  * surely less than val, so the answer is "!less".
693  */
694  PG_RETURN_BOOL(sub ? !less : less);
695  }
696 
697  if (less)
698  PG_RETURN_BOOL(val <= sum);
699  else
700  PG_RETURN_BOOL(val >= sum);
701 }
702 
703 Datum
705 {
706  /* We must do all the math in int32 */
708  int32 base = (int32) PG_GETARG_INT16(1);
709  int32 offset = PG_GETARG_INT32(2);
710  bool sub = PG_GETARG_BOOL(3);
711  bool less = PG_GETARG_BOOL(4);
712  int32 sum;
713 
714  if (offset < 0)
715  ereport(ERROR,
716  (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
717  errmsg("invalid preceding or following size in window function")));
718 
719  if (sub)
720  offset = -offset; /* cannot overflow */
721 
722  if (unlikely(pg_add_s32_overflow(base, offset, &sum)))
723  {
724  /*
725  * If sub is false, the true sum is surely more than val, so correct
726  * answer is the same as "less". If sub is true, the true sum is
727  * surely less than val, so the answer is "!less".
728  */
729  PG_RETURN_BOOL(sub ? !less : less);
730  }
731 
732  if (less)
733  PG_RETURN_BOOL(val <= sum);
734  else
735  PG_RETURN_BOOL(val >= sum);
736 }
737 
738 Datum
740 {
741  /* Doesn't seem worth duplicating code for, so just invoke int2_int4 */
743  PG_GETARG_DATUM(0),
744  PG_GETARG_DATUM(1),
746  PG_GETARG_DATUM(3),
747  PG_GETARG_DATUM(4));
748 }
749 
750 Datum
752 {
753  /* Doesn't seem worth duplicating code for, so just invoke int4_int8 */
757  PG_GETARG_DATUM(2),
758  PG_GETARG_DATUM(3),
759  PG_GETARG_DATUM(4));
760 }
761 
762 
763 /*
764  * int[24]pl - returns arg1 + arg2
765  * int[24]mi - returns arg1 - arg2
766  * int[24]mul - returns arg1 * arg2
767  * int[24]div - returns arg1 / arg2
768  */
769 
770 Datum
772 {
774 
775  if (unlikely(arg == PG_INT32_MIN))
776  ereport(ERROR,
777  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
778  errmsg("integer out of range")));
780 }
781 
782 Datum
784 {
786 
788 }
789 
790 Datum
792 {
793  int32 arg1 = PG_GETARG_INT32(0);
794  int32 arg2 = PG_GETARG_INT32(1);
795  int32 result;
796 
797  if (unlikely(pg_add_s32_overflow(arg1, arg2, &result)))
798  ereport(ERROR,
799  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
800  errmsg("integer out of range")));
801  PG_RETURN_INT32(result);
802 }
803 
804 Datum
806 {
807  int32 arg1 = PG_GETARG_INT32(0);
808  int32 arg2 = PG_GETARG_INT32(1);
809  int32 result;
810 
811  if (unlikely(pg_sub_s32_overflow(arg1, arg2, &result)))
812  ereport(ERROR,
813  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
814  errmsg("integer out of range")));
815  PG_RETURN_INT32(result);
816 }
817 
818 Datum
820 {
821  int32 arg1 = PG_GETARG_INT32(0);
822  int32 arg2 = PG_GETARG_INT32(1);
823  int32 result;
824 
825  if (unlikely(pg_mul_s32_overflow(arg1, arg2, &result)))
826  ereport(ERROR,
827  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
828  errmsg("integer out of range")));
829  PG_RETURN_INT32(result);
830 }
831 
832 Datum
834 {
835  int32 arg1 = PG_GETARG_INT32(0);
836  int32 arg2 = PG_GETARG_INT32(1);
837  int32 result;
838 
839  if (arg2 == 0)
840  {
841  ereport(ERROR,
842  (errcode(ERRCODE_DIVISION_BY_ZERO),
843  errmsg("division by zero")));
844  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
845  PG_RETURN_NULL();
846  }
847 
848  /*
849  * INT_MIN / -1 is problematic, since the result can't be represented on a
850  * two's-complement machine. Some machines produce INT_MIN, some produce
851  * zero, some throw an exception. We can dodge the problem by recognizing
852  * that division by -1 is the same as negation.
853  */
854  if (arg2 == -1)
855  {
856  if (unlikely(arg1 == PG_INT32_MIN))
857  ereport(ERROR,
858  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
859  errmsg("integer out of range")));
860  result = -arg1;
861  PG_RETURN_INT32(result);
862  }
863 
864  /* No overflow is possible */
865 
866  result = arg1 / arg2;
867 
868  PG_RETURN_INT32(result);
869 }
870 
871 Datum
873 {
875  int32 result;
876 
877  if (unlikely(pg_add_s32_overflow(arg, 1, &result)))
878  ereport(ERROR,
879  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
880  errmsg("integer out of range")));
881 
882  PG_RETURN_INT32(result);
883 }
884 
885 Datum
887 {
889 
890  if (unlikely(arg == PG_INT16_MIN))
891  ereport(ERROR,
892  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
893  errmsg("smallint out of range")));
895 }
896 
897 Datum
899 {
901 
903 }
904 
905 Datum
907 {
908  int16 arg1 = PG_GETARG_INT16(0);
909  int16 arg2 = PG_GETARG_INT16(1);
910  int16 result;
911 
912  if (unlikely(pg_add_s16_overflow(arg1, arg2, &result)))
913  ereport(ERROR,
914  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
915  errmsg("smallint out of range")));
916  PG_RETURN_INT16(result);
917 }
918 
919 Datum
921 {
922  int16 arg1 = PG_GETARG_INT16(0);
923  int16 arg2 = PG_GETARG_INT16(1);
924  int16 result;
925 
926  if (unlikely(pg_sub_s16_overflow(arg1, arg2, &result)))
927  ereport(ERROR,
928  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
929  errmsg("smallint out of range")));
930  PG_RETURN_INT16(result);
931 }
932 
933 Datum
935 {
936  int16 arg1 = PG_GETARG_INT16(0);
937  int16 arg2 = PG_GETARG_INT16(1);
938  int16 result;
939 
940  if (unlikely(pg_mul_s16_overflow(arg1, arg2, &result)))
941  ereport(ERROR,
942  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
943  errmsg("smallint out of range")));
944 
945  PG_RETURN_INT16(result);
946 }
947 
948 Datum
950 {
951  int16 arg1 = PG_GETARG_INT16(0);
952  int16 arg2 = PG_GETARG_INT16(1);
953  int16 result;
954 
955  if (arg2 == 0)
956  {
957  ereport(ERROR,
958  (errcode(ERRCODE_DIVISION_BY_ZERO),
959  errmsg("division by zero")));
960  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
961  PG_RETURN_NULL();
962  }
963 
964  /*
965  * SHRT_MIN / -1 is problematic, since the result can't be represented on
966  * a two's-complement machine. Some machines produce SHRT_MIN, some
967  * produce zero, some throw an exception. We can dodge the problem by
968  * recognizing that division by -1 is the same as negation.
969  */
970  if (arg2 == -1)
971  {
972  if (unlikely(arg1 == PG_INT16_MIN))
973  ereport(ERROR,
974  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
975  errmsg("smallint out of range")));
976  result = -arg1;
977  PG_RETURN_INT16(result);
978  }
979 
980  /* No overflow is possible */
981 
982  result = arg1 / arg2;
983 
984  PG_RETURN_INT16(result);
985 }
986 
987 Datum
989 {
990  int16 arg1 = PG_GETARG_INT16(0);
991  int32 arg2 = PG_GETARG_INT32(1);
992  int32 result;
993 
994  if (unlikely(pg_add_s32_overflow((int32) arg1, arg2, &result)))
995  ereport(ERROR,
996  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
997  errmsg("integer out of range")));
998  PG_RETURN_INT32(result);
999 }
1000 
1001 Datum
1003 {
1004  int16 arg1 = PG_GETARG_INT16(0);
1005  int32 arg2 = PG_GETARG_INT32(1);
1006  int32 result;
1007 
1008  if (unlikely(pg_sub_s32_overflow((int32) arg1, arg2, &result)))
1009  ereport(ERROR,
1010  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1011  errmsg("integer out of range")));
1012  PG_RETURN_INT32(result);
1013 }
1014 
1015 Datum
1017 {
1018  int16 arg1 = PG_GETARG_INT16(0);
1019  int32 arg2 = PG_GETARG_INT32(1);
1020  int32 result;
1021 
1022  if (unlikely(pg_mul_s32_overflow((int32) arg1, arg2, &result)))
1023  ereport(ERROR,
1024  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1025  errmsg("integer out of range")));
1026  PG_RETURN_INT32(result);
1027 }
1028 
1029 Datum
1031 {
1032  int16 arg1 = PG_GETARG_INT16(0);
1033  int32 arg2 = PG_GETARG_INT32(1);
1034 
1035  if (unlikely(arg2 == 0))
1036  {
1037  ereport(ERROR,
1038  (errcode(ERRCODE_DIVISION_BY_ZERO),
1039  errmsg("division by zero")));
1040  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
1041  PG_RETURN_NULL();
1042  }
1043 
1044  /* No overflow is possible */
1045  PG_RETURN_INT32((int32) arg1 / arg2);
1046 }
1047 
1048 Datum
1050 {
1051  int32 arg1 = PG_GETARG_INT32(0);
1052  int16 arg2 = PG_GETARG_INT16(1);
1053  int32 result;
1054 
1055  if (unlikely(pg_add_s32_overflow(arg1, (int32) arg2, &result)))
1056  ereport(ERROR,
1057  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1058  errmsg("integer out of range")));
1059  PG_RETURN_INT32(result);
1060 }
1061 
1062 Datum
1064 {
1065  int32 arg1 = PG_GETARG_INT32(0);
1066  int16 arg2 = PG_GETARG_INT16(1);
1067  int32 result;
1068 
1069  if (unlikely(pg_sub_s32_overflow(arg1, (int32) arg2, &result)))
1070  ereport(ERROR,
1071  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1072  errmsg("integer out of range")));
1073  PG_RETURN_INT32(result);
1074 }
1075 
1076 Datum
1078 {
1079  int32 arg1 = PG_GETARG_INT32(0);
1080  int16 arg2 = PG_GETARG_INT16(1);
1081  int32 result;
1082 
1083  if (unlikely(pg_mul_s32_overflow(arg1, (int32) arg2, &result)))
1084  ereport(ERROR,
1085  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1086  errmsg("integer out of range")));
1087  PG_RETURN_INT32(result);
1088 }
1089 
1090 Datum
1092 {
1093  int32 arg1 = PG_GETARG_INT32(0);
1094  int16 arg2 = PG_GETARG_INT16(1);
1095  int32 result;
1096 
1097  if (unlikely(arg2 == 0))
1098  {
1099  ereport(ERROR,
1100  (errcode(ERRCODE_DIVISION_BY_ZERO),
1101  errmsg("division by zero")));
1102  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
1103  PG_RETURN_NULL();
1104  }
1105 
1106  /*
1107  * INT_MIN / -1 is problematic, since the result can't be represented on a
1108  * two's-complement machine. Some machines produce INT_MIN, some produce
1109  * zero, some throw an exception. We can dodge the problem by recognizing
1110  * that division by -1 is the same as negation.
1111  */
1112  if (arg2 == -1)
1113  {
1114  if (unlikely(arg1 == PG_INT32_MIN))
1115  ereport(ERROR,
1116  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1117  errmsg("integer out of range")));
1118  result = -arg1;
1119  PG_RETURN_INT32(result);
1120  }
1121 
1122  /* No overflow is possible */
1123 
1124  result = arg1 / arg2;
1125 
1126  PG_RETURN_INT32(result);
1127 }
1128 
1129 Datum
1131 {
1132  int32 arg1 = PG_GETARG_INT32(0);
1133  int32 arg2 = PG_GETARG_INT32(1);
1134 
1135  if (unlikely(arg2 == 0))
1136  {
1137  ereport(ERROR,
1138  (errcode(ERRCODE_DIVISION_BY_ZERO),
1139  errmsg("division by zero")));
1140  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
1141  PG_RETURN_NULL();
1142  }
1143 
1144  /*
1145  * Some machines throw a floating-point exception for INT_MIN % -1, which
1146  * is a bit silly since the correct answer is perfectly well-defined,
1147  * namely zero.
1148  */
1149  if (arg2 == -1)
1150  PG_RETURN_INT32(0);
1151 
1152  /* No overflow is possible */
1153 
1154  PG_RETURN_INT32(arg1 % arg2);
1155 }
1156 
1157 Datum
1159 {
1160  int16 arg1 = PG_GETARG_INT16(0);
1161  int16 arg2 = PG_GETARG_INT16(1);
1162 
1163  if (unlikely(arg2 == 0))
1164  {
1165  ereport(ERROR,
1166  (errcode(ERRCODE_DIVISION_BY_ZERO),
1167  errmsg("division by zero")));
1168  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
1169  PG_RETURN_NULL();
1170  }
1171 
1172  /*
1173  * Some machines throw a floating-point exception for INT_MIN % -1, which
1174  * is a bit silly since the correct answer is perfectly well-defined,
1175  * namely zero. (It's not clear this ever happens when dealing with
1176  * int16, but we might as well have the test for safety.)
1177  */
1178  if (arg2 == -1)
1179  PG_RETURN_INT16(0);
1180 
1181  /* No overflow is possible */
1182 
1183  PG_RETURN_INT16(arg1 % arg2);
1184 }
1185 
1186 
1187 /* int[24]abs()
1188  * Absolute value
1189  */
1190 Datum
1192 {
1193  int32 arg1 = PG_GETARG_INT32(0);
1194  int32 result;
1195 
1196  if (unlikely(arg1 == PG_INT32_MIN))
1197  ereport(ERROR,
1198  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1199  errmsg("integer out of range")));
1200  result = (arg1 < 0) ? -arg1 : arg1;
1201  PG_RETURN_INT32(result);
1202 }
1203 
1204 Datum
1206 {
1207  int16 arg1 = PG_GETARG_INT16(0);
1208  int16 result;
1209 
1210  if (unlikely(arg1 == PG_INT16_MIN))
1211  ereport(ERROR,
1212  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1213  errmsg("smallint out of range")));
1214  result = (arg1 < 0) ? -arg1 : arg1;
1215  PG_RETURN_INT16(result);
1216 }
1217 
1218 /*
1219  * Greatest Common Divisor
1220  *
1221  * Returns the largest positive integer that exactly divides both inputs.
1222  * Special cases:
1223  * - gcd(x, 0) = gcd(0, x) = abs(x)
1224  * because 0 is divisible by anything
1225  * - gcd(0, 0) = 0
1226  * complies with the previous definition and is a common convention
1227  *
1228  * Special care must be taken if either input is INT_MIN --- gcd(0, INT_MIN),
1229  * gcd(INT_MIN, 0) and gcd(INT_MIN, INT_MIN) are all equal to abs(INT_MIN),
1230  * which cannot be represented as a 32-bit signed integer.
1231  */
1232 static int32
1234 {
1235  int32 swap;
1236  int32 a1,
1237  a2;
1238 
1239  /*
1240  * Put the greater absolute value in arg1.
1241  *
1242  * This would happen automatically in the loop below, but avoids an
1243  * expensive modulo operation, and simplifies the special-case handling
1244  * for INT_MIN below.
1245  *
1246  * We do this in negative space in order to handle INT_MIN.
1247  */
1248  a1 = (arg1 < 0) ? arg1 : -arg1;
1249  a2 = (arg2 < 0) ? arg2 : -arg2;
1250  if (a1 > a2)
1251  {
1252  swap = arg1;
1253  arg1 = arg2;
1254  arg2 = swap;
1255  }
1256 
1257  /* Special care needs to be taken with INT_MIN. See comments above. */
1258  if (arg1 == PG_INT32_MIN)
1259  {
1260  if (arg2 == 0 || arg2 == PG_INT32_MIN)
1261  ereport(ERROR,
1262  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1263  errmsg("integer out of range")));
1264 
1265  /*
1266  * Some machines throw a floating-point exception for INT_MIN % -1,
1267  * which is a bit silly since the correct answer is perfectly
1268  * well-defined, namely zero. Guard against this and just return the
1269  * result, gcd(INT_MIN, -1) = 1.
1270  */
1271  if (arg2 == -1)
1272  return 1;
1273  }
1274 
1275  /* Use the Euclidean algorithm to find the GCD */
1276  while (arg2 != 0)
1277  {
1278  swap = arg2;
1279  arg2 = arg1 % arg2;
1280  arg1 = swap;
1281  }
1282 
1283  /*
1284  * Make sure the result is positive. (We know we don't have INT_MIN
1285  * anymore).
1286  */
1287  if (arg1 < 0)
1288  arg1 = -arg1;
1289 
1290  return arg1;
1291 }
1292 
1293 Datum
1295 {
1296  int32 arg1 = PG_GETARG_INT32(0);
1297  int32 arg2 = PG_GETARG_INT32(1);
1298  int32 result;
1299 
1300  result = int4gcd_internal(arg1, arg2);
1301 
1302  PG_RETURN_INT32(result);
1303 }
1304 
1305 /*
1306  * Least Common Multiple
1307  */
1308 Datum
1310 {
1311  int32 arg1 = PG_GETARG_INT32(0);
1312  int32 arg2 = PG_GETARG_INT32(1);
1313  int32 gcd;
1314  int32 result;
1315 
1316  /*
1317  * Handle lcm(x, 0) = lcm(0, x) = 0 as a special case. This prevents a
1318  * division-by-zero error below when x is zero, and an overflow error from
1319  * the GCD computation when x = INT_MIN.
1320  */
1321  if (arg1 == 0 || arg2 == 0)
1322  PG_RETURN_INT32(0);
1323 
1324  /* lcm(x, y) = abs(x / gcd(x, y) * y) */
1325  gcd = int4gcd_internal(arg1, arg2);
1326  arg1 = arg1 / gcd;
1327 
1328  if (unlikely(pg_mul_s32_overflow(arg1, arg2, &result)))
1329  ereport(ERROR,
1330  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1331  errmsg("integer out of range")));
1332 
1333  /* If the result is INT_MIN, it cannot be represented. */
1334  if (unlikely(result == PG_INT32_MIN))
1335  ereport(ERROR,
1336  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1337  errmsg("integer out of range")));
1338 
1339  if (result < 0)
1340  result = -result;
1341 
1342  PG_RETURN_INT32(result);
1343 }
1344 
1345 Datum
1347 {
1348  int16 arg1 = PG_GETARG_INT16(0);
1349  int16 arg2 = PG_GETARG_INT16(1);
1350 
1351  PG_RETURN_INT16((arg1 > arg2) ? arg1 : arg2);
1352 }
1353 
1354 Datum
1356 {
1357  int16 arg1 = PG_GETARG_INT16(0);
1358  int16 arg2 = PG_GETARG_INT16(1);
1359 
1360  PG_RETURN_INT16((arg1 < arg2) ? arg1 : arg2);
1361 }
1362 
1363 Datum
1365 {
1366  int32 arg1 = PG_GETARG_INT32(0);
1367  int32 arg2 = PG_GETARG_INT32(1);
1368 
1369  PG_RETURN_INT32((arg1 > arg2) ? arg1 : arg2);
1370 }
1371 
1372 Datum
1374 {
1375  int32 arg1 = PG_GETARG_INT32(0);
1376  int32 arg2 = PG_GETARG_INT32(1);
1377 
1378  PG_RETURN_INT32((arg1 < arg2) ? arg1 : arg2);
1379 }
1380 
1381 /*
1382  * Bit-pushing operators
1383  *
1384  * int[24]and - returns arg1 & arg2
1385  * int[24]or - returns arg1 | arg2
1386  * int[24]xor - returns arg1 # arg2
1387  * int[24]not - returns ~arg1
1388  * int[24]shl - returns arg1 << arg2
1389  * int[24]shr - returns arg1 >> arg2
1390  */
1391 
1392 Datum
1394 {
1395  int32 arg1 = PG_GETARG_INT32(0);
1396  int32 arg2 = PG_GETARG_INT32(1);
1397 
1398  PG_RETURN_INT32(arg1 & arg2);
1399 }
1400 
1401 Datum
1403 {
1404  int32 arg1 = PG_GETARG_INT32(0);
1405  int32 arg2 = PG_GETARG_INT32(1);
1406 
1407  PG_RETURN_INT32(arg1 | arg2);
1408 }
1409 
1410 Datum
1412 {
1413  int32 arg1 = PG_GETARG_INT32(0);
1414  int32 arg2 = PG_GETARG_INT32(1);
1415 
1416  PG_RETURN_INT32(arg1 ^ arg2);
1417 }
1418 
1419 Datum
1421 {
1422  int32 arg1 = PG_GETARG_INT32(0);
1423  int32 arg2 = PG_GETARG_INT32(1);
1424 
1425  PG_RETURN_INT32(arg1 << arg2);
1426 }
1427 
1428 Datum
1430 {
1431  int32 arg1 = PG_GETARG_INT32(0);
1432  int32 arg2 = PG_GETARG_INT32(1);
1433 
1434  PG_RETURN_INT32(arg1 >> arg2);
1435 }
1436 
1437 Datum
1439 {
1440  int32 arg1 = PG_GETARG_INT32(0);
1441 
1442  PG_RETURN_INT32(~arg1);
1443 }
1444 
1445 Datum
1447 {
1448  int16 arg1 = PG_GETARG_INT16(0);
1449  int16 arg2 = PG_GETARG_INT16(1);
1450 
1451  PG_RETURN_INT16(arg1 & arg2);
1452 }
1453 
1454 Datum
1456 {
1457  int16 arg1 = PG_GETARG_INT16(0);
1458  int16 arg2 = PG_GETARG_INT16(1);
1459 
1460  PG_RETURN_INT16(arg1 | arg2);
1461 }
1462 
1463 Datum
1465 {
1466  int16 arg1 = PG_GETARG_INT16(0);
1467  int16 arg2 = PG_GETARG_INT16(1);
1468 
1469  PG_RETURN_INT16(arg1 ^ arg2);
1470 }
1471 
1472 Datum
1474 {
1475  int16 arg1 = PG_GETARG_INT16(0);
1476 
1477  PG_RETURN_INT16(~arg1);
1478 }
1479 
1480 
1481 Datum
1483 {
1484  int16 arg1 = PG_GETARG_INT16(0);
1485  int32 arg2 = PG_GETARG_INT32(1);
1486 
1487  PG_RETURN_INT16(arg1 << arg2);
1488 }
1489 
1490 Datum
1492 {
1493  int16 arg1 = PG_GETARG_INT16(0);
1494  int32 arg2 = PG_GETARG_INT32(1);
1495 
1496  PG_RETURN_INT16(arg1 >> arg2);
1497 }
1498 
1499 /*
1500  * non-persistent numeric series generator
1501  */
1502 Datum
1504 {
1505  return generate_series_step_int4(fcinfo);
1506 }
1507 
1508 Datum
1510 {
1511  FuncCallContext *funcctx;
1512  generate_series_fctx *fctx;
1513  int32 result;
1514  MemoryContext oldcontext;
1515 
1516  /* stuff done only on the first call of the function */
1517  if (SRF_IS_FIRSTCALL())
1518  {
1519  int32 start = PG_GETARG_INT32(0);
1520  int32 finish = PG_GETARG_INT32(1);
1521  int32 step = 1;
1522 
1523  /* see if we were given an explicit step size */
1524  if (PG_NARGS() == 3)
1525  step = PG_GETARG_INT32(2);
1526  if (step == 0)
1527  ereport(ERROR,
1528  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1529  errmsg("step size cannot equal zero")));
1530 
1531  /* create a function context for cross-call persistence */
1532  funcctx = SRF_FIRSTCALL_INIT();
1533 
1534  /*
1535  * switch to memory context appropriate for multiple function calls
1536  */
1537  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
1538 
1539  /* allocate memory for user context */
1540  fctx = (generate_series_fctx *) palloc(sizeof(generate_series_fctx));
1541 
1542  /*
1543  * Use fctx to keep state from call to call. Seed current with the
1544  * original start value
1545  */
1546  fctx->current = start;
1547  fctx->finish = finish;
1548  fctx->step = step;
1549 
1550  funcctx->user_fctx = fctx;
1551  MemoryContextSwitchTo(oldcontext);
1552  }
1553 
1554  /* stuff done on every call of the function */
1555  funcctx = SRF_PERCALL_SETUP();
1556 
1557  /*
1558  * get the saved state and use current as the result for this iteration
1559  */
1560  fctx = funcctx->user_fctx;
1561  result = fctx->current;
1562 
1563  if ((fctx->step > 0 && fctx->current <= fctx->finish) ||
1564  (fctx->step < 0 && fctx->current >= fctx->finish))
1565  {
1566  /*
1567  * Increment current in preparation for next iteration. If next-value
1568  * computation overflows, this is the final result.
1569  */
1570  if (pg_add_s32_overflow(fctx->current, fctx->step, &fctx->current))
1571  fctx->step = 0;
1572 
1573  /* do when there is more left to send */
1574  SRF_RETURN_NEXT(funcctx, Int32GetDatum(result));
1575  }
1576  else
1577  /* do when there is no more left */
1578  SRF_RETURN_DONE(funcctx);
1579 }
1580 
1581 /*
1582  * Planner support function for generate_series(int4, int4 [, int4])
1583  */
1584 Datum
1586 {
1587  Node *rawreq = (Node *) PG_GETARG_POINTER(0);
1588  Node *ret = NULL;
1589 
1590  if (IsA(rawreq, SupportRequestRows))
1591  {
1592  /* Try to estimate the number of rows returned */
1593  SupportRequestRows *req = (SupportRequestRows *) rawreq;
1594 
1595  if (is_funcclause(req->node)) /* be paranoid */
1596  {
1597  List *args = ((FuncExpr *) req->node)->args;
1598  Node *arg1,
1599  *arg2,
1600  *arg3;
1601 
1602  /* We can use estimated argument values here */
1604  arg2 = estimate_expression_value(req->root, lsecond(args));
1605  if (list_length(args) >= 3)
1606  arg3 = estimate_expression_value(req->root, lthird(args));
1607  else
1608  arg3 = NULL;
1609 
1610  /*
1611  * If any argument is constant NULL, we can safely assume that
1612  * zero rows are returned. Otherwise, if they're all non-NULL
1613  * constants, we can calculate the number of rows that will be
1614  * returned. Use double arithmetic to avoid overflow hazards.
1615  */
1616  if ((IsA(arg1, Const) &&
1617  ((Const *) arg1)->constisnull) ||
1618  (IsA(arg2, Const) &&
1619  ((Const *) arg2)->constisnull) ||
1620  (arg3 != NULL && IsA(arg3, Const) &&
1621  ((Const *) arg3)->constisnull))
1622  {
1623  req->rows = 0;
1624  ret = (Node *) req;
1625  }
1626  else if (IsA(arg1, Const) &&
1627  IsA(arg2, Const) &&
1628  (arg3 == NULL || IsA(arg3, Const)))
1629  {
1630  double start,
1631  finish,
1632  step;
1633 
1634  start = DatumGetInt32(((Const *) arg1)->constvalue);
1635  finish = DatumGetInt32(((Const *) arg2)->constvalue);
1636  step = arg3 ? DatumGetInt32(((Const *) arg3)->constvalue) : 1;
1637 
1638  /* This equation works for either sign of step */
1639  if (step != 0)
1640  {
1641  req->rows = floor((finish - start + step) / step);
1642  ret = (Node *) req;
1643  }
1644  }
1645  }
1646  }
1647 
1648  PG_RETURN_POINTER(ret);
1649 }
#define ARR_NDIM(a)
Definition: array.h:283
#define ARR_ELEMTYPE(a)
Definition: array.h:285
#define ARR_HASNULL(a)
Definition: array.h:284
#define ARR_LBOUND(a)
Definition: array.h:289
Datum array_recv(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1295
Datum array_send(PG_FUNCTION_ARGS)
Definition: arrayfuncs.c:1583
signed short int16
Definition: c.h:477
signed int int32
Definition: c.h:478
#define PG_INT16_MIN
Definition: c.h:569
#define unlikely(x)
Definition: c.h:295
#define PG_INT32_MIN
Definition: c.h:572
Node * estimate_expression_value(PlannerInfo *root, Node *node)
Definition: clauses.c:2273
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define ereturn(context, dummy_value,...)
Definition: elog.h:276
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:371
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:276
#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo)
Definition: fmgr.h:150
#define PG_RETURN_CSTRING(x)
Definition: fmgr.h:362
#define PG_GETARG_DATUM(n)
Definition: fmgr.h:268
#define LOCAL_FCINFO(name, nargs)
Definition: fmgr.h:110
#define PG_NARGS()
Definition: fmgr.h:203
#define PG_GETARG_CSTRING(n)
Definition: fmgr.h:277
#define PG_RETURN_NULL()
Definition: fmgr.h:345
#define PG_GETARG_INT64(n)
Definition: fmgr.h:283
#define PG_RETURN_INT16(x)
Definition: fmgr.h:356
#define PG_RETURN_INT32(x)
Definition: fmgr.h:354
#define PG_GETARG_INT32(n)
Definition: fmgr.h:269
#define PG_GETARG_BOOL(n)
Definition: fmgr.h:274
#define DirectFunctionCall5(func, arg1, arg2, arg3, arg4, arg5)
Definition: fmgr.h:650
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:361
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
#define PG_RETURN_BOOL(x)
Definition: fmgr.h:359
#define PG_GETARG_INT16(n)
Definition: fmgr.h:271
#define SRF_IS_FIRSTCALL()
Definition: funcapi.h:303
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:307
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:309
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:305
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:327
static const FormData_pg_attribute a1
Definition: heap.c:141
static const FormData_pg_attribute a2
Definition: heap.c:155
long val
Definition: informix.c:664
Datum int4div(PG_FUNCTION_ARGS)
Definition: int.c:833
Datum int4shl(PG_FUNCTION_ARGS)
Definition: int.c:1420
Datum int2vectorrecv(PG_FUNCTION_ARGS)
Definition: int.c:231
Datum int2not(PG_FUNCTION_ARGS)
Definition: int.c:1473
Datum int4pl(PG_FUNCTION_ARGS)
Definition: int.c:791
Datum int2xor(PG_FUNCTION_ARGS)
Definition: int.c:1464
Datum generate_series_int4(PG_FUNCTION_ARGS)
Definition: int.c:1503
Datum int4recv(PG_FUNCTION_ARGS)
Definition: int.c:311
Datum int4um(PG_FUNCTION_ARGS)
Definition: int.c:771
Datum int4gt(PG_FUNCTION_ARGS)
Definition: int.c:432
Datum int24eq(PG_FUNCTION_ARGS)
Definition: int.c:504
Datum int2lt(PG_FUNCTION_ARGS)
Definition: int.c:468
Datum int24mi(PG_FUNCTION_ARGS)
Definition: int.c:1002
Datum int2out(PG_FUNCTION_ARGS)
Definition: int.c:74
Datum int2eq(PG_FUNCTION_ARGS)
Definition: int.c:450
Datum int42eq(PG_FUNCTION_ARGS)
Definition: int.c:558
Datum int2ge(PG_FUNCTION_ARGS)
Definition: int.c:495
Datum int2up(PG_FUNCTION_ARGS)
Definition: int.c:898
Datum int4gcd(PG_FUNCTION_ARGS)
Definition: int.c:1294
Datum int42ge(PG_FUNCTION_ARGS)
Definition: int.c:603
Datum int42mul(PG_FUNCTION_ARGS)
Definition: int.c:1077
Datum int24gt(PG_FUNCTION_ARGS)
Definition: int.c:540
Datum int2le(PG_FUNCTION_ARGS)
Definition: int.c:477
Datum int2abs(PG_FUNCTION_ARGS)
Definition: int.c:1205
#define Int2VectorSize(n)
Definition: int.c:45
Datum int4lt(PG_FUNCTION_ARGS)
Definition: int.c:414
Datum int2um(PG_FUNCTION_ARGS)
Definition: int.c:886
Datum int2shl(PG_FUNCTION_ARGS)
Definition: int.c:1482
Datum in_range_int2_int8(PG_FUNCTION_ARGS)
Definition: int.c:751
Datum int42div(PG_FUNCTION_ARGS)
Definition: int.c:1091
Datum int2mi(PG_FUNCTION_ARGS)
Definition: int.c:920
Datum int2ne(PG_FUNCTION_ARGS)
Definition: int.c:459
Datum int24le(PG_FUNCTION_ARGS)
Definition: int.c:531
Datum int2send(PG_FUNCTION_ARGS)
Definition: int.c:98
Datum int2mul(PG_FUNCTION_ARGS)
Definition: int.c:934
Datum int2smaller(PG_FUNCTION_ARGS)
Definition: int.c:1355
Datum int2mod(PG_FUNCTION_ARGS)
Definition: int.c:1158
Datum int2in(PG_FUNCTION_ARGS)
Definition: int.c:63
Datum int24mul(PG_FUNCTION_ARGS)
Definition: int.c:1016
Datum int42gt(PG_FUNCTION_ARGS)
Definition: int.c:594
Datum int4lcm(PG_FUNCTION_ARGS)
Definition: int.c:1309
Datum in_range_int4_int8(PG_FUNCTION_ARGS)
Definition: int.c:669
Datum int2div(PG_FUNCTION_ARGS)
Definition: int.c:949
Datum in_range_int2_int2(PG_FUNCTION_ARGS)
Definition: int.c:739
Datum int4in(PG_FUNCTION_ARGS)
Definition: int.c:287
Datum int2shr(PG_FUNCTION_ARGS)
Definition: int.c:1491
Datum in_range_int2_int4(PG_FUNCTION_ARGS)
Definition: int.c:704
static int32 int4gcd_internal(int32 arg1, int32 arg2)
Definition: int.c:1233
Datum int2vectorout(PG_FUNCTION_ARGS)
Definition: int.c:207
Datum i4toi2(PG_FUNCTION_ARGS)
Definition: int.c:348
Datum int4ge(PG_FUNCTION_ARGS)
Definition: int.c:441
Datum int4and(PG_FUNCTION_ARGS)
Definition: int.c:1393
Datum int4send(PG_FUNCTION_ARGS)
Definition: int.c:322
Datum int24ge(PG_FUNCTION_ARGS)
Definition: int.c:549
Datum in_range_int4_int2(PG_FUNCTION_ARGS)
Definition: int.c:657
Datum int2vectorin(PG_FUNCTION_ARGS)
Definition: int.c:141
Datum bool_int4(PG_FUNCTION_ARGS)
Definition: int.c:372
Datum int4inc(PG_FUNCTION_ARGS)
Definition: int.c:872
Datum int4shr(PG_FUNCTION_ARGS)
Definition: int.c:1429
Datum int4larger(PG_FUNCTION_ARGS)
Definition: int.c:1364
Datum int24ne(PG_FUNCTION_ARGS)
Definition: int.c:513
Datum int2gt(PG_FUNCTION_ARGS)
Definition: int.c:486
Datum int24lt(PG_FUNCTION_ARGS)
Definition: int.c:522
Datum int42pl(PG_FUNCTION_ARGS)
Definition: int.c:1049
Datum in_range_int4_int4(PG_FUNCTION_ARGS)
Definition: int.c:623
Datum int4ne(PG_FUNCTION_ARGS)
Definition: int.c:405
Datum int42le(PG_FUNCTION_ARGS)
Definition: int.c:585
Datum i2toi4(PG_FUNCTION_ARGS)
Definition: int.c:340
Datum int4smaller(PG_FUNCTION_ARGS)
Definition: int.c:1373
Datum int24pl(PG_FUNCTION_ARGS)
Definition: int.c:988
Datum int4_bool(PG_FUNCTION_ARGS)
Definition: int.c:362
Datum int4mod(PG_FUNCTION_ARGS)
Definition: int.c:1130
Datum int24div(PG_FUNCTION_ARGS)
Definition: int.c:1030
Datum int4xor(PG_FUNCTION_ARGS)
Definition: int.c:1411
Datum generate_series_step_int4(PG_FUNCTION_ARGS)
Definition: int.c:1509
Datum int2larger(PG_FUNCTION_ARGS)
Definition: int.c:1346
int2vector * buildint2vector(const int16 *int2s, int n)
Definition: int.c:114
Datum int2and(PG_FUNCTION_ARGS)
Definition: int.c:1446
Datum int4not(PG_FUNCTION_ARGS)
Definition: int.c:1438
Datum int4abs(PG_FUNCTION_ARGS)
Definition: int.c:1191
Datum int4out(PG_FUNCTION_ARGS)
Definition: int.c:298
Datum generate_series_int4_support(PG_FUNCTION_ARGS)
Definition: int.c:1585
Datum int4mul(PG_FUNCTION_ARGS)
Definition: int.c:819
Datum int4eq(PG_FUNCTION_ARGS)
Definition: int.c:396
Datum int4le(PG_FUNCTION_ARGS)
Definition: int.c:423
Datum int42ne(PG_FUNCTION_ARGS)
Definition: int.c:567
Datum int4mi(PG_FUNCTION_ARGS)
Definition: int.c:805
Datum int42lt(PG_FUNCTION_ARGS)
Definition: int.c:576
Datum int2pl(PG_FUNCTION_ARGS)
Definition: int.c:906
Datum int4up(PG_FUNCTION_ARGS)
Definition: int.c:783
Datum int2vectorsend(PG_FUNCTION_ARGS)
Definition: int.c:273
Datum int2recv(PG_FUNCTION_ARGS)
Definition: int.c:87
Datum int42mi(PG_FUNCTION_ARGS)
Definition: int.c:1063
Datum int4or(PG_FUNCTION_ARGS)
Definition: int.c:1402
Datum int2or(PG_FUNCTION_ARGS)
Definition: int.c:1455
static bool pg_sub_s16_overflow(int16 a, int16 b, int16 *result)
Definition: int.h:65
static bool pg_mul_s32_overflow(int32 a, int32 b, int32 *result)
Definition: int.h:140
static bool pg_mul_s16_overflow(int16 a, int16 b, int16 *result)
Definition: int.h:83
static bool pg_add_s16_overflow(int16 a, int16 b, int16 *result)
Definition: int.h:47
static bool pg_sub_s32_overflow(int32 a, int32 b, int32 *result)
Definition: int.h:122
static bool pg_add_s64_overflow(int64 a, int64 b, int64 *result)
Definition: int.h:161
static bool pg_add_s32_overflow(int32 a, int32 b, int32 *result)
Definition: int.h:104
Assert(fmt[strlen(fmt) - 1] !='\n')
void * palloc0(Size size)
Definition: mcxt.c:1241
void * repalloc(void *pointer, Size size)
Definition: mcxt.c:1456
void * palloc(Size size)
Definition: mcxt.c:1210
static bool is_funcclause(const void *clause)
Definition: nodeFuncs.h:67
#define IsA(nodeptr, _type_)
Definition: nodes.h:168
int pg_ltoa(int32 value, char *a)
Definition: numutils.c:718
int32 pg_strtoint32_safe(const char *s, Node *escontext)
Definition: numutils.c:246
int pg_itoa(int16 i, char *a)
Definition: numutils.c:640
int16 pg_strtoint16_safe(const char *s, Node *escontext)
Definition: numutils.c:119
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:138
void * arg
static int list_length(const List *l)
Definition: pg_list.h:152
#define lthird(l)
Definition: pg_list.h:188
#define linitial(l)
Definition: pg_list.h:178
#define lsecond(l)
Definition: pg_list.h:183
static char * buf
Definition: pg_test_fsync.c:67
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:322
uintptr_t Datum
Definition: postgres.h:64
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
static Pointer DatumGetPointer(Datum X)
Definition: postgres.h:312
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212
static int32 DatumGetInt32(Datum X)
Definition: postgres.h:202
#define InvalidOid
Definition: postgres_ext.h:36
unsigned int pq_getmsgint(StringInfo msg, int b)
Definition: pqformat.c:418
void pq_begintypsend(StringInfo buf)
Definition: pqformat.c:329
bytea * pq_endtypsend(StringInfo buf)
Definition: pqformat.c:349
static void pq_sendint32(StringInfo buf, uint32 i)
Definition: pqformat.h:145
static void pq_sendint16(StringInfo buf, uint16 i)
Definition: pqformat.h:137
StringInfoData * StringInfo
Definition: stringinfo.h:44
void * user_fctx
Definition: funcapi.h:82
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:101
Definition: pg_list.h:54
Definition: nodes.h:118
struct PlannerInfo * root
Definition: supportnodes.h:163
int32 current
Definition: int.c:49
int32 finish
Definition: int.c:50
Definition: c.h:699
int ndim
Definition: c.h:701
int dim1
Definition: c.h:704
Oid elemtype
Definition: c.h:703
int16 values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:706
int32 dataoffset
Definition: c.h:702
int lbound1
Definition: c.h:705
static uint32 gcd(uint32 a, uint32 b)
#define SET_VARSIZE(PTR, len)
Definition: varatt.h:305