78 #define MUL_GUARD_DIGITS 4
79 #define DIV_GUARD_DIGITS 8
88 #define MUL_GUARD_DIGITS 3
89 #define DIV_GUARD_DIGITS 6
96 #define HALF_NBASE 5000
98 #define MUL_GUARD_DIGITS 2
99 #define DIV_GUARD_DIGITS 4
164 #define NUMERIC_SIGN_MASK 0xC000
165 #define NUMERIC_POS 0x0000
166 #define NUMERIC_NEG 0x4000
167 #define NUMERIC_SHORT 0x8000
168 #define NUMERIC_SPECIAL 0xC000
170 #define NUMERIC_FLAGBITS(n) ((n)->choice.n_header & NUMERIC_SIGN_MASK)
171 #define NUMERIC_IS_SHORT(n) (NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)
172 #define NUMERIC_IS_SPECIAL(n) (NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)
174 #define NUMERIC_HDRSZ (VARHDRSZ + sizeof(uint16) + sizeof(int16))
175 #define NUMERIC_HDRSZ_SHORT (VARHDRSZ + sizeof(uint16))
182 #define NUMERIC_HEADER_IS_SHORT(n) (((n)->choice.n_header & 0x8000) != 0)
183 #define NUMERIC_HEADER_SIZE(n) \
184 (VARHDRSZ + sizeof(uint16) + \
185 (NUMERIC_HEADER_IS_SHORT(n) ? 0 : sizeof(int16)))
196 #define NUMERIC_EXT_SIGN_MASK 0xF000
197 #define NUMERIC_NAN 0xC000
198 #define NUMERIC_PINF 0xD000
199 #define NUMERIC_NINF 0xF000
200 #define NUMERIC_INF_SIGN_MASK 0x2000
202 #define NUMERIC_EXT_FLAGBITS(n) ((n)->choice.n_header & NUMERIC_EXT_SIGN_MASK)
203 #define NUMERIC_IS_NAN(n) ((n)->choice.n_header == NUMERIC_NAN)
204 #define NUMERIC_IS_PINF(n) ((n)->choice.n_header == NUMERIC_PINF)
205 #define NUMERIC_IS_NINF(n) ((n)->choice.n_header == NUMERIC_NINF)
206 #define NUMERIC_IS_INF(n) \
207 (((n)->choice.n_header & ~NUMERIC_INF_SIGN_MASK) == NUMERIC_PINF)
213 #define NUMERIC_SHORT_SIGN_MASK 0x2000
214 #define NUMERIC_SHORT_DSCALE_MASK 0x1F80
215 #define NUMERIC_SHORT_DSCALE_SHIFT 7
216 #define NUMERIC_SHORT_DSCALE_MAX \
217 (NUMERIC_SHORT_DSCALE_MASK >> NUMERIC_SHORT_DSCALE_SHIFT)
218 #define NUMERIC_SHORT_WEIGHT_SIGN_MASK 0x0040
219 #define NUMERIC_SHORT_WEIGHT_MASK 0x003F
220 #define NUMERIC_SHORT_WEIGHT_MAX NUMERIC_SHORT_WEIGHT_MASK
221 #define NUMERIC_SHORT_WEIGHT_MIN (-(NUMERIC_SHORT_WEIGHT_MASK+1))
233 #define NUMERIC_DSCALE_MASK 0x3FFF
234 #define NUMERIC_DSCALE_MAX NUMERIC_DSCALE_MASK
236 #define NUMERIC_SIGN(n) \
237 (NUMERIC_IS_SHORT(n) ? \
238 (((n)->choice.n_short.n_header & NUMERIC_SHORT_SIGN_MASK) ? \
239 NUMERIC_NEG : NUMERIC_POS) : \
240 (NUMERIC_IS_SPECIAL(n) ? \
241 NUMERIC_EXT_FLAGBITS(n) : NUMERIC_FLAGBITS(n)))
242 #define NUMERIC_DSCALE(n) (NUMERIC_HEADER_IS_SHORT((n)) ? \
243 ((n)->choice.n_short.n_header & NUMERIC_SHORT_DSCALE_MASK) \
244 >> NUMERIC_SHORT_DSCALE_SHIFT \
245 : ((n)->choice.n_long.n_sign_dscale & NUMERIC_DSCALE_MASK))
246 #define NUMERIC_WEIGHT(n) (NUMERIC_HEADER_IS_SHORT((n)) ? \
247 (((n)->choice.n_short.n_header & NUMERIC_SHORT_WEIGHT_SIGN_MASK ? \
248 ~NUMERIC_SHORT_WEIGHT_MASK : 0) \
249 | ((n)->choice.n_short.n_header & NUMERIC_SHORT_WEIGHT_MASK)) \
250 : ((n)->choice.n_long.n_weight))
394 #define NUMERIC_ABBREV_BITS (SIZEOF_DATUM * BITS_PER_BYTE)
395 #if SIZEOF_DATUM == 8
396 #define NumericAbbrevGetDatum(X) ((Datum) (X))
397 #define DatumGetNumericAbbrev(X) ((int64) (X))
398 #define NUMERIC_ABBREV_NAN NumericAbbrevGetDatum(PG_INT64_MIN)
399 #define NUMERIC_ABBREV_PINF NumericAbbrevGetDatum(-PG_INT64_MAX)
400 #define NUMERIC_ABBREV_NINF NumericAbbrevGetDatum(PG_INT64_MAX)
402 #define NumericAbbrevGetDatum(X) ((Datum) (X))
403 #define DatumGetNumericAbbrev(X) ((int32) (X))
404 #define NUMERIC_ABBREV_NAN NumericAbbrevGetDatum(PG_INT32_MIN)
405 #define NUMERIC_ABBREV_PINF NumericAbbrevGetDatum(-PG_INT32_MAX)
406 #define NUMERIC_ABBREV_NINF NumericAbbrevGetDatum(PG_INT32_MAX)
431 #elif DEC_DIGITS == 2
433 #elif DEC_DIGITS == 1
441 #elif DEC_DIGITS == 2
443 #elif DEC_DIGITS == 1
472 #define dump_numeric(s,n)
473 #define dump_var(s,v)
476 #define digitbuf_alloc(ndigits) \
477 ((NumericDigit *) palloc((ndigits) * sizeof(NumericDigit)))
478 #define digitbuf_free(buf) \
484 #define init_var(v) memset(v, 0, sizeof(NumericVar))
486 #define NUMERIC_DIGITS(num) (NUMERIC_HEADER_IS_SHORT(num) ? \
487 (num)->choice.n_short.n_data : (num)->choice.n_long.n_data)
488 #define NUMERIC_NDIGITS(num) \
489 ((VARSIZE(num) - NUMERIC_HEADER_SIZE(num)) / sizeof(NumericDigit))
490 #define NUMERIC_CAN_BE_SHORT(scale,weight) \
491 ((scale) <= NUMERIC_SHORT_DSCALE_MAX && \
492 (weight) <= NUMERIC_SHORT_WEIGHT_MAX && \
493 (weight) >= NUMERIC_SHORT_WEIGHT_MIN)
503 const char *cp,
int sign,
528 static bool numericvar_to_int128(
const NumericVar *var, int128 *result);
529 static void int128_to_numericvar(int128
val,
NumericVar *var);
544 int var1weight,
int var1sign,
546 int var2weight,
int var2sign);
556 int rscale,
bool round);
562 static void div_var_int64(
const NumericVar *var, int64 ival,
int ival_weight,
602 const NumericVar *count_var,
bool reversed_bounds,
635 Node *escontext = fcinfo->context;
638 const char *numstart;
645 if (!isspace((
unsigned char) *cp))
673 if (!isdigit((
unsigned char) *cp) && *cp !=
'.')
706 if (!isspace((
unsigned char) *cp))
763 &
value, &cp, escontext))
773 if (!isspace((
unsigned char) *cp))
785 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
786 errmsg(
"value overflows numeric format")));
795 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
796 errmsg(
"invalid input syntax for type %s: \"%s\"",
879 return (
arg.ndigits == 0 ||
arg.ndigits <=
arg.weight + 1);
920 return ((typmod -
VARHDRSZ) >> 16) & 0xffff;
935 return (((typmod -
VARHDRSZ) & 0x7ff) ^ 1024) - 1024;
1041 if (strchr(
str,
'.') != NULL)
1047 last = strlen(
str) - 1;
1048 while (
str[last] ==
'0')
1052 if (
str[last] ==
'.')
1056 str[last + 1] =
'\0';
1098 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1099 errmsg(
"invalid sign in external \"numeric\" value")));
1104 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1105 errmsg(
"invalid scale in external \"numeric\" value")));
1107 for (
i = 0;
i <
len;
i++)
1111 if (d < 0 || d >=
NBASE)
1113 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1114 errmsg(
"invalid digit in external \"numeric\" value")));
1169 for (
i = 0;
i <
x.ndigits;
i++)
1221 new_scale == old_scale && new_precision >= old_precision))
1290 new->choice.n_short.n_header =
1328 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1329 errmsg(
"NUMERIC precision %d must be between 1 and %d",
1333 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1334 errmsg(
"NUMERIC scale %d must be between %d and %d",
1342 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1343 errmsg(
"NUMERIC precision %d must be between 1 and %d",
1351 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1352 errmsg(
"invalid NUMERIC type modifier")));
1395 res->choice.n_short.n_header =
1400 res->choice.n_short.n_header =
1425 res->choice.n_short.n_header =
1438 res->choice.n_short.n_header =
1441 res->choice.n_long.n_sign_dscale =
1444 res->choice.n_long.n_sign_dscale =
1709 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1710 errmsg(
"start value cannot be NaN")));
1713 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1714 errmsg(
"start value cannot be infinity")));
1720 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1721 errmsg(
"stop value cannot be NaN")));
1724 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1725 errmsg(
"stop value cannot be infinity")));
1737 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1738 errmsg(
"step size cannot be NaN")));
1741 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1742 errmsg(
"step size cannot be infinity")));
1749 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1750 errmsg(
"step size cannot equal zero")));
1841 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1842 errmsg(
"count must be greater than zero")));
1852 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1853 errmsg(
"operand, lower bound, and upper bound cannot be NaN")));
1857 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1858 errmsg(
"lower and upper bounds must be finite")));
1871 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1872 errmsg(
"lower bound cannot equal upper bound")));
1901 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1902 errmsg(
"integer out of range")));
1918 const NumericVar *count_var,
bool reversed_bounds,
1929 if (!reversed_bounds)
1931 sub_var(&operand_var, &bound1_var, &operand_var);
1932 sub_var(&bound2_var, &bound1_var, &bound2_var);
1936 sub_var(&bound1_var, &operand_var, &operand_var);
1937 sub_var(&bound1_var, &bound2_var, &bound2_var);
1940 mul_var(&operand_var, count_var, &operand_var,
1942 div_var(&operand_var, &bound2_var, result_var,
1950 if (
cmp_var(result_var, count_var) >= 0)
2094 pfree(original_varatt);
2113 if (memtupcount < 10000 || nss->input_count < 10000 || !nss->estimating)
2124 if (abbr_card > 100000.0)
2129 "numeric_abbrev: estimation ends at cardinality %f"
2146 if (abbr_card < nss->input_count / 10000.0 + 0.5)
2151 "numeric_abbrev: aborting abbreviation at cardinality %f"
2152 " below threshold %f after " INT64_FORMAT " values (%d rows)",
2162 "numeric_abbrev: cardinality %f"
2262 #if NUMERIC_ABBREV_BITS == 64
2268 int weight = var->
weight;
2271 if (ndigits == 0 || weight < -44)
2275 else if (weight > 83)
2281 result = ((int64) (weight + 44) << 56);
2286 result |= ((int64) var->
digits[3]);
2289 result |= ((int64) var->
digits[2]) << 14;
2292 result |= ((int64) var->
digits[1]) << 28;
2295 result |= ((int64) var->
digits[0]) << 42;
2307 ^ (
uint32) ((uint64) result >> 32));
2317 #if NUMERIC_ABBREV_BITS == 32
2323 int weight = var->
weight;
2326 if (ndigits == 0 || weight < -11)
2330 else if (weight > 20)
2338 weight = (weight + 11) * 4;
2350 result = (result * 1000) + (nxt1 / 10);
2353 else if (result > 99)
2356 result = (result * 10000) + nxt1;
2359 else if (result > 9)
2364 result = (result * 100000) + (nxt1 * 10) + (nxt2 / 1000);
2372 result = (result * 1000000) + (nxt1 * 100) + (nxt2 / 100);
2375 result = result | (weight << 24);
2579 (
errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
2580 errmsg(
"invalid preceding or following size in window function")));
2677 sub_var(&basev, &offsetv, &sum);
2679 add_var(&basev, &offsetv, &sum);
2682 result = (
cmp_var(&valv, &sum) <= 0);
2684 result = (
cmp_var(&valv, &sum) >= 0);
2767 result = digit_hash ^ weight;
2909 add_var(&arg1, &arg2, &result);
2987 sub_var(&arg1, &arg2, &result);
3153 *have_error =
false;
3175 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3176 errmsg(
"division by zero")));
3198 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3199 errmsg(
"division by zero")));
3234 if (have_error && (arg2.
ndigits == 0 || arg2.
digits[0] == 0))
3243 div_var(&arg1, &arg2, &result, rscale,
true);
3283 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3284 errmsg(
"division by zero")));
3301 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3302 errmsg(
"division by zero")));
3332 div_var(&arg1, &arg2, &result, 0,
false);
3376 *have_error =
false;
3397 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3398 errmsg(
"division by zero")));
3415 if (have_error && (arg2.
ndigits == 0 || arg2.
digits[0] == 0))
3421 mod_var(&arg1, &arg2, &result);
3548 gcd_var(&arg1, &arg2, &result);
3602 gcd_var(&arg1, &arg2, &result);
3603 div_var(&arg1, &result, &result, 0,
false);
3633 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
3634 errmsg(
"factorial of a negative number is undefined")));
3643 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
3644 errmsg(
"value overflows numeric format")));
3651 for (num = num - 1; num > 1; num--)
3658 mul_var(&result, &fact, &result, 0);
3693 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
3694 errmsg(
"cannot take square root of a negative number")));
3715 #if DEC_DIGITS == ((DEC_DIGITS / 2) * 2)
3718 if (
arg.weight >= 0)
3725 rscale =
Max(rscale,
arg.dscale);
3785 val *= 0.434294481903252;
3792 rscale =
Max(rscale,
arg.dscale);
3831 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
3832 errmsg(
"cannot take logarithm of a negative number")));
3844 rscale =
Max(rscale,
arg.dscale);
3886 if (sign1 < 0 || sign2 < 0)
3888 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
3889 errmsg(
"cannot take logarithm of a negative number")));
3891 if (sign1 == 0 || sign2 == 0)
3893 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
3894 errmsg(
"cannot take logarithm of zero")));
3919 log_var(&arg1, &arg2, &result);
3979 if (sign1 == 0 && sign2 < 0)
3981 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
3982 errmsg(
"zero raised to a negative power is undefined")));
3985 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
3986 errmsg(
"a negative number raised to a non-integer power yields a complex result")));
4012 if (sign1 == 0 && sign2 > 0)
4031 abs_x_gt_one =
true;
4040 if (abs_x_gt_one == (sign2 > 0))
4091 if (sign1 == 0 && sign2 < 0)
4093 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
4094 errmsg(
"zero raised to a negative power is undefined")));
4146 last_digit_pos = var->
ndigits - 1;
4147 while (last_digit_pos >= 0 &&
4148 var->
digits[last_digit_pos] == 0)
4151 if (last_digit_pos >= 0)
4168 while (last_digit % 10 == 0)
4240 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4241 errmsg(
"lower bound cannot be NaN"));
4244 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4245 errmsg(
"lower bound cannot be infinity"));
4251 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4252 errmsg(
"upper bound cannot be NaN"));
4255 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4256 errmsg(
"upper bound cannot be infinity"));
4315 rscale = log10val2 < 0 ? 0 : log10val2;
4335 static const int pow10[] = {1, 10, 100, 1000};
4336 #elif DEC_DIGITS == 2
4337 static const int pow10[] = {1, 10};
4338 #elif DEC_DIGITS == 1
4339 static const int pow10[] = {1};
4341 #error unsupported NBASE
4354 tmp = (int128) val1 * (int128) factor;
4356 int128_to_numericvar(tmp, &result);
4365 mul_var(&result, &tmp, &result, 0);
4403 *have_error =
false;
4416 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4417 errmsg(
"cannot convert NaN to %s",
"integer")));
4420 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4421 errmsg(
"cannot convert infinity to %s",
"integer")));
4438 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4439 errmsg(
"integer out of range")));
4491 *have_error =
false;
4504 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4505 errmsg(
"cannot convert NaN to %s",
"bigint")));
4508 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4509 errmsg(
"cannot convert infinity to %s",
"bigint")));
4526 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4527 errmsg(
"bigint out of range")));
4564 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4565 errmsg(
"cannot convert NaN to %s",
"smallint")));
4568 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4569 errmsg(
"cannot convert infinity to %s",
"smallint")));
4577 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4578 errmsg(
"smallint out of range")));
4582 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4583 errmsg(
"smallint out of range")));
4598 char buf[DBL_DIG + 100];
4692 char buf[FLT_DIG + 100];
4760 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4761 errmsg(
"cannot convert NaN to %s",
"pg_lsn")));
4764 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4765 errmsg(
"cannot convert infinity to %s",
"pg_lsn")));
4773 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4774 errmsg(
"pg_lsn out of range")));
4809 #define NA_TOTAL_COUNT(na) \
4810 ((na)->N + (na)->NaNcount + (na)->pInfcount + (na)->nInfcount)
4824 elog(
ERROR,
"aggregate function called in non-aggregate context");
4829 state->calcSumX2 = calcSumX2;
4830 state->agg_context = agg_context;
4847 state->calcSumX2 = calcSumX2;
4885 state->maxScaleCount = 1;
4888 state->maxScaleCount++;
4891 if (
state->calcSumX2)
4905 if (
state->calcSumX2)
4957 if (
state->maxScaleCount > 1 ||
state->maxScale == 0)
4963 state->maxScaleCount--;
4965 else if (
state->N == 1)
4968 state->maxScale = 0;
4969 state->maxScaleCount = 0;
4979 if (
state->calcSumX2)
4994 if (
state->calcSumX2)
5007 if (
state->calcSumX2)
5048 elog(
ERROR,
"aggregate function called in non-aggregate context");
5062 state1->
N = state2->
N;
5077 state1->
N += state2->
N;
5140 elog(
ERROR,
"aggregate function called in non-aggregate context");
5154 state1->
N = state2->
N;
5168 state1->
N += state2->
N;
5213 elog(
ERROR,
"aggregate function called in non-aggregate context");
5264 elog(
ERROR,
"aggregate function called in non-aggregate context");
5323 elog(
ERROR,
"aggregate function called in non-aggregate context");
5378 elog(
ERROR,
"aggregate function called in non-aggregate context");
5439 elog(
ERROR,
"numeric_accum_inv called with NULL state");
5467 typedef struct Int128AggState
5479 static Int128AggState *
5482 Int128AggState *
state;
5487 elog(
ERROR,
"aggregate function called in non-aggregate context");
5491 state = (Int128AggState *)
palloc0(
sizeof(Int128AggState));
5492 state->calcSumX2 = calcSumX2;
5503 static Int128AggState *
5504 makeInt128AggStateCurrentContext(
bool calcSumX2)
5506 Int128AggState *
state;
5508 state = (Int128AggState *)
palloc0(
sizeof(Int128AggState));
5509 state->calcSumX2 = calcSumX2;
5518 do_int128_accum(Int128AggState *
state, int128
newval)
5520 if (
state->calcSumX2)
5531 do_int128_discard(Int128AggState *
state, int128
newval)
5533 if (
state->calcSumX2)
5541 #define makePolyNumAggState makeInt128AggState
5542 #define makePolyNumAggStateCurrentContext makeInt128AggStateCurrentContext
5545 #define makePolyNumAggState makeNumericAggState
5546 #define makePolyNumAggStateCurrentContext makeNumericAggStateCurrentContext
5624 elog(
ERROR,
"aggregate function called in non-aggregate context");
5638 state1->
N = state2->
N;
5655 state1->
N += state2->
N;
5690 elog(
ERROR,
"aggregate function called in non-aggregate context");
5712 int128_to_numericvar(
state->sumX, &tmp_var);
5720 int128_to_numericvar(
state->sumX2, &tmp_var);
5747 elog(
ERROR,
"aggregate function called in non-aggregate context");
5768 numericvar_to_int128(&tmp_var, &result->
sumX);
5776 numericvar_to_int128(&tmp_var, &result->
sumX2);
5827 elog(
ERROR,
"aggregate function called in non-aggregate context");
5841 state1->
N = state2->
N;
5855 state1->
N += state2->
N;
5888 elog(
ERROR,
"aggregate function called in non-aggregate context");
5910 int128_to_numericvar(
state->sumX, &tmp_var);
5936 elog(
ERROR,
"aggregate function called in non-aggregate context");
5957 numericvar_to_int128(&tmp_var, &result->
sumX);
5982 elog(
ERROR,
"int2_accum_inv called with NULL state");
5991 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6007 elog(
ERROR,
"int4_accum_inv called with NULL state");
6016 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6032 elog(
ERROR,
"int8_accum_inv called with NULL state");
6038 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6053 elog(
ERROR,
"int8_avg_accum_inv called with NULL state");
6062 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6085 int128_to_numericvar(
state->sumX, &result);
6114 int128_to_numericvar(
state->sumX, &result);
6141 if (
state->NaNcount > 0)
6145 if (
state->pInfcount > 0 &&
state->nInfcount > 0)
6147 if (
state->pInfcount > 0)
6149 if (
state->nInfcount > 0)
6175 if (
state->NaNcount > 0)
6179 if (
state->pInfcount > 0 &&
state->nInfcount > 0)
6181 if (
state->pInfcount > 0)
6183 if (
state->nInfcount > 0)
6207 bool variance,
bool sample,
6229 if (sample && totCount <= 1)
6241 if (
state->NaNcount > 0 ||
state->pInfcount > 0 ||
state->nInfcount > 0)
6257 rscale = vsumX.
dscale * 2;
6259 mul_var(&vsumX, &vsumX, &vsumX, rscale);
6260 mul_var(&vN, &vsumX2, &vsumX2, rscale);
6261 sub_var(&vsumX2, &vsumX, &vsumX2);
6271 mul_var(&vN, &vNminus1, &vNminus1, 0);
6273 mul_var(&vN, &vN, &vNminus1, 0);
6275 div_var(&vsumX2, &vNminus1, &vsumX, rscale,
true);
6359 numeric_poly_stddev_internal(Int128AggState *
state,
6360 bool variance,
bool sample,
6377 int128_to_numericvar(
state->sumX, &tmp_var);
6380 int128_to_numericvar(
state->sumX2, &tmp_var);
6413 res = numeric_poly_stddev_internal(
state,
true,
true, &is_null);
6434 res = numeric_poly_stddev_internal(
state,
false,
true, &is_null);
6455 res = numeric_poly_stddev_internal(
state,
true,
false, &is_null);
6476 res = numeric_poly_stddev_internal(
state,
false,
false, &is_null);
6529 #ifndef USE_FLOAT8_BYVAL
6578 #ifndef USE_FLOAT8_BYVAL
6675 elog(
ERROR,
"expected 2-element int8 array");
6703 elog(
ERROR,
"expected 2-element int8 array");
6721 elog(
ERROR,
"aggregate function called in non-aggregate context");
6728 elog(
ERROR,
"expected 2-element int8 array");
6732 elog(
ERROR,
"expected 2-element int8 array");
6738 state1->
sum += state2->
sum;
6762 elog(
ERROR,
"expected 2-element int8 array");
6790 elog(
ERROR,
"expected 2-element int8 array");
6809 elog(
ERROR,
"expected 2-element int8 array");
6813 if (transdata->
count == 0)
6834 elog(
ERROR,
"expected 2-element int8 array");
6838 if (transdata->
count == 0)
6852 #ifdef NUMERIC_DEBUG
6890 for (
i = 0;
i < ndigits;
i++)
7016 bool have_dp =
false;
7018 unsigned char *decdigits;
7051 if (!isdigit((
unsigned char) *cp))
7052 goto invalid_syntax;
7062 if (isdigit((
unsigned char) *cp))
7064 decdigits[
i++] = *cp++ -
'0';
7070 else if (*cp ==
'.')
7073 goto invalid_syntax;
7078 goto invalid_syntax;
7080 else if (*cp ==
'_')
7084 if (!isdigit((
unsigned char) *cp))
7085 goto invalid_syntax;
7096 if (*cp ==
'e' || *cp ==
'E')
7114 else if (*cp ==
'-')
7121 if (!isdigit((
unsigned char) *cp))
7122 goto invalid_syntax;
7126 if (isdigit((
unsigned char) *cp))
7128 exponent = exponent * 10 + (*cp++ -
'0');
7132 else if (*cp ==
'_')
7136 if (!isdigit((
unsigned char) *cp))
7137 goto invalid_syntax;
7144 exponent = -exponent;
7146 dweight += (int) exponent;
7147 dscale -= (int) exponent;
7162 offset = (weight + 1) *
DEC_DIGITS - (dweight + 1);
7167 dest->weight = weight;
7168 dest->dscale = dscale;
7173 while (ndigits-- > 0)
7176 *
digits++ = ((decdigits[
i] * 10 + decdigits[
i + 1]) * 10 +
7177 decdigits[
i + 2]) * 10 + decdigits[
i + 3];
7178 #elif DEC_DIGITS == 2
7179 *
digits++ = decdigits[
i] * 10 + decdigits[
i + 1];
7180 #elif DEC_DIGITS == 1
7183 #error unsupported NBASE
7200 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7201 errmsg(
"value overflows numeric format")));
7205 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
7206 errmsg(
"invalid input syntax for type %s: \"%s\"",
7217 return dig >=
'0' && dig <=
'9' ? dig -
'0' :
7218 dig >=
'a' && dig <=
'f' ? dig -
'a' + 10 :
7219 dig >=
'A' && dig <=
'F' ? dig -
'A' + 10 : -1;
7244 const char **endptr,
Node *escontext)
7246 const char *firstdigit = cp;
7268 if (isxdigit((
unsigned char) *cp))
7279 if (
dest->weight > SHRT_MAX)
7290 else if (*cp ==
'_')
7294 if (!isxdigit((
unsigned char) *cp))
7295 goto invalid_syntax;
7305 if (*cp >=
'0' && *cp <=
'7')
7316 if (
dest->weight > SHRT_MAX)
7324 tmp = tmp * 8 + (*cp++ -
'0');
7327 else if (*cp ==
'_')
7331 if (*cp < '0' || *cp >
'7')
7332 goto invalid_syntax;
7342 if (*cp >=
'0' && *cp <=
'1')
7353 if (
dest->weight > SHRT_MAX)
7361 tmp = tmp * 2 + (*cp++ -
'0');
7364 else if (*cp ==
'_')
7368 if (*cp < '0' || *cp >
'1')
7369 goto invalid_syntax;
7377 goto invalid_syntax;
7381 goto invalid_syntax;
7389 if (
dest->weight > SHRT_MAX)
7403 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7404 errmsg(
"value overflows numeric format")));
7408 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
7409 errmsg(
"invalid input syntax for type %s: \"%s\"",
7474 if (
value->ndigits > 0)
7475 memcpy(newbuf + 1,
value->digits,
7482 dest->digits = newbuf + 1;
7541 for (d = 0; d <= var->
weight; d++)
7547 bool putit = (d > 0);
7566 #elif DEC_DIGITS == 2
7569 if (d1 > 0 || d > 0)
7572 #elif DEC_DIGITS == 1
7575 #error unsupported NBASE
7588 endcp = cp + dscale;
7693 div_var(var, &tmp_var, &tmp_var, rscale,
true);
7705 len = strlen(sig_out) + 13;
7752 for (
i = 0;
i <
len;
i++)
7786 int weight = var->
weight;
7792 *have_error =
false;
7819 while (n > 0 && *
digits == 0)
7826 while (n > 0 &&
digits[n - 1] == 0)
7842 result->choice.n_short.n_header =
7854 result->choice.n_long.n_sign_dscale =
7856 result->choice.n_long.n_weight = weight;
7875 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7876 errmsg(
"value overflows numeric format")));
7953 else if (dig < 1000)
7955 #elif DEC_DIGITS == 2
7958 #elif DEC_DIGITS == 1
7961 #error unsupported NBASE
7965 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7966 errmsg(
"numeric field overflow"),
7967 errdetail(
"A field with precision %d, scale %d must round to an absolute value less than %s%d.",
8016 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
8017 errmsg(
"numeric field overflow"),
8018 errdetail(
"A field with precision %d, scale %d cannot hold an infinite value.",
8019 precision,
scale)));
8059 Assert(weight >= 0 && ndigits <= weight + 1);
8069 for (
i = 1;
i <= weight;
i++)
8136 newuval = uval /
NBASE;
8137 *ptr = uval - newuval *
NBASE;
8142 var->
weight = ndigits - 1;
8187 Assert(weight >= 0 && ndigits <= weight + 1);
8192 for (
i = 1;
i <= weight;
i++)
8224 numericvar_to_int128(
const NumericVar *var, int128 *result)
8255 Assert(weight >= 0 && ndigits <= weight + 1);
8261 for (
i = 1;
i <= weight;
i++)
8277 if (!neg || (-
val) !=
val ||
val == 0 || oldval < 0)
8287 *result = neg ? -
val :
val;
8327 newuval = uval /
NBASE;
8328 *ptr = uval - newuval *
NBASE;
8333 var->
weight = ndigits - 1;
8350 val = strtod(tmp, &endptr);
8351 if (*endptr !=
'\0')
8355 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
8356 errmsg(
"invalid input syntax for type %s: \"%s\"",
8357 "double precision", tmp)));
8389 int var1weight,
int var1sign,
8391 int var2weight,
int var2sign)
8393 if (var1ndigits == 0)
8395 if (var2ndigits == 0)
8401 if (var2ndigits == 0)
8413 var2digits, var2ndigits, var2weight);
8420 var1digits, var1ndigits, var1weight);
8707 var1digits = var1->
digits;
8708 var2digits = var2->
digits;
8710 if (var1ndigits == 0 || var2ndigits == 0)
8737 res_ndigits = var1ndigits + var2ndigits + 1;
8742 if (res_ndigits < 3)
8766 dig = (
int *)
palloc0(res_ndigits *
sizeof(
int));
8778 for (i1 =
Min(var1ndigits - 1, res_ndigits - 3); i1 >= 0; i1--)
8786 maxdig += var1digit;
8787 if (maxdig > (INT_MAX - INT_MAX /
NBASE) / (
NBASE - 1))
8791 for (
i = res_ndigits - 1;
i >= 0;
i--)
8793 newdig = dig[
i] + carry;
8794 if (newdig >=
NBASE)
8796 carry = newdig /
NBASE;
8797 newdig -= carry *
NBASE;
8805 maxdig = 1 + var1digit;
8822 int i2limit =
Min(var2ndigits, res_ndigits - i1 - 2);
8823 int *dig_i1_2 = &dig[i1 + 2];
8825 for (i2 = 0; i2 < i2limit; i2++)
8826 dig_i1_2[i2] += var1digit * var2digits[i2];
8836 res_digits = result->
digits;
8838 for (
i = res_ndigits - 1;
i >= 0;
i--)
8840 newdig = dig[
i] + carry;
8841 if (newdig >=
NBASE)
8843 carry = newdig /
NBASE;
8844 newdig -= carry *
NBASE;
8848 res_digits[
i] = newdig;
8857 result->
weight = res_weight;
8858 result->
sign = res_sign;
8878 int rscale,
bool round)
8895 int var1ndigits = var1->
ndigits;
8896 int var2ndigits = var2->
ndigits;
8902 if (var2ndigits == 0 || var2->
digits[0] == 0)
8904 (
errcode(ERRCODE_DIVISION_BY_ZERO),
8905 errmsg(
"division by zero")));
8914 if (var2ndigits <= 2)
8917 int idivisor_weight;
8919 idivisor = var2->
digits[0];
8920 idivisor_weight = var2->
weight;
8921 if (var2ndigits == 2)
8927 idivisor = -idivisor;
8929 div_var_int(var1, idivisor, idivisor_weight, result, rscale, round);
8933 if (var2ndigits <= 4)
8936 int idivisor_weight;
8938 idivisor = var2->
digits[0];
8939 idivisor_weight = var2->
weight;
8940 for (
i = 1;
i < var2ndigits;
i++)
8946 idivisor = -idivisor;
8948 div_var_int64(var1, idivisor, idivisor_weight, result, rscale, round);
8958 if (var1ndigits == 0)
8978 res_ndigits =
Max(res_ndigits, 1);
8990 div_ndigits = res_ndigits + var2ndigits;
8991 div_ndigits =
Max(div_ndigits, var1ndigits);
9005 divisor = dividend + (div_ndigits + 1);
9013 res_digits = result->
digits;
9026 int d =
NBASE / (divisor[1] + 1);
9029 for (
i = var2ndigits;
i > 0;
i--)
9031 carry += divisor[
i] * d;
9032 divisor[
i] = carry %
NBASE;
9033 carry = carry /
NBASE;
9038 for (
i = var1ndigits;
i >= 0;
i--)
9040 carry += dividend[
i] * d;
9041 dividend[
i] = carry %
NBASE;
9042 carry = carry /
NBASE;
9048 divisor1 = divisor[1];
9049 divisor2 = divisor[2];
9057 for (
j = 0;
j < res_ndigits;
j++)
9060 int next2digits = dividend[
j] *
NBASE + dividend[
j + 1];
9068 if (next2digits == 0)
9074 if (dividend[
j] == divisor1)
9077 qhat = next2digits / divisor1;
9085 while (divisor2 * qhat >
9086 (next2digits - qhat * divisor1) *
NBASE + dividend[
j + 2])
9103 for (
i = var2ndigits;
i >= 0;
i--)
9107 tmp_result = dividend_j[
i] - borrow - divisor[
i] * qhat;
9109 dividend_j[
i] = tmp_result + borrow *
NBASE;
9124 for (
i = var2ndigits;
i >= 0;
i--)
9126 carry += dividend_j[
i] + divisor[
i];
9129 dividend_j[
i] = carry -
NBASE;
9134 dividend_j[
i] = carry;
9144 res_digits[
j] = qhat;
9152 result->
weight = res_weight;
9153 result->
sign = res_sign;
9206 int var1ndigits = var1->
ndigits;
9207 int var2ndigits = var2->
ndigits;
9215 if (var2ndigits == 0 || var2digits[0] == 0)
9217 (
errcode(ERRCODE_DIVISION_BY_ZERO),
9218 errmsg(
"division by zero")));
9227 if (var2ndigits <= 2)
9230 int idivisor_weight;
9232 idivisor = var2->
digits[0];
9233 idivisor_weight = var2->
weight;
9234 if (var2ndigits == 2)
9240 idivisor = -idivisor;
9242 div_var_int(var1, idivisor, idivisor_weight, result, rscale, round);
9246 if (var2ndigits <= 4)
9249 int idivisor_weight;
9251 idivisor = var2->
digits[0];
9252 idivisor_weight = var2->
weight;
9253 for (
i = 1;
i < var2ndigits;
i++)
9259 idivisor = -idivisor;
9261 div_var_int64(var1, idivisor, idivisor_weight, result, rscale, round);
9271 if (var1ndigits == 0)
9311 div = (
int *)
palloc0((div_ndigits + 1) *
sizeof(int));
9312 load_ndigits =
Min(div_ndigits, var1ndigits);
9313 for (
i = 0;
i < load_ndigits;
i++)
9314 div[
i + 1] = var1digits[
i];
9322 fdivisor = (double) var2digits[0];
9323 for (
i = 1;
i < 4;
i++)
9326 if (
i < var2ndigits)
9327 fdivisor += (double) var2digits[
i];
9329 fdivisorinverse = 1.0 / fdivisor;
9353 for (qi = 0; qi < div_ndigits; qi++)
9356 fdividend = (double) div[qi];
9357 for (
i = 1;
i < 4;
i++)
9360 if (qi +
i <= div_ndigits)
9361 fdividend += (double) div[qi +
i];
9364 fquotient = fdividend * fdivisorinverse;
9365 qdigit = (fquotient >= 0.0) ? ((
int) fquotient) :
9366 (((
int) fquotient) - 1);
9371 maxdiv += abs(qdigit);
9372 if (maxdiv > (INT_MAX - INT_MAX /
NBASE - 1) / (
NBASE - 1))
9382 for (
i =
Min(qi + var2ndigits - 2, div_ndigits);
i > qi;
i--)
9384 newdig = div[
i] + carry;
9387 carry = -((-newdig - 1) /
NBASE) - 1;
9388 newdig -= carry *
NBASE;
9390 else if (newdig >=
NBASE)
9392 carry = newdig /
NBASE;
9393 newdig -= carry *
NBASE;
9399 newdig = div[qi] + carry;
9413 fdividend = (double) div[qi];
9414 for (
i = 1;
i < 4;
i++)
9417 if (qi +
i <= div_ndigits)
9418 fdividend += (double) div[qi +
i];
9421 fquotient = fdividend * fdivisorinverse;
9422 qdigit = (fquotient >= 0.0) ? ((
int) fquotient) :
9423 (((
int) fquotient) - 1);
9424 maxdiv += abs(qdigit);
9447 int istop =
Min(var2ndigits, div_ndigits - qi + 1);
9448 int *div_qi = &div[qi];
9450 for (
i = 0;
i < istop;
i++)
9477 div[qi + 1] += div[qi] *
NBASE;
9485 fdividend = (double) div[qi];
9486 for (
i = 1;
i < 4;
i++)
9488 fquotient = fdividend * fdivisorinverse;
9489 qdigit = (fquotient >= 0.0) ? ((
int) fquotient) :
9490 (((
int) fquotient) - 1);
9502 res_digits = result->
digits;
9504 for (
i = div_ndigits;
i >= 0;
i--)
9506 newdig = div[
i] + carry;
9509 carry = -((-newdig - 1) /
NBASE) - 1;
9510 newdig -= carry *
NBASE;
9512 else if (newdig >=
NBASE)
9514 carry = newdig /
NBASE;
9515 newdig -= carry *
NBASE;
9519 res_digits[
i] = newdig;
9528 result->
weight = res_weight;
9529 result->
sign = res_sign;
9553 int var_ndigits = var->
ndigits;
9565 errcode(ERRCODE_DIVISION_BY_ZERO),
9566 errmsg(
"division by zero"));
9569 if (var_ndigits == 0)
9585 res_weight = var->
weight - ival_weight;
9589 res_ndigits =
Max(res_ndigits, 1);
9596 res_digits = res_buf + 1;
9608 divisor = abs(ival);
9610 if (divisor <= UINT_MAX /
NBASE)
9615 for (
i = 0;
i < res_ndigits;
i++)
9617 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9619 carry = carry % divisor;
9627 for (
i = 0;
i < res_ndigits;
i++)
9629 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9631 carry = carry % divisor;
9637 result->
ndigits = res_ndigits;
9638 result->
buf = res_buf;
9639 result->
digits = res_digits;
9640 result->
weight = res_weight;
9641 result->
sign = res_sign;
9665 div_var_int64(
const NumericVar *var, int64 ival,
int ival_weight,
9669 int var_ndigits = var->
ndigits;
9681 errcode(ERRCODE_DIVISION_BY_ZERO),
9682 errmsg(
"division by zero"));
9685 if (var_ndigits == 0)
9701 res_weight = var->
weight - ival_weight;
9705 res_ndigits =
Max(res_ndigits, 1);
9712 res_digits = res_buf + 1;
9731 for (
i = 0;
i < res_ndigits;
i++)
9733 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9735 carry = carry % divisor;
9743 for (
i = 0;
i < res_ndigits;
i++)
9745 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9747 carry = carry % divisor;
9753 result->
ndigits = res_ndigits;
9754 result->
buf = res_buf;
9755 result->
digits = res_digits;
9756 result->
weight = res_weight;
9757 result->
sign = res_sign;
9801 firstdigit1 = var1->
digits[
i];
9802 if (firstdigit1 != 0)
9813 firstdigit2 = var2->
digits[
i];
9814 if (firstdigit2 != 0)
9825 qweight = weight1 - weight2;
9826 if (firstdigit1 <= firstdigit2)
9858 div_var(var1, var2, &tmp, 0,
false);
9915 while (
cmp_abs(&r, var2) >= 0)
10024 result->
dscale = res_dscale;
10040 mod_var(&tmp_arg, result, &mod);
10047 result->
dscale = res_dscale;
10086 result->
dscale = rscale;
10096 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
10097 errmsg(
"cannot take square root of a negative number")));
10110 if (
arg->weight >= 0)
10111 res_weight =
arg->weight / 2;
10113 res_weight = -((-
arg->weight - 1) / 2 + 1);
10121 if (rscale + 1 >= 0)
10124 res_ndigits = res_weight + 1 - (-rscale - 1) /
DEC_DIGITS;
10125 res_ndigits =
Max(res_ndigits, 1);
10133 src_ndigits =
arg->weight + 1 + (res_ndigits - res_weight - 1) * 2;
10134 src_ndigits =
Max(src_ndigits, 1);
10204 while ((ndigits[step] = src_ndigits) > 4)
10207 blen = src_ndigits / 4;
10208 if (blen * 4 == src_ndigits &&
arg->digits[0] <
NBASE / 4)
10212 src_ndigits -= 2 * blen;
10224 arg_int64 =
arg->digits[0];
10225 for (src_idx = 1; src_idx < src_ndigits; src_idx++)
10227 arg_int64 *=
NBASE;
10228 if (src_idx < arg->ndigits)
10229 arg_int64 +=
arg->digits[src_idx];
10232 s_int64 = (int64) sqrt((
double) arg_int64);
10233 r_int64 = arg_int64 - s_int64 * s_int64;
10245 while (r_int64 < 0 || r_int64 > 2 * s_int64)
10247 s_int64 = (s_int64 + arg_int64 / s_int64) / 2;
10248 r_int64 = arg_int64 - s_int64 * s_int64;
10271 while (step >= 0 && (src_ndigits = ndigits[step]) <= 8)
10282 blen = (src_ndigits - src_idx) / 2;
10289 for (
i = 0;
i < blen;
i++, src_idx++)
10293 if (src_idx < arg->ndigits)
10294 a1 +=
arg->digits[src_idx];
10297 for (
i = 0;
i < blen;
i++, src_idx++)
10300 if (src_idx < arg->ndigits)
10301 a0 +=
arg->digits[src_idx];
10305 numer = r_int64 *
b +
a1;
10306 denom = 2 * s_int64;
10308 u = numer - q * denom;
10311 s_int64 = s_int64 *
b + q;
10312 r_int64 = u *
b + a0 - q * q;
10317 r_int64 += s_int64;
10319 r_int64 += s_int64;
10322 Assert(src_idx == src_ndigits);
10336 s_int128 = s_int64;
10337 r_int128 = r_int64;
10345 while (step >= 0 && (src_ndigits = ndigits[step]) <= 16)
10356 blen = (src_ndigits - src_idx) / 2;
10363 for (
i = 0;
i < blen;
i++, src_idx++)
10367 if (src_idx < arg->ndigits)
10368 a1 +=
arg->digits[src_idx];
10371 for (
i = 0;
i < blen;
i++, src_idx++)
10374 if (src_idx < arg->ndigits)
10375 a0 +=
arg->digits[src_idx];
10379 numer = r_int128 *
b +
a1;
10380 denom = 2 * s_int128;
10382 u = numer - q * denom;
10385 s_int128 = s_int128 *
b + q;
10386 r_int128 = u *
b + a0 - q * q;
10391 r_int128 += s_int128;
10393 r_int128 += s_int128;
10396 Assert(src_idx == src_ndigits);
10406 int128_to_numericvar(s_int128, &s_var);
10408 int128_to_numericvar(r_int128, &r_var);
10429 src_ndigits = ndigits[step];
10430 blen = (src_ndigits - src_idx) / 2;
10433 if (src_idx < arg->ndigits)
10435 tmp_len =
Min(blen,
arg->ndigits - src_idx);
10437 memcpy(a1_var.
digits,
arg->digits + src_idx,
10439 a1_var.
weight = blen - 1;
10451 if (src_idx < arg->ndigits)
10453 tmp_len =
Min(blen,
arg->ndigits - src_idx);
10455 memcpy(a0_var.
digits,
arg->digits + src_idx,
10457 a0_var.
weight = blen - 1;
10472 add_var(&q_var, &a1_var, &q_var);
10473 add_var(&s_var, &s_var, &u_var);
10478 add_var(&s_var, &q_var, &s_var);
10488 add_var(&u_var, &a0_var, &u_var);
10489 mul_var(&q_var, &q_var, &q_var, 0);
10494 sub_var(&u_var, &q_var, &r_var);
10498 add_var(&r_var, &s_var, &r_var);
10500 add_var(&r_var, &s_var, &r_var);
10506 if (
cmp_var(&u_var, &q_var) < 0)
10510 Assert(src_idx == src_ndigits);
10518 result->
weight = res_weight;
10570 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
10571 errmsg(
"value overflows numeric format")));
10573 result->
dscale = rscale;
10578 dweight = (int) (
val * 0.434294481903252);
10587 if (fabs(
val) > 0.01)
10592 while (fabs(
val) > 0.01)
10598 local_rscale =
x.dscale + ndiv2;
10611 sig_digits = 1 + dweight + rscale + (int) (ndiv2 * 0.301029995663981);
10612 sig_digits =
Max(sig_digits, 0) + 8;
10614 local_rscale = sig_digits - 1;
10628 div_var_int(&elem, ni, 0, &elem, local_rscale,
true);
10632 add_var(result, &elem, result);
10634 mul_var(&elem, &
x, &elem, local_rscale);
10636 div_var_int(&elem, ni, 0, &elem, local_rscale,
true);
10644 while (ndiv2-- > 0)
10648 mul_var(result, result, result, local_rscale);
10696 ln_dweight =
x.weight *
DEC_DIGITS + (int) log10(
x.digits[0]);
10733 ln_var = log((
double)
digits) + dweight * 2.302585092994046;
10734 ln_dweight = (int) log10(fabs(
ln_var));
10767 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
10768 errmsg(
"cannot take logarithm of zero")));
10771 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
10772 errmsg(
"cannot take logarithm of a negative number")));
10800 local_rscale = rscale -
x.weight *
DEC_DIGITS / 2 + 8;
10807 local_rscale = rscale -
x.weight *
DEC_DIGITS / 2 + 8;
10828 local_rscale = rscale + (int) ((nsqrt + 1) * 0.301029995663981) + 8;
10832 div_var_fast(result, &elem, result, local_rscale,
true);
10834 mul_var(result, result, &
x, local_rscale);
10841 mul_var(&xx, &
x, &xx, local_rscale);
10842 div_var_int(&xx, ni, 0, &elem, local_rscale,
true);
10847 add_var(result, &elem, result);
10854 mul_var(result, &fact, result, rscale);
10875 int ln_base_dweight;
10876 int ln_num_dweight;
10877 int result_dweight;
10879 int ln_base_rscale;
10888 result_dweight = ln_num_dweight - ln_base_dweight;
10905 ln_base_rscale = rscale + result_dweight - ln_base_dweight + 8;
10908 ln_num_rscale = rscale + result_dweight - ln_num_dweight + 8;
10912 ln_var(base, &ln_base, ln_base_rscale);
10913 ln_var(num, &ln_num, ln_num_rscale);
10916 div_var_fast(&ln_num, &ln_base, result, rscale,
true);
10987 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
10988 errmsg(
"a negative number raised to a non-integer power yields a complex result")));
11030 local_rscale = 8 - ln_dweight;
11033 ln_var(base, &ln_base, local_rscale);
11035 mul_var(&ln_base, exp, &ln_num, local_rscale);
11044 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11045 errmsg(
"value overflows numeric format")));
11051 val *= 0.434294481903252;
11061 sig_digits = rscale + (int)
val;
11062 sig_digits =
Max(sig_digits, 0);
11065 local_rscale = sig_digits - ln_dweight + 8;
11070 ln_var(base, &ln_base, local_rscale);
11072 mul_var(&ln_base, exp, &ln_num, local_rscale);
11074 exp_var(&ln_num, result, rscale);
11130 f = exp * (log10(f) + p);
11138 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11139 errmsg(
"value overflows numeric format")));
11154 rscale =
Max(rscale, exp_dscale);
11170 result->
dscale = rscale;
11180 mul_var(base, base, result, rscale);
11191 (
errcode(ERRCODE_DIVISION_BY_ZERO),
11192 errmsg(
"division by zero")));
11194 result->
dscale = rscale;
11212 sig_digits = 1 + rscale + (int) f;
11219 sig_digits += (int) log(fabs((
double) exp)) + 8;
11235 while ((mask >>= 1) > 0)
11243 local_rscale =
Min(local_rscale, 2 * base_prod.
dscale);
11246 mul_var(&base_prod, &base_prod, &base_prod, local_rscale);
11250 local_rscale = sig_digits -
11252 local_rscale =
Min(local_rscale,
11256 mul_var(&base_prod, result, result, local_rscale);
11267 if (base_prod.
weight > SHRT_MAX || result->
weight > SHRT_MAX)
11272 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11273 errmsg(
"value overflows numeric format")));
11302 result->
dscale = exp < 0 ? -exp : 0;
11314 result->
digits[0] *= 10;
11331 int rlen64_ndigits;
11341 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
11342 errmsg(
"lower bound must be less than or equal to upper bound"));
11348 result->
dscale = rscale;
11367 for (
i = 0;
i < n;
i++)
11393 rlen64 = (uint64) rlen.
digits[0];
11394 rlen64_ndigits = 1;
11395 while (rlen64_ndigits < res_ndigits && rlen64_ndigits < 4)
11398 if (rlen64_ndigits < rlen.
ndigits)
11399 rlen64 += rlen.
digits[rlen64_ndigits];
11413 result->
dscale = rscale;
11414 res_digits = result->
digits;
11423 if (rlen64_ndigits == res_ndigits && pow10 != 1)
11428 for (
i = rlen64_ndigits - 1;
i >= 0;
i--)
11431 rand = rand /
NBASE;
11438 whole_ndigits = res_ndigits;
11443 i = rlen64_ndigits;
11444 while (
i < whole_ndigits - 3)
11449 rand = rand /
NBASE;
11451 rand = rand /
NBASE;
11453 rand = rand /
NBASE;
11458 while (
i < whole_ndigits)
11465 if (
i < res_ndigits)
11476 }
while (
cmp_var(result, &rlen) > 0);
11479 add_var(result, rmin, result);
11519 const NumericDigit *var2digits,
int var2ndigits,
int var2weight)
11526 while (var1weight > var2weight && i1 < var1ndigits)
11528 if (var1digits[i1++] != 0)
11532 while (var2weight > var1weight && i2 < var2ndigits)
11534 if (var2digits[i2++] != 0)
11541 if (var1weight == var2weight)
11543 while (i1 < var1ndigits && i2 < var2ndigits)
11545 int stat = var1digits[i1++] - var2digits[i2++];
11560 while (i1 < var1ndigits)
11562 if (var1digits[i1++] != 0)
11565 while (i2 < var2ndigits)
11567 if (var2digits[i2++] != 0)
11598 int var1ndigits = var1->
ndigits;
11599 int var2ndigits = var2->
ndigits;
11610 res_rscale =
Max(rscale1, rscale2);
11612 res_ndigits = res_rscale + res_weight + 1;
11613 if (res_ndigits <= 0)
11618 res_digits = res_buf + 1;
11620 i1 = res_rscale + var1->
weight + 1;
11621 i2 = res_rscale + var2->
weight + 1;
11622 for (
i = res_ndigits - 1;
i >= 0;
i--)
11626 if (i1 >= 0 && i1 < var1ndigits)
11627 carry += var1digits[i1];
11628 if (i2 >= 0 && i2 < var2ndigits)
11629 carry += var2digits[i2];
11631 if (carry >=
NBASE)
11633 res_digits[
i] = carry -
NBASE;
11638 res_digits[
i] = carry;
11646 result->
ndigits = res_ndigits;
11647 result->
buf = res_buf;
11648 result->
digits = res_digits;
11649 result->
weight = res_weight;
11650 result->
dscale = res_dscale;
11683 int var1ndigits = var1->
ndigits;
11684 int var2ndigits = var2->
ndigits;
11688 res_weight = var1->
weight;
11695 res_rscale =
Max(rscale1, rscale2);
11697 res_ndigits = res_rscale + res_weight + 1;
11698 if (res_ndigits <= 0)
11703 res_digits = res_buf + 1;
11705 i1 = res_rscale + var1->
weight + 1;
11706 i2 = res_rscale + var2->
weight + 1;
11707 for (
i = res_ndigits - 1;
i >= 0;
i--)
11711 if (i1 >= 0 && i1 < var1ndigits)
11712 borrow += var1digits[i1];
11713 if (i2 >= 0 && i2 < var2ndigits)
11714 borrow -= var2digits[i2];
11718 res_digits[
i] = borrow +
NBASE;
11723 res_digits[
i] = borrow;
11731 result->
ndigits = res_ndigits;
11732 result->
buf = res_buf;
11733 result->
digits = res_digits;
11734 result->
weight = res_weight;
11735 result->
dscale = res_dscale;
11779 if (ndigits < var->ndigits ||
11780 (ndigits == var->
ndigits && di > 0))
11784 #if DEC_DIGITS == 1
11796 #if DEC_DIGITS == 4
11798 #elif DEC_DIGITS == 2
11801 #error unsupported NBASE
11803 extra =
digits[--ndigits] % pow10;
11804 digits[ndigits] -= extra;
11806 if (extra >= pow10 / 2)
11808 pow10 +=
digits[ndigits];
11809 if (pow10 >=
NBASE)
11814 digits[ndigits] = pow10;
11822 carry +=
digits[--ndigits];
11823 if (carry >=
NBASE)
11830 digits[ndigits] = carry;
11879 if (ndigits <= var->ndigits)
11883 #if DEC_DIGITS == 1
11896 #if DEC_DIGITS == 4
11898 #elif DEC_DIGITS == 2
11901 #error unsupported NBASE
11903 extra =
digits[--ndigits] % pow10;
11904 digits[ndigits] -= extra;
11923 while (ndigits > 0 && *
digits == 0)
11931 while (ndigits > 0 &&
digits[ndigits - 1] == 0)
11976 int32 *accum_digits;
12005 val_ndigits =
val->ndigits;
12006 val_digits =
val->digits;
12009 for (val_i = 0; val_i < val_ndigits; val_i++)
12011 accum_digits[
i] += (
int32) val_digits[val_i];
12051 for (
i = ndigits - 1;
i >= 0;
i--)
12053 newdig = dig[
i] + carry;
12054 if (newdig >=
NBASE)
12056 carry = newdig /
NBASE;
12057 newdig -= carry *
NBASE;
12070 for (
i = ndigits - 1;
i >= 0;
i--)
12072 newdig = dig[
i] + carry;
12073 if (newdig >=
NBASE)
12075 carry = newdig /
NBASE;
12076 newdig -= carry *
NBASE;
12097 int old_weight = accum->
weight;
12098 int old_ndigits = accum->
ndigits;
12104 accum_weight = old_weight;
12105 accum_ndigits = old_ndigits;
12116 if (
val->weight >= accum_weight)
12118 accum_weight =
val->weight + 1;
12119 accum_ndigits = accum_ndigits + (accum_weight - old_weight);
12134 accum_rscale = accum_ndigits - accum_weight - 1;
12135 val_rscale =
val->ndigits -
val->weight - 1;
12136 if (val_rscale > accum_rscale)
12137 accum_ndigits = accum_ndigits + (val_rscale - accum_rscale);
12139 if (accum_ndigits != old_ndigits ||
12140 accum_weight != old_weight)
12142 int32 *new_pos_digits;
12143 int32 *new_neg_digits;
12146 weightdiff = accum_weight - old_weight;
12148 new_pos_digits =
palloc0(accum_ndigits *
sizeof(
int32));
12149 new_neg_digits =
palloc0(accum_ndigits *
sizeof(
int32));
12153 memcpy(&new_pos_digits[weightdiff], accum->
pos_digits,
12154 old_ndigits *
sizeof(
int32));
12157 memcpy(&new_neg_digits[weightdiff], accum->
neg_digits,
12158 old_ndigits *
sizeof(
int32));
12165 accum->
weight = accum_weight;
12166 accum->
ndigits = accum_ndigits;
12222 add_var(&pos_var, &neg_var, result);
#define PG_GETARG_ARRAYTYPE_P_COPY(n)
#define PG_GETARG_ARRAYTYPE_P(n)
#define PG_RETURN_ARRAYTYPE_P(x)
#define ARR_OVERHEAD_NONULLS(ndims)
int32 * ArrayGetIntegerTypmods(ArrayType *arr, int *n)
Datum numeric_stddev_samp(PG_FUNCTION_ARGS)
static const NumericVar const_two
static void mod_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static const NumericVar const_pinf
static char * get_str_from_var_sci(const NumericVar *var, int rscale)
#define NUMERIC_INF_SIGN_MASK
#define dump_numeric(s, n)
#define NUMERIC_CAN_BE_SHORT(scale, weight)
static void ceil_var(const NumericVar *var, NumericVar *result)
static void accum_sum_carry(NumericSumAccum *accum)
#define DatumGetNumericAbbrev(X)
#define NUMERIC_HDRSZ_SHORT
#define digitbuf_free(buf)
Datum numeric_poly_var_samp(PG_FUNCTION_ARGS)
static const NumericDigit const_zero_point_nine_data[1]
Datum numeric_accum(PG_FUNCTION_ARGS)
static void exp_var(const NumericVar *arg, NumericVar *result, int rscale)
Datum numeric_poly_serialize(PG_FUNCTION_ARGS)
Datum int2_accum_inv(PG_FUNCTION_ARGS)
static Datum numeric_abbrev_convert_var(const NumericVar *var, NumericSortSupport *nss)
Datum numeric_accum_inv(PG_FUNCTION_ARGS)
Datum numeric_div(PG_FUNCTION_ARGS)
Datum numeric_sub(PG_FUNCTION_ARGS)
int32 numeric_maximum_size(int32 typmod)
static bool numeric_abbrev_abort(int memtupcount, SortSupport ssup)
Datum numeric_poly_var_pop(PG_FUNCTION_ARGS)
Datum numeric_avg_serialize(PG_FUNCTION_ARGS)
Datum hash_numeric(PG_FUNCTION_ARGS)
Datum hash_numeric_extended(PG_FUNCTION_ARGS)
static bool numeric_is_integral(Numeric num)
static NumericAggState * makeNumericAggState(FunctionCallInfo fcinfo, bool calcSumX2)
Datum numeric_var_pop(PG_FUNCTION_ARGS)
static int get_min_scale(NumericVar *var)
static void sub_abs(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
int32 numeric_int4_opt_error(Numeric num, bool *have_error)
static void power_var(const NumericVar *base, const NumericVar *exp, NumericVar *result)
static bool is_valid_numeric_typmod(int32 typmod)
static void div_var_int(const NumericVar *var, int ival, int ival_weight, NumericVar *result, int rscale, bool round)
static int cmp_numerics(Numeric num1, Numeric num2)
Datum numeric_avg(PG_FUNCTION_ARGS)
static void numericvar_serialize(StringInfo buf, const NumericVar *var)
static NumericAggState * makeNumericAggStateCurrentContext(bool calcSumX2)
static void accum_sum_final(NumericSumAccum *accum, NumericVar *result)
static void power_var_int(const NumericVar *base, int exp, int exp_dscale, NumericVar *result)
static void free_var(NumericVar *var)
#define NUMERIC_DSCALE(n)
Datum int2_sum(PG_FUNCTION_ARGS)
static int numeric_typmod_scale(int32 typmod)
char * numeric_normalize(Numeric num)
Datum numeric_poly_sum(PG_FUNCTION_ARGS)
Datum int2_accum(PG_FUNCTION_ARGS)
Datum float8_numeric(PG_FUNCTION_ARGS)
static void trunc_var(NumericVar *var, int rscale)
Datum numeric_round(PG_FUNCTION_ARGS)
static void set_var_from_num(Numeric num, NumericVar *dest)
static void accum_sum_add(NumericSumAccum *accum, const NumericVar *val)
Datum numeric_cmp(PG_FUNCTION_ARGS)
Datum int4_avg_combine(PG_FUNCTION_ARGS)
Datum width_bucket_numeric(PG_FUNCTION_ARGS)
Datum int8_sum(PG_FUNCTION_ARGS)
Datum int8_accum_inv(PG_FUNCTION_ARGS)
Datum numerictypmodout(PG_FUNCTION_ARGS)
static Numeric duplicate_numeric(Numeric num)
#define makePolyNumAggState
Numeric numeric_mod_opt_error(Numeric num1, Numeric num2, bool *have_error)
static int32 make_numeric_typmod(int precision, int scale)
Datum numeric_recv(PG_FUNCTION_ARGS)
Numeric numeric_div_opt_error(Numeric num1, Numeric num2, bool *have_error)
static void sub_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
Numeric int64_to_numeric(int64 val)
Datum numeric_trim_scale(PG_FUNCTION_ARGS)
Datum int2int4_sum(PG_FUNCTION_ARGS)
static Numeric numeric_stddev_internal(NumericAggState *state, bool variance, bool sample, bool *is_null)
Numeric random_numeric(pg_prng_state *state, Numeric rmin, Numeric rmax)
Datum float4_numeric(PG_FUNCTION_ARGS)
Datum numeric_poly_stddev_samp(PG_FUNCTION_ARGS)
static void add_abs(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
Datum generate_series_step_numeric(PG_FUNCTION_ARGS)
Datum numeric_int8(PG_FUNCTION_ARGS)
static void do_numeric_accum(NumericAggState *state, Numeric newval)
Datum int4_numeric(PG_FUNCTION_ARGS)
Datum numeric_sum(PG_FUNCTION_ARGS)
Datum numeric_ge(PG_FUNCTION_ARGS)
static const NumericVar const_ninf
Datum numeric_uplus(PG_FUNCTION_ARGS)
Datum numeric_stddev_pop(PG_FUNCTION_ARGS)
Datum numeric_uminus(PG_FUNCTION_ARGS)
static void add_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static Datum numeric_abbrev_convert(Datum original_datum, SortSupport ssup)
#define NUMERIC_IS_SPECIAL(n)
#define NA_TOTAL_COUNT(na)
Datum numeric_le(PG_FUNCTION_ARGS)
Datum numeric_ceil(PG_FUNCTION_ARGS)
Datum numeric_send(PG_FUNCTION_ARGS)
struct Int8TransTypeData Int8TransTypeData
static void gcd_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static bool set_var_from_non_decimal_integer_str(const char *str, const char *cp, int sign, int base, NumericVar *dest, const char **endptr, Node *escontext)
Datum numerictypmodin(PG_FUNCTION_ARGS)
Datum in_range_numeric_numeric(PG_FUNCTION_ARGS)
Datum numeric_power(PG_FUNCTION_ARGS)
Numeric int64_div_fast_to_numeric(int64 val1, int log10val2)
static const NumericVar const_minus_one
static void div_var_fast(const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale, bool round)
static bool numericvar_to_int32(const NumericVar *var, int32 *result)
static int numeric_fast_cmp(Datum x, Datum y, SortSupport ssup)
static void floor_var(const NumericVar *var, NumericVar *result)
Datum numeric_int4(PG_FUNCTION_ARGS)
Datum numeric_gcd(PG_FUNCTION_ARGS)
static void compute_bucket(Numeric operand, Numeric bound1, Numeric bound2, const NumericVar *count_var, bool reversed_bounds, NumericVar *result_var)
static const NumericDigit const_one_data[1]
Datum numeric_poly_combine(PG_FUNCTION_ARGS)
static void init_var_from_num(Numeric num, NumericVar *dest)
static const NumericDigit const_two_data[1]
Datum numeric_fac(PG_FUNCTION_ARGS)
Datum numeric_serialize(PG_FUNCTION_ARGS)
#define NUMERIC_SHORT_WEIGHT_MASK
#define NUMERIC_IS_PINF(n)
static void zero_var(NumericVar *var)
Datum numeric_ne(PG_FUNCTION_ARGS)
#define NUMERIC_SHORT_WEIGHT_SIGN_MASK
Datum numeric(PG_FUNCTION_ARGS)
Datum int4_avg_accum_inv(PG_FUNCTION_ARGS)
static bool do_numeric_discard(NumericAggState *state, Numeric newval)
Datum int8_avg_serialize(PG_FUNCTION_ARGS)
Datum numeric_exp(PG_FUNCTION_ARGS)
static int numeric_cmp_abbrev(Datum x, Datum y, SortSupport ssup)
Datum numeric_log(PG_FUNCTION_ARGS)
static void mul_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale)
Datum numeric_scale(PG_FUNCTION_ARGS)
static Numeric make_result_opt_error(const NumericVar *var, bool *have_error)
Datum numeric_sqrt(PG_FUNCTION_ARGS)
static bool apply_typmod_special(Numeric num, int32 typmod, Node *escontext)
Datum int4_accum_inv(PG_FUNCTION_ARGS)
Datum numeric_poly_deserialize(PG_FUNCTION_ARGS)
#define NUMERIC_IS_INF(n)
Datum numeric_inc(PG_FUNCTION_ARGS)
static void random_var(pg_prng_state *state, const NumericVar *rmin, const NumericVar *rmax, NumericVar *result)
static char * get_str_from_var(const NumericVar *var)
Datum int8_avg_accum_inv(PG_FUNCTION_ARGS)
Datum int4_accum(PG_FUNCTION_ARGS)
Datum generate_series_numeric(PG_FUNCTION_ARGS)
#define NUMERIC_ABBREV_PINF
Datum numeric_out(PG_FUNCTION_ARGS)
Datum numeric_int2(PG_FUNCTION_ARGS)
int64 numeric_int8_opt_error(Numeric num, bool *have_error)
#define digitbuf_alloc(ndigits)
struct NumericAggState NumericAggState
static void sqrt_var(const NumericVar *arg, NumericVar *result, int rscale)
Datum numeric_trunc(PG_FUNCTION_ARGS)
static bool set_var_from_str(const char *str, const char *cp, NumericVar *dest, const char **endptr, Node *escontext)
static int estimate_ln_dweight(const NumericVar *var)
Datum numeric_lcm(PG_FUNCTION_ARGS)
static int cmp_var(const NumericVar *var1, const NumericVar *var2)
Datum numeric_div_trunc(PG_FUNCTION_ARGS)
static int numeric_sign_internal(Numeric num)
Datum int8_accum(PG_FUNCTION_ARGS)
static int select_div_scale(const NumericVar *var1, const NumericVar *var2)
Datum numeric_avg_deserialize(PG_FUNCTION_ARGS)
#define NUMERIC_ABBREV_NAN
static int cmp_abs_common(const NumericDigit *var1digits, int var1ndigits, int var1weight, const NumericDigit *var2digits, int var2ndigits, int var2weight)
Datum numeric_poly_stddev_pop(PG_FUNCTION_ARGS)
static bool apply_typmod(NumericVar *var, int32 typmod, Node *escontext)
#define NUMERIC_IS_NINF(n)
Datum numeric_float8(PG_FUNCTION_ARGS)
Datum int2_avg_accum_inv(PG_FUNCTION_ARGS)
static const NumericVar const_zero_point_nine
static int cmp_abs(const NumericVar *var1, const NumericVar *var2)
static const NumericVar const_zero
Datum numeric_in(PG_FUNCTION_ARGS)
#define NUMERIC_ABBREV_NINF
static void accum_sum_combine(NumericSumAccum *accum, NumericSumAccum *accum2)
static void numericvar_deserialize(StringInfo buf, NumericVar *var)
static const int round_powers[4]
Datum numeric_mod(PG_FUNCTION_ARGS)
struct NumericSumAccum NumericSumAccum
bool numeric_is_nan(Numeric num)
#define NUMERIC_SIGN_MASK
Datum numeric_lt(PG_FUNCTION_ARGS)
static void div_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale, bool round)
#define NUMERIC_DSCALE_MASK
Numeric numeric_sub_opt_error(Numeric num1, Numeric num2, bool *have_error)
Datum numeric_var_samp(PG_FUNCTION_ARGS)
Datum numeric_sortsupport(PG_FUNCTION_ARGS)
Numeric numeric_mul_opt_error(Numeric num1, Numeric num2, bool *have_error)
struct NumericVar NumericVar
static void int64_to_numericvar(int64 val, NumericVar *var)
Datum int8_avg_deserialize(PG_FUNCTION_ARGS)
static bool numericvar_to_int64(const NumericVar *var, int64 *result)
Datum numeric_float8_no_overflow(PG_FUNCTION_ARGS)
Datum numeric_combine(PG_FUNCTION_ARGS)
Datum int8_avg_combine(PG_FUNCTION_ARGS)
Datum int8_avg_accum(PG_FUNCTION_ARGS)
Datum numeric_sign(PG_FUNCTION_ARGS)
Datum int2_numeric(PG_FUNCTION_ARGS)
static int numeric_typmod_precision(int32 typmod)
#define NUMERIC_DSCALE_MAX
Datum int4_sum(PG_FUNCTION_ARGS)
static void alloc_var(NumericVar *var, int ndigits)
static int xdigit_value(char dig)
static Numeric make_result(const NumericVar *var)
static const NumericDigit const_one_point_one_data[2]
#define NUMERIC_SHORT_DSCALE_MASK
#define NumericAbbrevGetDatum(X)
#define NUMERIC_SHORT_DSCALE_SHIFT
static void accum_sum_reset(NumericSumAccum *accum)
#define NUMERIC_WEIGHT(n)
Datum numeric_add(PG_FUNCTION_ARGS)
static void round_var(NumericVar *var, int rscale)
Datum numeric_poly_avg(PG_FUNCTION_ARGS)
Datum numeric_eq(PG_FUNCTION_ARGS)
static void set_var_from_var(const NumericVar *value, NumericVar *dest)
static void log_var(const NumericVar *base, const NumericVar *num, NumericVar *result)
Datum numeric_ln(PG_FUNCTION_ARGS)
#define NUMERIC_SHORT_SIGN_MASK
static bool numericvar_to_uint64(const NumericVar *var, uint64 *result)
Datum numeric_abs(PG_FUNCTION_ARGS)
Datum int8_avg(PG_FUNCTION_ARGS)
Datum numeric_avg_accum(PG_FUNCTION_ARGS)
Datum numeric_larger(PG_FUNCTION_ARGS)
static const NumericVar const_one_point_one
Datum int4_avg_accum(PG_FUNCTION_ARGS)
static void strip_var(NumericVar *var)
static const NumericVar const_nan
#define NUMERIC_IS_SHORT(n)
Datum numeric_smaller(PG_FUNCTION_ARGS)
Datum numeric_gt(PG_FUNCTION_ARGS)
Datum numeric_deserialize(PG_FUNCTION_ARGS)
char * numeric_out_sci(Numeric num, int scale)
#define NUMERIC_DIGITS(num)
Datum int8_numeric(PG_FUNCTION_ARGS)
Datum numeric_mul(PG_FUNCTION_ARGS)
#define NUMERIC_IS_NAN(n)
#define makePolyNumAggStateCurrentContext
static const NumericDigit const_zero_data[1]
static double numericvar_to_double_no_overflow(const NumericVar *var)
Datum numeric_avg_combine(PG_FUNCTION_ARGS)
Datum numeric_min_scale(PG_FUNCTION_ARGS)
Numeric numeric_add_opt_error(Numeric num1, Numeric num2, bool *have_error)
Datum numeric_float4(PG_FUNCTION_ARGS)
Datum numeric_support(PG_FUNCTION_ARGS)
static const NumericVar const_one
#define NUMERIC_NDIGITS(num)
NumericAggState PolyNumAggState
static void accum_sum_rescale(NumericSumAccum *accum, const NumericVar *val)
static int cmp_var_common(const NumericDigit *var1digits, int var1ndigits, int var1weight, int var1sign, const NumericDigit *var2digits, int var2ndigits, int var2weight, int var2sign)
bool numeric_is_inf(Numeric num)
static void ln_var(const NumericVar *arg, NumericVar *result, int rscale)
Datum numeric_pg_lsn(PG_FUNCTION_ARGS)
static void power_ten_int(int exp, NumericVar *result)
static void accum_sum_copy(NumericSumAccum *dst, NumericSumAccum *src)
Datum numeric_floor(PG_FUNCTION_ARGS)
Datum int2_avg_accum(PG_FUNCTION_ARGS)
static void div_mod_var(const NumericVar *var1, const NumericVar *var2, NumericVar *quot, NumericVar *rem)
#define Assert(condition)
#define FLEXIBLE_ARRAY_MEMBER
#define StaticAssertDecl(condition, errmessage)
static void PGresult * res
int errdetail(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereturn(context, dummy_value,...)
#define ereport(elevel,...)
Datum float8in(PG_FUNCTION_ARGS)
Datum float4in(PG_FUNCTION_ARGS)
static float4 get_float4_infinity(void)
static float4 get_float4_nan(void)
static float8 get_float8_infinity(void)
static float8 get_float8_nan(void)
#define PG_FREE_IF_COPY(ptr, n)
#define PG_RETURN_UINT32(x)
#define PG_GETARG_BYTEA_PP(n)
#define PG_RETURN_BYTEA_P(x)
#define DirectFunctionCall2(func, arg1, arg2)
#define PG_GETARG_FLOAT8(n)
#define PG_RETURN_FLOAT8(x)
#define PG_GETARG_POINTER(n)
#define PG_RETURN_CSTRING(x)
#define PG_RETURN_INT64(x)
#define DirectFunctionCall1(func, arg1)
#define PG_GETARG_CSTRING(n)
#define PG_GETARG_INT64(n)
#define PG_DETOAST_DATUM_PACKED(datum)
#define PG_RETURN_UINT64(x)
#define PG_RETURN_INT16(x)
#define PG_RETURN_INT32(x)
#define PG_GETARG_INT32(n)
#define PG_GETARG_BOOL(n)
#define PG_RETURN_DATUM(x)
#define PG_GETARG_FLOAT4(n)
#define PG_RETURN_POINTER(x)
#define PG_RETURN_FLOAT4(x)
#define PG_RETURN_BOOL(x)
#define PG_GETARG_INT16(n)
#define SRF_IS_FIRSTCALL()
#define SRF_PERCALL_SETUP()
#define SRF_RETURN_NEXT(_funcctx, _result)
#define SRF_FIRSTCALL_INIT()
#define SRF_RETURN_DONE(_funcctx)
static Datum hash_uint32(uint32 k)
static Datum hash_any_extended(const unsigned char *k, int keylen, uint64 seed)
static Datum hash_any(const unsigned char *k, int keylen)
static const FormData_pg_attribute a1
void initHyperLogLog(hyperLogLogState *cState, uint8 bwidth)
double estimateHyperLogLog(hyperLogLogState *cState)
void addHyperLogLog(hyperLogLogState *cState, uint32 hash)
static bool pg_mul_s64_overflow(int64 a, int64 b, int64 *result)
static bool pg_sub_s64_overflow(int64 a, int64 b, int64 *result)
static bool pg_add_u64_overflow(uint64 a, uint64 b, uint64 *result)
static bool pg_mul_u64_overflow(uint64 a, uint64 b, uint64 *result)
char * pstrdup(const char *in)
void pfree(void *pointer)
void * palloc0(Size size)
MemoryContext CurrentMemoryContext
#define CHECK_FOR_INTERRUPTS()
int AggCheckCallContext(FunctionCallInfo fcinfo, MemoryContext *aggcontext)
int32 exprTypmod(const Node *expr)
Node * relabel_to_typmod(Node *expr, int32 typmod)
#define IsA(nodeptr, _type_)
#define NUMERIC_MIN_SCALE
#define NUMERIC_MAX_PRECISION
#define NUMERIC_MAX_RESULT_SCALE
#define NUMERIC_MAX_DISPLAY_SCALE
#define NUMERIC_MIN_SIG_DIGITS
static Numeric DatumGetNumeric(Datum X)
#define PG_GETARG_NUMERIC(n)
struct NumericData * Numeric
#define NUMERIC_MAX_SCALE
#define NUMERIC_MIN_DISPLAY_SCALE
#define PG_RETURN_NUMERIC(x)
static Datum NumericGetDatum(Numeric X)
static int list_length(const List *l)
uint64 pg_prng_uint64_range(pg_prng_state *state, uint64 rmin, uint64 rmax)
static rewind_source * source
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
static uint32 DatumGetUInt32(Datum X)
static uint64 DatumGetUInt64(Datum X)
#define Int64GetDatumFast(X)
static char * DatumGetCString(Datum X)
static Datum UInt64GetDatum(uint64 X)
static Pointer DatumGetPointer(Datum X)
static Datum CStringGetDatum(const char *X)
static int32 DatumGetInt32(Datum X)
MemoryContextSwitchTo(old_ctx)
static int cmp(const chr *x, const chr *y, size_t len)
struct SortSupportData * SortSupport
StringInfoData * StringInfo
static void initReadOnlyStringInfo(StringInfo str, char *data, int len)
MemoryContext multi_call_memory_ctx
MemoryContext agg_context
union NumericChoice choice
NumericDigit n_data[FLEXIBLE_ARRAY_MEMBER]
NumericDigit n_data[FLEXIBLE_ARRAY_MEMBER]
hyperLogLogState abbr_card
int(* comparator)(Datum x, Datum y, SortSupport ssup)
Datum(* abbrev_converter)(Datum original, SortSupport ssup)
int(* abbrev_full_comparator)(Datum x, Datum y, SortSupport ssup)
bool(* abbrev_abort)(int memtupcount, SortSupport ssup)
struct NumericLong n_long
struct NumericShort n_short
#define VARSIZE_SHORT(PTR)
#define VARATT_IS_SHORT(PTR)
#define SET_VARSIZE(PTR, len)
#define VARDATA_SHORT(PTR)
#define VARSIZE_ANY_EXHDR(PTR)