PostgreSQL Source Code  git master
int8.c
Go to the documentation of this file.
1 /*-------------------------------------------------------------------------
2  *
3  * int8.c
4  * Internal 64-bit integer operations
5  *
6  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
7  * Portions Copyright (c) 1994, Regents of the University of California
8  *
9  * IDENTIFICATION
10  * src/backend/utils/adt/int8.c
11  *
12  *-------------------------------------------------------------------------
13  */
14 #include "postgres.h"
15 
16 #include <ctype.h>
17 #include <limits.h>
18 #include <math.h>
19 
20 #include "common/int.h"
21 #include "funcapi.h"
22 #include "libpq/pqformat.h"
23 #include "nodes/nodeFuncs.h"
24 #include "nodes/supportnodes.h"
25 #include "optimizer/optimizer.h"
26 #include "utils/builtins.h"
27 
28 
29 typedef struct
30 {
31  int64 current;
32  int64 finish;
33  int64 step;
35 
36 
37 /***********************************************************************
38  **
39  ** Routines for 64-bit integers.
40  **
41  ***********************************************************************/
42 
43 /*----------------------------------------------------------
44  * Formatting and conversion routines.
45  *---------------------------------------------------------*/
46 
47 /* int8in()
48  */
49 Datum
51 {
52  char *num = PG_GETARG_CSTRING(0);
53 
54  PG_RETURN_INT64(pg_strtoint64_safe(num, fcinfo->context));
55 }
56 
57 
58 /* int8out()
59  */
60 Datum
62 {
63  int64 val = PG_GETARG_INT64(0);
64  char buf[MAXINT8LEN + 1];
65  char *result;
66  int len;
67 
68  len = pg_lltoa(val, buf) + 1;
69 
70  /*
71  * Since the length is already known, we do a manual palloc() and memcpy()
72  * to avoid the strlen() call that would otherwise be done in pstrdup().
73  */
74  result = palloc(len);
75  memcpy(result, buf, len);
76  PG_RETURN_CSTRING(result);
77 }
78 
79 /*
80  * int8recv - converts external binary format to int8
81  */
82 Datum
84 {
86 
88 }
89 
90 /*
91  * int8send - converts int8 to binary format
92  */
93 Datum
95 {
96  int64 arg1 = PG_GETARG_INT64(0);
98 
100  pq_sendint64(&buf, arg1);
102 }
103 
104 
105 /*----------------------------------------------------------
106  * Relational operators for int8s, including cross-data-type comparisons.
107  *---------------------------------------------------------*/
108 
109 /* int8relop()
110  * Is val1 relop val2?
111  */
112 Datum
114 {
115  int64 val1 = PG_GETARG_INT64(0);
116  int64 val2 = PG_GETARG_INT64(1);
117 
118  PG_RETURN_BOOL(val1 == val2);
119 }
120 
121 Datum
123 {
124  int64 val1 = PG_GETARG_INT64(0);
125  int64 val2 = PG_GETARG_INT64(1);
126 
127  PG_RETURN_BOOL(val1 != val2);
128 }
129 
130 Datum
132 {
133  int64 val1 = PG_GETARG_INT64(0);
134  int64 val2 = PG_GETARG_INT64(1);
135 
136  PG_RETURN_BOOL(val1 < val2);
137 }
138 
139 Datum
141 {
142  int64 val1 = PG_GETARG_INT64(0);
143  int64 val2 = PG_GETARG_INT64(1);
144 
145  PG_RETURN_BOOL(val1 > val2);
146 }
147 
148 Datum
150 {
151  int64 val1 = PG_GETARG_INT64(0);
152  int64 val2 = PG_GETARG_INT64(1);
153 
154  PG_RETURN_BOOL(val1 <= val2);
155 }
156 
157 Datum
159 {
160  int64 val1 = PG_GETARG_INT64(0);
161  int64 val2 = PG_GETARG_INT64(1);
162 
163  PG_RETURN_BOOL(val1 >= val2);
164 }
165 
166 /* int84relop()
167  * Is 64-bit val1 relop 32-bit val2?
168  */
169 Datum
171 {
172  int64 val1 = PG_GETARG_INT64(0);
173  int32 val2 = PG_GETARG_INT32(1);
174 
175  PG_RETURN_BOOL(val1 == val2);
176 }
177 
178 Datum
180 {
181  int64 val1 = PG_GETARG_INT64(0);
182  int32 val2 = PG_GETARG_INT32(1);
183 
184  PG_RETURN_BOOL(val1 != val2);
185 }
186 
187 Datum
189 {
190  int64 val1 = PG_GETARG_INT64(0);
191  int32 val2 = PG_GETARG_INT32(1);
192 
193  PG_RETURN_BOOL(val1 < val2);
194 }
195 
196 Datum
198 {
199  int64 val1 = PG_GETARG_INT64(0);
200  int32 val2 = PG_GETARG_INT32(1);
201 
202  PG_RETURN_BOOL(val1 > val2);
203 }
204 
205 Datum
207 {
208  int64 val1 = PG_GETARG_INT64(0);
209  int32 val2 = PG_GETARG_INT32(1);
210 
211  PG_RETURN_BOOL(val1 <= val2);
212 }
213 
214 Datum
216 {
217  int64 val1 = PG_GETARG_INT64(0);
218  int32 val2 = PG_GETARG_INT32(1);
219 
220  PG_RETURN_BOOL(val1 >= val2);
221 }
222 
223 /* int48relop()
224  * Is 32-bit val1 relop 64-bit val2?
225  */
226 Datum
228 {
229  int32 val1 = PG_GETARG_INT32(0);
230  int64 val2 = PG_GETARG_INT64(1);
231 
232  PG_RETURN_BOOL(val1 == val2);
233 }
234 
235 Datum
237 {
238  int32 val1 = PG_GETARG_INT32(0);
239  int64 val2 = PG_GETARG_INT64(1);
240 
241  PG_RETURN_BOOL(val1 != val2);
242 }
243 
244 Datum
246 {
247  int32 val1 = PG_GETARG_INT32(0);
248  int64 val2 = PG_GETARG_INT64(1);
249 
250  PG_RETURN_BOOL(val1 < val2);
251 }
252 
253 Datum
255 {
256  int32 val1 = PG_GETARG_INT32(0);
257  int64 val2 = PG_GETARG_INT64(1);
258 
259  PG_RETURN_BOOL(val1 > val2);
260 }
261 
262 Datum
264 {
265  int32 val1 = PG_GETARG_INT32(0);
266  int64 val2 = PG_GETARG_INT64(1);
267 
268  PG_RETURN_BOOL(val1 <= val2);
269 }
270 
271 Datum
273 {
274  int32 val1 = PG_GETARG_INT32(0);
275  int64 val2 = PG_GETARG_INT64(1);
276 
277  PG_RETURN_BOOL(val1 >= val2);
278 }
279 
280 /* int82relop()
281  * Is 64-bit val1 relop 16-bit val2?
282  */
283 Datum
285 {
286  int64 val1 = PG_GETARG_INT64(0);
287  int16 val2 = PG_GETARG_INT16(1);
288 
289  PG_RETURN_BOOL(val1 == val2);
290 }
291 
292 Datum
294 {
295  int64 val1 = PG_GETARG_INT64(0);
296  int16 val2 = PG_GETARG_INT16(1);
297 
298  PG_RETURN_BOOL(val1 != val2);
299 }
300 
301 Datum
303 {
304  int64 val1 = PG_GETARG_INT64(0);
305  int16 val2 = PG_GETARG_INT16(1);
306 
307  PG_RETURN_BOOL(val1 < val2);
308 }
309 
310 Datum
312 {
313  int64 val1 = PG_GETARG_INT64(0);
314  int16 val2 = PG_GETARG_INT16(1);
315 
316  PG_RETURN_BOOL(val1 > val2);
317 }
318 
319 Datum
321 {
322  int64 val1 = PG_GETARG_INT64(0);
323  int16 val2 = PG_GETARG_INT16(1);
324 
325  PG_RETURN_BOOL(val1 <= val2);
326 }
327 
328 Datum
330 {
331  int64 val1 = PG_GETARG_INT64(0);
332  int16 val2 = PG_GETARG_INT16(1);
333 
334  PG_RETURN_BOOL(val1 >= val2);
335 }
336 
337 /* int28relop()
338  * Is 16-bit val1 relop 64-bit val2?
339  */
340 Datum
342 {
343  int16 val1 = PG_GETARG_INT16(0);
344  int64 val2 = PG_GETARG_INT64(1);
345 
346  PG_RETURN_BOOL(val1 == val2);
347 }
348 
349 Datum
351 {
352  int16 val1 = PG_GETARG_INT16(0);
353  int64 val2 = PG_GETARG_INT64(1);
354 
355  PG_RETURN_BOOL(val1 != val2);
356 }
357 
358 Datum
360 {
361  int16 val1 = PG_GETARG_INT16(0);
362  int64 val2 = PG_GETARG_INT64(1);
363 
364  PG_RETURN_BOOL(val1 < val2);
365 }
366 
367 Datum
369 {
370  int16 val1 = PG_GETARG_INT16(0);
371  int64 val2 = PG_GETARG_INT64(1);
372 
373  PG_RETURN_BOOL(val1 > val2);
374 }
375 
376 Datum
378 {
379  int16 val1 = PG_GETARG_INT16(0);
380  int64 val2 = PG_GETARG_INT64(1);
381 
382  PG_RETURN_BOOL(val1 <= val2);
383 }
384 
385 Datum
387 {
388  int16 val1 = PG_GETARG_INT16(0);
389  int64 val2 = PG_GETARG_INT64(1);
390 
391  PG_RETURN_BOOL(val1 >= val2);
392 }
393 
394 /*
395  * in_range support function for int8.
396  *
397  * Note: we needn't supply int8_int4 or int8_int2 variants, as implicit
398  * coercion of the offset value takes care of those scenarios just as well.
399  */
400 Datum
402 {
403  int64 val = PG_GETARG_INT64(0);
404  int64 base = PG_GETARG_INT64(1);
405  int64 offset = PG_GETARG_INT64(2);
406  bool sub = PG_GETARG_BOOL(3);
407  bool less = PG_GETARG_BOOL(4);
408  int64 sum;
409 
410  if (offset < 0)
411  ereport(ERROR,
412  (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
413  errmsg("invalid preceding or following size in window function")));
414 
415  if (sub)
416  offset = -offset; /* cannot overflow */
417 
418  if (unlikely(pg_add_s64_overflow(base, offset, &sum)))
419  {
420  /*
421  * If sub is false, the true sum is surely more than val, so correct
422  * answer is the same as "less". If sub is true, the true sum is
423  * surely less than val, so the answer is "!less".
424  */
425  PG_RETURN_BOOL(sub ? !less : less);
426  }
427 
428  if (less)
429  PG_RETURN_BOOL(val <= sum);
430  else
431  PG_RETURN_BOOL(val >= sum);
432 }
433 
434 
435 /*----------------------------------------------------------
436  * Arithmetic operators on 64-bit integers.
437  *---------------------------------------------------------*/
438 
439 Datum
441 {
442  int64 arg = PG_GETARG_INT64(0);
443  int64 result;
444 
445  if (unlikely(arg == PG_INT64_MIN))
446  ereport(ERROR,
447  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
448  errmsg("bigint out of range")));
449  result = -arg;
450  PG_RETURN_INT64(result);
451 }
452 
453 Datum
455 {
456  int64 arg = PG_GETARG_INT64(0);
457 
459 }
460 
461 Datum
463 {
464  int64 arg1 = PG_GETARG_INT64(0);
465  int64 arg2 = PG_GETARG_INT64(1);
466  int64 result;
467 
468  if (unlikely(pg_add_s64_overflow(arg1, arg2, &result)))
469  ereport(ERROR,
470  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
471  errmsg("bigint out of range")));
472  PG_RETURN_INT64(result);
473 }
474 
475 Datum
477 {
478  int64 arg1 = PG_GETARG_INT64(0);
479  int64 arg2 = PG_GETARG_INT64(1);
480  int64 result;
481 
482  if (unlikely(pg_sub_s64_overflow(arg1, arg2, &result)))
483  ereport(ERROR,
484  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
485  errmsg("bigint out of range")));
486  PG_RETURN_INT64(result);
487 }
488 
489 Datum
491 {
492  int64 arg1 = PG_GETARG_INT64(0);
493  int64 arg2 = PG_GETARG_INT64(1);
494  int64 result;
495 
496  if (unlikely(pg_mul_s64_overflow(arg1, arg2, &result)))
497  ereport(ERROR,
498  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
499  errmsg("bigint out of range")));
500  PG_RETURN_INT64(result);
501 }
502 
503 Datum
505 {
506  int64 arg1 = PG_GETARG_INT64(0);
507  int64 arg2 = PG_GETARG_INT64(1);
508  int64 result;
509 
510  if (arg2 == 0)
511  {
512  ereport(ERROR,
513  (errcode(ERRCODE_DIVISION_BY_ZERO),
514  errmsg("division by zero")));
515  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
516  PG_RETURN_NULL();
517  }
518 
519  /*
520  * INT64_MIN / -1 is problematic, since the result can't be represented on
521  * a two's-complement machine. Some machines produce INT64_MIN, some
522  * produce zero, some throw an exception. We can dodge the problem by
523  * recognizing that division by -1 is the same as negation.
524  */
525  if (arg2 == -1)
526  {
527  if (unlikely(arg1 == PG_INT64_MIN))
528  ereport(ERROR,
529  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
530  errmsg("bigint out of range")));
531  result = -arg1;
532  PG_RETURN_INT64(result);
533  }
534 
535  /* No overflow is possible */
536 
537  result = arg1 / arg2;
538 
539  PG_RETURN_INT64(result);
540 }
541 
542 /* int8abs()
543  * Absolute value
544  */
545 Datum
547 {
548  int64 arg1 = PG_GETARG_INT64(0);
549  int64 result;
550 
551  if (unlikely(arg1 == PG_INT64_MIN))
552  ereport(ERROR,
553  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
554  errmsg("bigint out of range")));
555  result = (arg1 < 0) ? -arg1 : arg1;
556  PG_RETURN_INT64(result);
557 }
558 
559 /* int8mod()
560  * Modulo operation.
561  */
562 Datum
564 {
565  int64 arg1 = PG_GETARG_INT64(0);
566  int64 arg2 = PG_GETARG_INT64(1);
567 
568  if (unlikely(arg2 == 0))
569  {
570  ereport(ERROR,
571  (errcode(ERRCODE_DIVISION_BY_ZERO),
572  errmsg("division by zero")));
573  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
574  PG_RETURN_NULL();
575  }
576 
577  /*
578  * Some machines throw a floating-point exception for INT64_MIN % -1,
579  * which is a bit silly since the correct answer is perfectly
580  * well-defined, namely zero.
581  */
582  if (arg2 == -1)
583  PG_RETURN_INT64(0);
584 
585  /* No overflow is possible */
586 
587  PG_RETURN_INT64(arg1 % arg2);
588 }
589 
590 /*
591  * Greatest Common Divisor
592  *
593  * Returns the largest positive integer that exactly divides both inputs.
594  * Special cases:
595  * - gcd(x, 0) = gcd(0, x) = abs(x)
596  * because 0 is divisible by anything
597  * - gcd(0, 0) = 0
598  * complies with the previous definition and is a common convention
599  *
600  * Special care must be taken if either input is INT64_MIN ---
601  * gcd(0, INT64_MIN), gcd(INT64_MIN, 0) and gcd(INT64_MIN, INT64_MIN) are
602  * all equal to abs(INT64_MIN), which cannot be represented as a 64-bit signed
603  * integer.
604  */
605 static int64
606 int8gcd_internal(int64 arg1, int64 arg2)
607 {
608  int64 swap;
609  int64 a1,
610  a2;
611 
612  /*
613  * Put the greater absolute value in arg1.
614  *
615  * This would happen automatically in the loop below, but avoids an
616  * expensive modulo operation, and simplifies the special-case handling
617  * for INT64_MIN below.
618  *
619  * We do this in negative space in order to handle INT64_MIN.
620  */
621  a1 = (arg1 < 0) ? arg1 : -arg1;
622  a2 = (arg2 < 0) ? arg2 : -arg2;
623  if (a1 > a2)
624  {
625  swap = arg1;
626  arg1 = arg2;
627  arg2 = swap;
628  }
629 
630  /* Special care needs to be taken with INT64_MIN. See comments above. */
631  if (arg1 == PG_INT64_MIN)
632  {
633  if (arg2 == 0 || arg2 == PG_INT64_MIN)
634  ereport(ERROR,
635  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
636  errmsg("bigint out of range")));
637 
638  /*
639  * Some machines throw a floating-point exception for INT64_MIN % -1,
640  * which is a bit silly since the correct answer is perfectly
641  * well-defined, namely zero. Guard against this and just return the
642  * result, gcd(INT64_MIN, -1) = 1.
643  */
644  if (arg2 == -1)
645  return 1;
646  }
647 
648  /* Use the Euclidean algorithm to find the GCD */
649  while (arg2 != 0)
650  {
651  swap = arg2;
652  arg2 = arg1 % arg2;
653  arg1 = swap;
654  }
655 
656  /*
657  * Make sure the result is positive. (We know we don't have INT64_MIN
658  * anymore).
659  */
660  if (arg1 < 0)
661  arg1 = -arg1;
662 
663  return arg1;
664 }
665 
666 Datum
668 {
669  int64 arg1 = PG_GETARG_INT64(0);
670  int64 arg2 = PG_GETARG_INT64(1);
671  int64 result;
672 
673  result = int8gcd_internal(arg1, arg2);
674 
675  PG_RETURN_INT64(result);
676 }
677 
678 /*
679  * Least Common Multiple
680  */
681 Datum
683 {
684  int64 arg1 = PG_GETARG_INT64(0);
685  int64 arg2 = PG_GETARG_INT64(1);
686  int64 gcd;
687  int64 result;
688 
689  /*
690  * Handle lcm(x, 0) = lcm(0, x) = 0 as a special case. This prevents a
691  * division-by-zero error below when x is zero, and an overflow error from
692  * the GCD computation when x = INT64_MIN.
693  */
694  if (arg1 == 0 || arg2 == 0)
695  PG_RETURN_INT64(0);
696 
697  /* lcm(x, y) = abs(x / gcd(x, y) * y) */
698  gcd = int8gcd_internal(arg1, arg2);
699  arg1 = arg1 / gcd;
700 
701  if (unlikely(pg_mul_s64_overflow(arg1, arg2, &result)))
702  ereport(ERROR,
703  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
704  errmsg("bigint out of range")));
705 
706  /* If the result is INT64_MIN, it cannot be represented. */
707  if (unlikely(result == PG_INT64_MIN))
708  ereport(ERROR,
709  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
710  errmsg("bigint out of range")));
711 
712  if (result < 0)
713  result = -result;
714 
715  PG_RETURN_INT64(result);
716 }
717 
718 Datum
720 {
721  /*
722  * When int8 is pass-by-reference, we provide this special case to avoid
723  * palloc overhead for COUNT(): when called as an aggregate, we know that
724  * the argument is modifiable local storage, so just update it in-place.
725  * (If int8 is pass-by-value, then of course this is useless as well as
726  * incorrect, so just ifdef it out.)
727  */
728 #ifndef USE_FLOAT8_BYVAL /* controls int8 too */
729  if (AggCheckCallContext(fcinfo, NULL))
730  {
731  int64 *arg = (int64 *) PG_GETARG_POINTER(0);
732 
733  if (unlikely(pg_add_s64_overflow(*arg, 1, arg)))
734  ereport(ERROR,
735  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
736  errmsg("bigint out of range")));
737 
739  }
740  else
741 #endif
742  {
743  /* Not called as an aggregate, so just do it the dumb way */
744  int64 arg = PG_GETARG_INT64(0);
745  int64 result;
746 
747  if (unlikely(pg_add_s64_overflow(arg, 1, &result)))
748  ereport(ERROR,
749  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
750  errmsg("bigint out of range")));
751 
752  PG_RETURN_INT64(result);
753  }
754 }
755 
756 Datum
758 {
759  /*
760  * When int8 is pass-by-reference, we provide this special case to avoid
761  * palloc overhead for COUNT(): when called as an aggregate, we know that
762  * the argument is modifiable local storage, so just update it in-place.
763  * (If int8 is pass-by-value, then of course this is useless as well as
764  * incorrect, so just ifdef it out.)
765  */
766 #ifndef USE_FLOAT8_BYVAL /* controls int8 too */
767  if (AggCheckCallContext(fcinfo, NULL))
768  {
769  int64 *arg = (int64 *) PG_GETARG_POINTER(0);
770 
771  if (unlikely(pg_sub_s64_overflow(*arg, 1, arg)))
772  ereport(ERROR,
773  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
774  errmsg("bigint out of range")));
776  }
777  else
778 #endif
779  {
780  /* Not called as an aggregate, so just do it the dumb way */
781  int64 arg = PG_GETARG_INT64(0);
782  int64 result;
783 
784  if (unlikely(pg_sub_s64_overflow(arg, 1, &result)))
785  ereport(ERROR,
786  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
787  errmsg("bigint out of range")));
788 
789  PG_RETURN_INT64(result);
790  }
791 }
792 
793 
794 /*
795  * These functions are exactly like int8inc/int8dec but are used for
796  * aggregates that count only non-null values. Since the functions are
797  * declared strict, the null checks happen before we ever get here, and all we
798  * need do is increment the state value. We could actually make these pg_proc
799  * entries point right at int8inc/int8dec, but then the opr_sanity regression
800  * test would complain about mismatched entries for a built-in function.
801  */
802 
803 Datum
805 {
806  return int8inc(fcinfo);
807 }
808 
809 Datum
811 {
812  return int8inc(fcinfo);
813 }
814 
815 Datum
817 {
818  return int8dec(fcinfo);
819 }
820 
821 /*
822  * int8inc_support
823  * prosupport function for int8inc() and int8inc_any()
824  */
825 Datum
827 {
828  Node *rawreq = (Node *) PG_GETARG_POINTER(0);
829 
830  if (IsA(rawreq, SupportRequestWFuncMonotonic))
831  {
834  int frameOptions = req->window_clause->frameOptions;
835 
836  /* No ORDER BY clause then all rows are peers */
837  if (req->window_clause->orderClause == NIL)
838  monotonic = MONOTONICFUNC_BOTH;
839  else
840  {
841  /*
842  * Otherwise take into account the frame options. When the frame
843  * bound is the start of the window then the resulting value can
844  * never decrease, therefore is monotonically increasing
845  */
846  if (frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING)
847  monotonic |= MONOTONICFUNC_INCREASING;
848 
849  /*
850  * Likewise, if the frame bound is the end of the window then the
851  * resulting value can never decrease.
852  */
853  if (frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING)
854  monotonic |= MONOTONICFUNC_DECREASING;
855  }
856 
857  req->monotonic = monotonic;
858  PG_RETURN_POINTER(req);
859  }
860 
861  PG_RETURN_POINTER(NULL);
862 }
863 
864 
865 Datum
867 {
868  int64 arg1 = PG_GETARG_INT64(0);
869  int64 arg2 = PG_GETARG_INT64(1);
870  int64 result;
871 
872  result = ((arg1 > arg2) ? arg1 : arg2);
873 
874  PG_RETURN_INT64(result);
875 }
876 
877 Datum
879 {
880  int64 arg1 = PG_GETARG_INT64(0);
881  int64 arg2 = PG_GETARG_INT64(1);
882  int64 result;
883 
884  result = ((arg1 < arg2) ? arg1 : arg2);
885 
886  PG_RETURN_INT64(result);
887 }
888 
889 Datum
891 {
892  int64 arg1 = PG_GETARG_INT64(0);
893  int32 arg2 = PG_GETARG_INT32(1);
894  int64 result;
895 
896  if (unlikely(pg_add_s64_overflow(arg1, (int64) arg2, &result)))
897  ereport(ERROR,
898  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
899  errmsg("bigint out of range")));
900  PG_RETURN_INT64(result);
901 }
902 
903 Datum
905 {
906  int64 arg1 = PG_GETARG_INT64(0);
907  int32 arg2 = PG_GETARG_INT32(1);
908  int64 result;
909 
910  if (unlikely(pg_sub_s64_overflow(arg1, (int64) arg2, &result)))
911  ereport(ERROR,
912  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
913  errmsg("bigint out of range")));
914  PG_RETURN_INT64(result);
915 }
916 
917 Datum
919 {
920  int64 arg1 = PG_GETARG_INT64(0);
921  int32 arg2 = PG_GETARG_INT32(1);
922  int64 result;
923 
924  if (unlikely(pg_mul_s64_overflow(arg1, (int64) arg2, &result)))
925  ereport(ERROR,
926  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
927  errmsg("bigint out of range")));
928  PG_RETURN_INT64(result);
929 }
930 
931 Datum
933 {
934  int64 arg1 = PG_GETARG_INT64(0);
935  int32 arg2 = PG_GETARG_INT32(1);
936  int64 result;
937 
938  if (arg2 == 0)
939  {
940  ereport(ERROR,
941  (errcode(ERRCODE_DIVISION_BY_ZERO),
942  errmsg("division by zero")));
943  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
944  PG_RETURN_NULL();
945  }
946 
947  /*
948  * INT64_MIN / -1 is problematic, since the result can't be represented on
949  * a two's-complement machine. Some machines produce INT64_MIN, some
950  * produce zero, some throw an exception. We can dodge the problem by
951  * recognizing that division by -1 is the same as negation.
952  */
953  if (arg2 == -1)
954  {
955  if (unlikely(arg1 == PG_INT64_MIN))
956  ereport(ERROR,
957  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
958  errmsg("bigint out of range")));
959  result = -arg1;
960  PG_RETURN_INT64(result);
961  }
962 
963  /* No overflow is possible */
964 
965  result = arg1 / arg2;
966 
967  PG_RETURN_INT64(result);
968 }
969 
970 Datum
972 {
973  int32 arg1 = PG_GETARG_INT32(0);
974  int64 arg2 = PG_GETARG_INT64(1);
975  int64 result;
976 
977  if (unlikely(pg_add_s64_overflow((int64) arg1, arg2, &result)))
978  ereport(ERROR,
979  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
980  errmsg("bigint out of range")));
981  PG_RETURN_INT64(result);
982 }
983 
984 Datum
986 {
987  int32 arg1 = PG_GETARG_INT32(0);
988  int64 arg2 = PG_GETARG_INT64(1);
989  int64 result;
990 
991  if (unlikely(pg_sub_s64_overflow((int64) arg1, arg2, &result)))
992  ereport(ERROR,
993  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
994  errmsg("bigint out of range")));
995  PG_RETURN_INT64(result);
996 }
997 
998 Datum
1000 {
1001  int32 arg1 = PG_GETARG_INT32(0);
1002  int64 arg2 = PG_GETARG_INT64(1);
1003  int64 result;
1004 
1005  if (unlikely(pg_mul_s64_overflow((int64) arg1, arg2, &result)))
1006  ereport(ERROR,
1007  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1008  errmsg("bigint out of range")));
1009  PG_RETURN_INT64(result);
1010 }
1011 
1012 Datum
1014 {
1015  int32 arg1 = PG_GETARG_INT32(0);
1016  int64 arg2 = PG_GETARG_INT64(1);
1017 
1018  if (unlikely(arg2 == 0))
1019  {
1020  ereport(ERROR,
1021  (errcode(ERRCODE_DIVISION_BY_ZERO),
1022  errmsg("division by zero")));
1023  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
1024  PG_RETURN_NULL();
1025  }
1026 
1027  /* No overflow is possible */
1028  PG_RETURN_INT64((int64) arg1 / arg2);
1029 }
1030 
1031 Datum
1033 {
1034  int64 arg1 = PG_GETARG_INT64(0);
1035  int16 arg2 = PG_GETARG_INT16(1);
1036  int64 result;
1037 
1038  if (unlikely(pg_add_s64_overflow(arg1, (int64) arg2, &result)))
1039  ereport(ERROR,
1040  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1041  errmsg("bigint out of range")));
1042  PG_RETURN_INT64(result);
1043 }
1044 
1045 Datum
1047 {
1048  int64 arg1 = PG_GETARG_INT64(0);
1049  int16 arg2 = PG_GETARG_INT16(1);
1050  int64 result;
1051 
1052  if (unlikely(pg_sub_s64_overflow(arg1, (int64) arg2, &result)))
1053  ereport(ERROR,
1054  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1055  errmsg("bigint out of range")));
1056  PG_RETURN_INT64(result);
1057 }
1058 
1059 Datum
1061 {
1062  int64 arg1 = PG_GETARG_INT64(0);
1063  int16 arg2 = PG_GETARG_INT16(1);
1064  int64 result;
1065 
1066  if (unlikely(pg_mul_s64_overflow(arg1, (int64) arg2, &result)))
1067  ereport(ERROR,
1068  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1069  errmsg("bigint out of range")));
1070  PG_RETURN_INT64(result);
1071 }
1072 
1073 Datum
1075 {
1076  int64 arg1 = PG_GETARG_INT64(0);
1077  int16 arg2 = PG_GETARG_INT16(1);
1078  int64 result;
1079 
1080  if (unlikely(arg2 == 0))
1081  {
1082  ereport(ERROR,
1083  (errcode(ERRCODE_DIVISION_BY_ZERO),
1084  errmsg("division by zero")));
1085  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
1086  PG_RETURN_NULL();
1087  }
1088 
1089  /*
1090  * INT64_MIN / -1 is problematic, since the result can't be represented on
1091  * a two's-complement machine. Some machines produce INT64_MIN, some
1092  * produce zero, some throw an exception. We can dodge the problem by
1093  * recognizing that division by -1 is the same as negation.
1094  */
1095  if (arg2 == -1)
1096  {
1097  if (unlikely(arg1 == PG_INT64_MIN))
1098  ereport(ERROR,
1099  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1100  errmsg("bigint out of range")));
1101  result = -arg1;
1102  PG_RETURN_INT64(result);
1103  }
1104 
1105  /* No overflow is possible */
1106 
1107  result = arg1 / arg2;
1108 
1109  PG_RETURN_INT64(result);
1110 }
1111 
1112 Datum
1114 {
1115  int16 arg1 = PG_GETARG_INT16(0);
1116  int64 arg2 = PG_GETARG_INT64(1);
1117  int64 result;
1118 
1119  if (unlikely(pg_add_s64_overflow((int64) arg1, arg2, &result)))
1120  ereport(ERROR,
1121  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1122  errmsg("bigint out of range")));
1123  PG_RETURN_INT64(result);
1124 }
1125 
1126 Datum
1128 {
1129  int16 arg1 = PG_GETARG_INT16(0);
1130  int64 arg2 = PG_GETARG_INT64(1);
1131  int64 result;
1132 
1133  if (unlikely(pg_sub_s64_overflow((int64) arg1, arg2, &result)))
1134  ereport(ERROR,
1135  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1136  errmsg("bigint out of range")));
1137  PG_RETURN_INT64(result);
1138 }
1139 
1140 Datum
1142 {
1143  int16 arg1 = PG_GETARG_INT16(0);
1144  int64 arg2 = PG_GETARG_INT64(1);
1145  int64 result;
1146 
1147  if (unlikely(pg_mul_s64_overflow((int64) arg1, arg2, &result)))
1148  ereport(ERROR,
1149  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1150  errmsg("bigint out of range")));
1151  PG_RETURN_INT64(result);
1152 }
1153 
1154 Datum
1156 {
1157  int16 arg1 = PG_GETARG_INT16(0);
1158  int64 arg2 = PG_GETARG_INT64(1);
1159 
1160  if (unlikely(arg2 == 0))
1161  {
1162  ereport(ERROR,
1163  (errcode(ERRCODE_DIVISION_BY_ZERO),
1164  errmsg("division by zero")));
1165  /* ensure compiler realizes we mustn't reach the division (gcc bug) */
1166  PG_RETURN_NULL();
1167  }
1168 
1169  /* No overflow is possible */
1170  PG_RETURN_INT64((int64) arg1 / arg2);
1171 }
1172 
1173 /* Binary arithmetics
1174  *
1175  * int8and - returns arg1 & arg2
1176  * int8or - returns arg1 | arg2
1177  * int8xor - returns arg1 # arg2
1178  * int8not - returns ~arg1
1179  * int8shl - returns arg1 << arg2
1180  * int8shr - returns arg1 >> arg2
1181  */
1182 
1183 Datum
1185 {
1186  int64 arg1 = PG_GETARG_INT64(0);
1187  int64 arg2 = PG_GETARG_INT64(1);
1188 
1189  PG_RETURN_INT64(arg1 & arg2);
1190 }
1191 
1192 Datum
1194 {
1195  int64 arg1 = PG_GETARG_INT64(0);
1196  int64 arg2 = PG_GETARG_INT64(1);
1197 
1198  PG_RETURN_INT64(arg1 | arg2);
1199 }
1200 
1201 Datum
1203 {
1204  int64 arg1 = PG_GETARG_INT64(0);
1205  int64 arg2 = PG_GETARG_INT64(1);
1206 
1207  PG_RETURN_INT64(arg1 ^ arg2);
1208 }
1209 
1210 Datum
1212 {
1213  int64 arg1 = PG_GETARG_INT64(0);
1214 
1215  PG_RETURN_INT64(~arg1);
1216 }
1217 
1218 Datum
1220 {
1221  int64 arg1 = PG_GETARG_INT64(0);
1222  int32 arg2 = PG_GETARG_INT32(1);
1223 
1224  PG_RETURN_INT64(arg1 << arg2);
1225 }
1226 
1227 Datum
1229 {
1230  int64 arg1 = PG_GETARG_INT64(0);
1231  int32 arg2 = PG_GETARG_INT32(1);
1232 
1233  PG_RETURN_INT64(arg1 >> arg2);
1234 }
1235 
1236 /*----------------------------------------------------------
1237  * Conversion operators.
1238  *---------------------------------------------------------*/
1239 
1240 Datum
1242 {
1243  int32 arg = PG_GETARG_INT32(0);
1244 
1245  PG_RETURN_INT64((int64) arg);
1246 }
1247 
1248 Datum
1250 {
1251  int64 arg = PG_GETARG_INT64(0);
1252 
1254  ereport(ERROR,
1255  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1256  errmsg("integer out of range")));
1257 
1259 }
1260 
1261 Datum
1263 {
1264  int16 arg = PG_GETARG_INT16(0);
1265 
1266  PG_RETURN_INT64((int64) arg);
1267 }
1268 
1269 Datum
1271 {
1272  int64 arg = PG_GETARG_INT64(0);
1273 
1275  ereport(ERROR,
1276  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1277  errmsg("smallint out of range")));
1278 
1280 }
1281 
1282 Datum
1284 {
1285  int64 arg = PG_GETARG_INT64(0);
1286  float8 result;
1287 
1288  result = arg;
1289 
1290  PG_RETURN_FLOAT8(result);
1291 }
1292 
1293 /* dtoi8()
1294  * Convert float8 to 8-byte integer.
1295  */
1296 Datum
1298 {
1299  float8 num = PG_GETARG_FLOAT8(0);
1300 
1301  /*
1302  * Get rid of any fractional part in the input. This is so we don't fail
1303  * on just-out-of-range values that would round into range. Note
1304  * assumption that rint() will pass through a NaN or Inf unchanged.
1305  */
1306  num = rint(num);
1307 
1308  /* Range check */
1309  if (unlikely(isnan(num) || !FLOAT8_FITS_IN_INT64(num)))
1310  ereport(ERROR,
1311  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1312  errmsg("bigint out of range")));
1313 
1314  PG_RETURN_INT64((int64) num);
1315 }
1316 
1317 Datum
1319 {
1320  int64 arg = PG_GETARG_INT64(0);
1321  float4 result;
1322 
1323  result = arg;
1324 
1325  PG_RETURN_FLOAT4(result);
1326 }
1327 
1328 /* ftoi8()
1329  * Convert float4 to 8-byte integer.
1330  */
1331 Datum
1333 {
1334  float4 num = PG_GETARG_FLOAT4(0);
1335 
1336  /*
1337  * Get rid of any fractional part in the input. This is so we don't fail
1338  * on just-out-of-range values that would round into range. Note
1339  * assumption that rint() will pass through a NaN or Inf unchanged.
1340  */
1341  num = rint(num);
1342 
1343  /* Range check */
1344  if (unlikely(isnan(num) || !FLOAT4_FITS_IN_INT64(num)))
1345  ereport(ERROR,
1346  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1347  errmsg("bigint out of range")));
1348 
1349  PG_RETURN_INT64((int64) num);
1350 }
1351 
1352 Datum
1354 {
1355  int64 arg = PG_GETARG_INT64(0);
1356 
1357  if (unlikely(arg < 0) || unlikely(arg > PG_UINT32_MAX))
1358  ereport(ERROR,
1359  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1360  errmsg("OID out of range")));
1361 
1362  PG_RETURN_OID((Oid) arg);
1363 }
1364 
1365 Datum
1367 {
1368  Oid arg = PG_GETARG_OID(0);
1369 
1370  PG_RETURN_INT64((int64) arg);
1371 }
1372 
1373 /*
1374  * non-persistent numeric series generator
1375  */
1376 Datum
1378 {
1379  return generate_series_step_int8(fcinfo);
1380 }
1381 
1382 Datum
1384 {
1385  FuncCallContext *funcctx;
1386  generate_series_fctx *fctx;
1387  int64 result;
1388  MemoryContext oldcontext;
1389 
1390  /* stuff done only on the first call of the function */
1391  if (SRF_IS_FIRSTCALL())
1392  {
1393  int64 start = PG_GETARG_INT64(0);
1394  int64 finish = PG_GETARG_INT64(1);
1395  int64 step = 1;
1396 
1397  /* see if we were given an explicit step size */
1398  if (PG_NARGS() == 3)
1399  step = PG_GETARG_INT64(2);
1400  if (step == 0)
1401  ereport(ERROR,
1402  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1403  errmsg("step size cannot equal zero")));
1404 
1405  /* create a function context for cross-call persistence */
1406  funcctx = SRF_FIRSTCALL_INIT();
1407 
1408  /*
1409  * switch to memory context appropriate for multiple function calls
1410  */
1411  oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
1412 
1413  /* allocate memory for user context */
1414  fctx = (generate_series_fctx *) palloc(sizeof(generate_series_fctx));
1415 
1416  /*
1417  * Use fctx to keep state from call to call. Seed current with the
1418  * original start value
1419  */
1420  fctx->current = start;
1421  fctx->finish = finish;
1422  fctx->step = step;
1423 
1424  funcctx->user_fctx = fctx;
1425  MemoryContextSwitchTo(oldcontext);
1426  }
1427 
1428  /* stuff done on every call of the function */
1429  funcctx = SRF_PERCALL_SETUP();
1430 
1431  /*
1432  * get the saved state and use current as the result for this iteration
1433  */
1434  fctx = funcctx->user_fctx;
1435  result = fctx->current;
1436 
1437  if ((fctx->step > 0 && fctx->current <= fctx->finish) ||
1438  (fctx->step < 0 && fctx->current >= fctx->finish))
1439  {
1440  /*
1441  * Increment current in preparation for next iteration. If next-value
1442  * computation overflows, this is the final result.
1443  */
1444  if (pg_add_s64_overflow(fctx->current, fctx->step, &fctx->current))
1445  fctx->step = 0;
1446 
1447  /* do when there is more left to send */
1448  SRF_RETURN_NEXT(funcctx, Int64GetDatum(result));
1449  }
1450  else
1451  /* do when there is no more left */
1452  SRF_RETURN_DONE(funcctx);
1453 }
1454 
1455 /*
1456  * Planner support function for generate_series(int8, int8 [, int8])
1457  */
1458 Datum
1460 {
1461  Node *rawreq = (Node *) PG_GETARG_POINTER(0);
1462  Node *ret = NULL;
1463 
1464  if (IsA(rawreq, SupportRequestRows))
1465  {
1466  /* Try to estimate the number of rows returned */
1467  SupportRequestRows *req = (SupportRequestRows *) rawreq;
1468 
1469  if (is_funcclause(req->node)) /* be paranoid */
1470  {
1471  List *args = ((FuncExpr *) req->node)->args;
1472  Node *arg1,
1473  *arg2,
1474  *arg3;
1475 
1476  /* We can use estimated argument values here */
1478  arg2 = estimate_expression_value(req->root, lsecond(args));
1479  if (list_length(args) >= 3)
1480  arg3 = estimate_expression_value(req->root, lthird(args));
1481  else
1482  arg3 = NULL;
1483 
1484  /*
1485  * If any argument is constant NULL, we can safely assume that
1486  * zero rows are returned. Otherwise, if they're all non-NULL
1487  * constants, we can calculate the number of rows that will be
1488  * returned. Use double arithmetic to avoid overflow hazards.
1489  */
1490  if ((IsA(arg1, Const) &&
1491  ((Const *) arg1)->constisnull) ||
1492  (IsA(arg2, Const) &&
1493  ((Const *) arg2)->constisnull) ||
1494  (arg3 != NULL && IsA(arg3, Const) &&
1495  ((Const *) arg3)->constisnull))
1496  {
1497  req->rows = 0;
1498  ret = (Node *) req;
1499  }
1500  else if (IsA(arg1, Const) &&
1501  IsA(arg2, Const) &&
1502  (arg3 == NULL || IsA(arg3, Const)))
1503  {
1504  double start,
1505  finish,
1506  step;
1507 
1508  start = DatumGetInt64(((Const *) arg1)->constvalue);
1509  finish = DatumGetInt64(((Const *) arg2)->constvalue);
1510  step = arg3 ? DatumGetInt64(((Const *) arg3)->constvalue) : 1;
1511 
1512  /* This equation works for either sign of step */
1513  if (step != 0)
1514  {
1515  req->rows = floor((finish - start + step) / step);
1516  ret = (Node *) req;
1517  }
1518  }
1519  }
1520  }
1521 
1522  PG_RETURN_POINTER(ret);
1523 }
#define MAXINT8LEN
Definition: builtins.h:22
#define PG_INT32_MAX
Definition: c.h:589
signed short int16
Definition: c.h:493
#define PG_UINT32_MAX
Definition: c.h:590
#define FLOAT4_FITS_IN_INT64(num)
Definition: c.h:1086
signed int int32
Definition: c.h:494
double float8
Definition: c.h:630
#define FLOAT8_FITS_IN_INT64(num)
Definition: c.h:1092
#define PG_INT16_MIN
Definition: c.h:585
#define PG_INT64_MIN
Definition: c.h:591
#define unlikely(x)
Definition: c.h:311
float float4
Definition: c.h:629
#define PG_INT32_MIN
Definition: c.h:588
#define PG_INT16_MAX
Definition: c.h:586
Node * estimate_expression_value(PlannerInfo *root, Node *node)
Definition: clauses.c:2395
int errcode(int sqlerrcode)
Definition: elog.c:857
int errmsg(const char *fmt,...)
Definition: elog.c:1070
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
Datum Int64GetDatum(int64 X)
Definition: fmgr.c:1807
#define PG_GETARG_OID(n)
Definition: fmgr.h:275
#define PG_RETURN_BYTEA_P(x)
Definition: fmgr.h:371
#define PG_GETARG_FLOAT8(n)
Definition: fmgr.h:282
#define PG_RETURN_FLOAT8(x)
Definition: fmgr.h:367
#define PG_GETARG_POINTER(n)
Definition: fmgr.h:276
#define PG_RETURN_CSTRING(x)
Definition: fmgr.h:362
#define PG_RETURN_INT64(x)
Definition: fmgr.h:368
#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 PG_GETARG_FLOAT4(n)
Definition: fmgr.h:281
#define PG_RETURN_POINTER(x)
Definition: fmgr.h:361
#define PG_RETURN_FLOAT4(x)
Definition: fmgr.h:366
#define PG_RETURN_OID(x)
Definition: fmgr.h:360
#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:304
#define SRF_PERCALL_SETUP()
Definition: funcapi.h:308
#define SRF_RETURN_NEXT(_funcctx, _result)
Definition: funcapi.h:310
#define SRF_FIRSTCALL_INIT()
Definition: funcapi.h:306
#define SRF_RETURN_DONE(_funcctx)
Definition: funcapi.h:328
return str start
static const FormData_pg_attribute a1
Definition: heap.c:142
static const FormData_pg_attribute a2
Definition: heap.c:156
long val
Definition: informix.c:670
Datum int8lcm(PG_FUNCTION_ARGS)
Definition: int8.c:682
Datum int84div(PG_FUNCTION_ARGS)
Definition: int8.c:932
Datum int8ge(PG_FUNCTION_ARGS)
Definition: int8.c:158
Datum i8tooid(PG_FUNCTION_ARGS)
Definition: int8.c:1353
Datum int8dec_any(PG_FUNCTION_ARGS)
Definition: int8.c:816
Datum in_range_int8_int8(PG_FUNCTION_ARGS)
Definition: int8.c:401
Datum int8abs(PG_FUNCTION_ARGS)
Definition: int8.c:546
Datum int48ge(PG_FUNCTION_ARGS)
Definition: int8.c:272
Datum int82le(PG_FUNCTION_ARGS)
Definition: int8.c:320
Datum int28lt(PG_FUNCTION_ARGS)
Definition: int8.c:359
Datum int84pl(PG_FUNCTION_ARGS)
Definition: int8.c:890
Datum int48pl(PG_FUNCTION_ARGS)
Definition: int8.c:971
Datum int8out(PG_FUNCTION_ARGS)
Definition: int8.c:61
Datum int82mi(PG_FUNCTION_ARGS)
Definition: int8.c:1046
Datum int84gt(PG_FUNCTION_ARGS)
Definition: int8.c:197
Datum int28ne(PG_FUNCTION_ARGS)
Definition: int8.c:350
Datum int8send(PG_FUNCTION_ARGS)
Definition: int8.c:94
Datum int8ne(PG_FUNCTION_ARGS)
Definition: int8.c:122
Datum int84(PG_FUNCTION_ARGS)
Definition: int8.c:1249
Datum int8mul(PG_FUNCTION_ARGS)
Definition: int8.c:490
Datum int84ge(PG_FUNCTION_ARGS)
Definition: int8.c:215
Datum int48lt(PG_FUNCTION_ARGS)
Definition: int8.c:245
Datum int8gcd(PG_FUNCTION_ARGS)
Definition: int8.c:667
Datum int8not(PG_FUNCTION_ARGS)
Definition: int8.c:1211
Datum int8le(PG_FUNCTION_ARGS)
Definition: int8.c:149
Datum int8lt(PG_FUNCTION_ARGS)
Definition: int8.c:131
Datum int48eq(PG_FUNCTION_ARGS)
Definition: int8.c:227
Datum generate_series_step_int8(PG_FUNCTION_ARGS)
Definition: int8.c:1383
Datum generate_series_int8(PG_FUNCTION_ARGS)
Definition: int8.c:1377
Datum int8eq(PG_FUNCTION_ARGS)
Definition: int8.c:113
Datum generate_series_int8_support(PG_FUNCTION_ARGS)
Definition: int8.c:1459
Datum int82div(PG_FUNCTION_ARGS)
Definition: int8.c:1074
Datum int48le(PG_FUNCTION_ARGS)
Definition: int8.c:263
Datum int28gt(PG_FUNCTION_ARGS)
Definition: int8.c:368
Datum i8tod(PG_FUNCTION_ARGS)
Definition: int8.c:1283
Datum int8inc_support(PG_FUNCTION_ARGS)
Definition: int8.c:826
Datum int8in(PG_FUNCTION_ARGS)
Definition: int8.c:50
Datum int8mod(PG_FUNCTION_ARGS)
Definition: int8.c:563
Datum oidtoi8(PG_FUNCTION_ARGS)
Definition: int8.c:1366
Datum int28pl(PG_FUNCTION_ARGS)
Definition: int8.c:1113
Datum int84eq(PG_FUNCTION_ARGS)
Definition: int8.c:170
Datum int28div(PG_FUNCTION_ARGS)
Definition: int8.c:1155
Datum int8pl(PG_FUNCTION_ARGS)
Definition: int8.c:462
Datum int8larger(PG_FUNCTION_ARGS)
Definition: int8.c:866
Datum int8xor(PG_FUNCTION_ARGS)
Definition: int8.c:1202
Datum int28(PG_FUNCTION_ARGS)
Definition: int8.c:1262
Datum int8gt(PG_FUNCTION_ARGS)
Definition: int8.c:140
Datum int8div(PG_FUNCTION_ARGS)
Definition: int8.c:504
Datum int48ne(PG_FUNCTION_ARGS)
Definition: int8.c:236
Datum int82pl(PG_FUNCTION_ARGS)
Definition: int8.c:1032
Datum int48mul(PG_FUNCTION_ARGS)
Definition: int8.c:999
Datum int48mi(PG_FUNCTION_ARGS)
Definition: int8.c:985
Datum int8up(PG_FUNCTION_ARGS)
Definition: int8.c:454
Datum int8smaller(PG_FUNCTION_ARGS)
Definition: int8.c:878
Datum int28le(PG_FUNCTION_ARGS)
Definition: int8.c:377
static int64 int8gcd_internal(int64 arg1, int64 arg2)
Definition: int8.c:606
Datum int82lt(PG_FUNCTION_ARGS)
Definition: int8.c:302
Datum int82gt(PG_FUNCTION_ARGS)
Definition: int8.c:311
Datum int82mul(PG_FUNCTION_ARGS)
Definition: int8.c:1060
Datum dtoi8(PG_FUNCTION_ARGS)
Definition: int8.c:1297
Datum int82ge(PG_FUNCTION_ARGS)
Definition: int8.c:329
Datum int48div(PG_FUNCTION_ARGS)
Definition: int8.c:1013
Datum int8inc_any(PG_FUNCTION_ARGS)
Definition: int8.c:804
Datum int48gt(PG_FUNCTION_ARGS)
Definition: int8.c:254
Datum int8or(PG_FUNCTION_ARGS)
Definition: int8.c:1193
Datum int48(PG_FUNCTION_ARGS)
Definition: int8.c:1241
Datum int8shr(PG_FUNCTION_ARGS)
Definition: int8.c:1228
Datum int8recv(PG_FUNCTION_ARGS)
Definition: int8.c:83
Datum int84le(PG_FUNCTION_ARGS)
Definition: int8.c:206
Datum int8dec(PG_FUNCTION_ARGS)
Definition: int8.c:757
Datum int84mi(PG_FUNCTION_ARGS)
Definition: int8.c:904
Datum int82ne(PG_FUNCTION_ARGS)
Definition: int8.c:293
Datum int82(PG_FUNCTION_ARGS)
Definition: int8.c:1270
Datum int8inc_float8_float8(PG_FUNCTION_ARGS)
Definition: int8.c:810
Datum int28ge(PG_FUNCTION_ARGS)
Definition: int8.c:386
Datum int8shl(PG_FUNCTION_ARGS)
Definition: int8.c:1219
Datum i8tof(PG_FUNCTION_ARGS)
Definition: int8.c:1318
Datum int82eq(PG_FUNCTION_ARGS)
Definition: int8.c:284
Datum int84ne(PG_FUNCTION_ARGS)
Definition: int8.c:179
Datum int8mi(PG_FUNCTION_ARGS)
Definition: int8.c:476
Datum ftoi8(PG_FUNCTION_ARGS)
Definition: int8.c:1332
Datum int8and(PG_FUNCTION_ARGS)
Definition: int8.c:1184
Datum int84mul(PG_FUNCTION_ARGS)
Definition: int8.c:918
Datum int8um(PG_FUNCTION_ARGS)
Definition: int8.c:440
Datum int28mi(PG_FUNCTION_ARGS)
Definition: int8.c:1127
Datum int84lt(PG_FUNCTION_ARGS)
Definition: int8.c:188
Datum int28eq(PG_FUNCTION_ARGS)
Definition: int8.c:341
Datum int28mul(PG_FUNCTION_ARGS)
Definition: int8.c:1141
Datum int8inc(PG_FUNCTION_ARGS)
Definition: int8.c:719
static bool pg_mul_s64_overflow(int64 a, int64 b, int64 *result)
Definition: int.h:219
static bool pg_sub_s64_overflow(int64 a, int64 b, int64 *result)
Definition: int.h:188
static bool pg_add_s64_overflow(int64 a, int64 b, int64 *result)
Definition: int.h:161
void * palloc(Size size)
Definition: mcxt.c:1316
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
Definition: nodeAgg.c:4511
static bool is_funcclause(const void *clause)
Definition: nodeFuncs.h:67
#define IsA(nodeptr, _type_)
Definition: nodes.h:158
int64 pg_strtoint64_safe(const char *s, Node *escontext)
Definition: numutils.c:651
int pg_lltoa(int64 value, char *a)
Definition: numutils.c:1229
#define FRAMEOPTION_START_UNBOUNDED_PRECEDING
Definition: parsenodes.h:586
#define FRAMEOPTION_END_UNBOUNDED_FOLLOWING
Definition: parsenodes.h:589
void * arg
const void size_t len
static int list_length(const List *l)
Definition: pg_list.h:152
#define NIL
Definition: pg_list.h:68
#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:73
MonotonicFunction
Definition: plannodes.h:1586
@ MONOTONICFUNC_NONE
Definition: plannodes.h:1587
@ MONOTONICFUNC_DECREASING
Definition: plannodes.h:1589
@ MONOTONICFUNC_INCREASING
Definition: plannodes.h:1588
@ MONOTONICFUNC_BOTH
Definition: plannodes.h:1590
static int64 DatumGetInt64(Datum X)
Definition: postgres.h:385
uintptr_t Datum
Definition: postgres.h:64
unsigned int Oid
Definition: postgres_ext.h:31
void pq_begintypsend(StringInfo buf)
Definition: pqformat.c:326
int64 pq_getmsgint64(StringInfo msg)
Definition: pqformat.c:453
bytea * pq_endtypsend(StringInfo buf)
Definition: pqformat.c:346
static void pq_sendint64(StringInfo buf, uint64 i)
Definition: pqformat.h:152
MemoryContextSwitchTo(old_ctx)
StringInfoData * StringInfo
Definition: stringinfo.h:54
void * user_fctx
Definition: funcapi.h:82
MemoryContext multi_call_memory_ctx
Definition: funcapi.h:101
Definition: pg_list.h:54
Definition: nodes.h:129
struct PlannerInfo * root
Definition: supportnodes.h:163
struct WindowClause * window_clause
Definition: supportnodes.h:296
MonotonicFunction monotonic
Definition: supportnodes.h:299
List * orderClause
Definition: parsenodes.h:1548
int32 current
Definition: int.c:49
int32 finish
Definition: int.c:50
static uint32 gcd(uint32 a, uint32 b)