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))
257 #define NUMERIC_WEIGHT_MAX PG_INT16_MAX
401 #define NUMERIC_ABBREV_BITS (SIZEOF_DATUM * BITS_PER_BYTE)
402 #if SIZEOF_DATUM == 8
403 #define NumericAbbrevGetDatum(X) ((Datum) (X))
404 #define DatumGetNumericAbbrev(X) ((int64) (X))
405 #define NUMERIC_ABBREV_NAN NumericAbbrevGetDatum(PG_INT64_MIN)
406 #define NUMERIC_ABBREV_PINF NumericAbbrevGetDatum(-PG_INT64_MAX)
407 #define NUMERIC_ABBREV_NINF NumericAbbrevGetDatum(PG_INT64_MAX)
409 #define NumericAbbrevGetDatum(X) ((Datum) (X))
410 #define DatumGetNumericAbbrev(X) ((int32) (X))
411 #define NUMERIC_ABBREV_NAN NumericAbbrevGetDatum(PG_INT32_MIN)
412 #define NUMERIC_ABBREV_PINF NumericAbbrevGetDatum(-PG_INT32_MAX)
413 #define NUMERIC_ABBREV_NINF NumericAbbrevGetDatum(PG_INT32_MAX)
438 #elif DEC_DIGITS == 2
440 #elif DEC_DIGITS == 1
448 #elif DEC_DIGITS == 2
450 #elif DEC_DIGITS == 1
479 #define dump_numeric(s,n)
480 #define dump_var(s,v)
483 #define digitbuf_alloc(ndigits) \
484 ((NumericDigit *) palloc((ndigits) * sizeof(NumericDigit)))
485 #define digitbuf_free(buf) \
491 #define init_var(v) memset(v, 0, sizeof(NumericVar))
493 #define NUMERIC_DIGITS(num) (NUMERIC_HEADER_IS_SHORT(num) ? \
494 (num)->choice.n_short.n_data : (num)->choice.n_long.n_data)
495 #define NUMERIC_NDIGITS(num) \
496 ((VARSIZE(num) - NUMERIC_HEADER_SIZE(num)) / sizeof(NumericDigit))
497 #define NUMERIC_CAN_BE_SHORT(scale,weight) \
498 ((scale) <= NUMERIC_SHORT_DSCALE_MAX && \
499 (weight) <= NUMERIC_SHORT_WEIGHT_MAX && \
500 (weight) >= NUMERIC_SHORT_WEIGHT_MIN)
510 const char *cp,
int sign,
535 static bool numericvar_to_int128(
const NumericVar *var, int128 *result);
536 static void int128_to_numericvar(int128
val,
NumericVar *var);
551 int var1weight,
int var1sign,
553 int var2weight,
int var2sign);
565 int rscale,
bool round);
571 static void div_var_int64(
const NumericVar *var, int64 ival,
int ival_weight,
644 Node *escontext = fcinfo->context;
647 const char *numstart;
654 if (!isspace((
unsigned char) *cp))
682 if (!isdigit((
unsigned char) *cp) && *cp !=
'.')
715 if (!isspace((
unsigned char) *cp))
772 &
value, &cp, escontext))
782 if (!isspace((
unsigned char) *cp))
794 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
795 errmsg(
"value overflows numeric format")));
804 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
805 errmsg(
"invalid input syntax for type %s: \"%s\"",
888 return (
arg.ndigits == 0 ||
arg.ndigits <=
arg.weight + 1);
929 return ((typmod -
VARHDRSZ) >> 16) & 0xffff;
944 return (((typmod -
VARHDRSZ) & 0x7ff) ^ 1024) - 1024;
1050 if (strchr(
str,
'.') != NULL)
1056 last = strlen(
str) - 1;
1057 while (
str[last] ==
'0')
1061 if (
str[last] ==
'.')
1065 str[last + 1] =
'\0';
1107 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1108 errmsg(
"invalid sign in external \"numeric\" value")));
1113 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1114 errmsg(
"invalid scale in external \"numeric\" value")));
1116 for (
i = 0;
i <
len;
i++)
1120 if (d < 0 || d >=
NBASE)
1122 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1123 errmsg(
"invalid digit in external \"numeric\" value")));
1178 for (
i = 0;
i <
x.ndigits;
i++)
1230 new_scale == old_scale && new_precision >= old_precision))
1299 new->choice.n_short.n_header =
1337 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1338 errmsg(
"NUMERIC precision %d must be between 1 and %d",
1342 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1343 errmsg(
"NUMERIC scale %d must be between %d and %d",
1351 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1352 errmsg(
"NUMERIC precision %d must be between 1 and %d",
1360 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1361 errmsg(
"invalid NUMERIC type modifier")));
1404 res->choice.n_short.n_header =
1409 res->choice.n_short.n_header =
1434 res->choice.n_short.n_header =
1447 res->choice.n_short.n_header =
1450 res->choice.n_long.n_sign_dscale =
1453 res->choice.n_long.n_sign_dscale =
1726 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1727 errmsg(
"start value cannot be NaN")));
1730 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1731 errmsg(
"start value cannot be infinity")));
1737 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1738 errmsg(
"stop value cannot be NaN")));
1741 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1742 errmsg(
"stop value cannot be infinity")));
1754 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1755 errmsg(
"step size cannot be NaN")));
1758 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1759 errmsg(
"step size cannot be infinity")));
1766 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1767 errmsg(
"step size cannot equal zero")));
1858 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1859 errmsg(
"count must be greater than zero")));
1869 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1870 errmsg(
"operand, lower bound, and upper bound cannot be NaN")));
1874 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1875 errmsg(
"lower and upper bounds must be finite")));
1888 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1889 errmsg(
"lower bound cannot equal upper bound")));
1918 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1919 errmsg(
"integer out of range")));
1954 sub_var(&operand_var, &bound1_var, &operand_var);
1955 sub_var(&bound2_var, &bound1_var, &bound2_var);
1957 mul_var(&operand_var, count_var, &operand_var,
1959 div_var(&operand_var, &bound2_var, result_var, 0,
false);
2098 pfree(original_varatt);
2117 if (memtupcount < 10000 || nss->input_count < 10000 || !nss->estimating)
2128 if (abbr_card > 100000.0)
2133 "numeric_abbrev: estimation ends at cardinality %f"
2150 if (abbr_card < nss->input_count / 10000.0 + 0.5)
2155 "numeric_abbrev: aborting abbreviation at cardinality %f"
2156 " below threshold %f after " INT64_FORMAT " values (%d rows)",
2166 "numeric_abbrev: cardinality %f"
2266 #if NUMERIC_ABBREV_BITS == 64
2272 int weight = var->
weight;
2275 if (ndigits == 0 || weight < -44)
2279 else if (weight > 83)
2285 result = ((int64) (weight + 44) << 56);
2290 result |= ((int64) var->
digits[3]);
2293 result |= ((int64) var->
digits[2]) << 14;
2296 result |= ((int64) var->
digits[1]) << 28;
2299 result |= ((int64) var->
digits[0]) << 42;
2311 ^ (
uint32) ((uint64) result >> 32));
2321 #if NUMERIC_ABBREV_BITS == 32
2327 int weight = var->
weight;
2330 if (ndigits == 0 || weight < -11)
2334 else if (weight > 20)
2342 weight = (weight + 11) * 4;
2354 result = (result * 1000) + (nxt1 / 10);
2357 else if (result > 99)
2360 result = (result * 10000) + nxt1;
2363 else if (result > 9)
2368 result = (result * 100000) + (nxt1 * 10) + (nxt2 / 1000);
2376 result = (result * 1000000) + (nxt1 * 100) + (nxt2 / 100);
2379 result = result | (weight << 24);
2583 (
errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
2584 errmsg(
"invalid preceding or following size in window function")));
2681 sub_var(&basev, &offsetv, &sum);
2683 add_var(&basev, &offsetv, &sum);
2686 result = (
cmp_var(&valv, &sum) <= 0);
2688 result = (
cmp_var(&valv, &sum) >= 0);
2771 result = digit_hash ^ weight;
2913 add_var(&arg1, &arg2, &result);
2991 sub_var(&arg1, &arg2, &result);
3157 *have_error =
false;
3179 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3180 errmsg(
"division by zero")));
3202 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3203 errmsg(
"division by zero")));
3238 if (have_error && (arg2.
ndigits == 0 || arg2.
digits[0] == 0))
3247 div_var(&arg1, &arg2, &result, rscale,
true);
3287 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3288 errmsg(
"division by zero")));
3305 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3306 errmsg(
"division by zero")));
3336 div_var(&arg1, &arg2, &result, 0,
false);
3380 *have_error =
false;
3401 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3402 errmsg(
"division by zero")));
3419 if (have_error && (arg2.
ndigits == 0 || arg2.
digits[0] == 0))
3425 mod_var(&arg1, &arg2, &result);
3552 gcd_var(&arg1, &arg2, &result);
3606 gcd_var(&arg1, &arg2, &result);
3607 div_var(&arg1, &result, &result, 0,
false);
3637 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
3638 errmsg(
"factorial of a negative number is undefined")));
3647 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
3648 errmsg(
"value overflows numeric format")));
3655 for (num = num - 1; num > 1; num--)
3662 mul_var(&result, &fact, &result, 0);
3697 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
3698 errmsg(
"cannot take square root of a negative number")));
3719 #if DEC_DIGITS == ((DEC_DIGITS / 2) * 2)
3722 if (
arg.weight >= 0)
3729 rscale =
Max(rscale,
arg.dscale);
3789 val *= 0.434294481903252;
3796 rscale =
Max(rscale,
arg.dscale);
3835 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
3836 errmsg(
"cannot take logarithm of a negative number")));
3848 rscale =
Max(rscale,
arg.dscale);
3890 if (sign1 < 0 || sign2 < 0)
3892 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
3893 errmsg(
"cannot take logarithm of a negative number")));
3895 if (sign1 == 0 || sign2 == 0)
3897 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
3898 errmsg(
"cannot take logarithm of zero")));
3923 log_var(&arg1, &arg2, &result);
3983 if (sign1 == 0 && sign2 < 0)
3985 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
3986 errmsg(
"zero raised to a negative power is undefined")));
3989 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
3990 errmsg(
"a negative number raised to a non-integer power yields a complex result")));
4016 if (sign1 == 0 && sign2 > 0)
4035 abs_x_gt_one =
true;
4044 if (abs_x_gt_one == (sign2 > 0))
4095 if (sign1 == 0 && sign2 < 0)
4097 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
4098 errmsg(
"zero raised to a negative power is undefined")));
4150 last_digit_pos = var->
ndigits - 1;
4151 while (last_digit_pos >= 0 &&
4152 var->
digits[last_digit_pos] == 0)
4155 if (last_digit_pos >= 0)
4172 while (last_digit % 10 == 0)
4244 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4245 errmsg(
"lower bound cannot be NaN"));
4248 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4249 errmsg(
"lower bound cannot be infinity"));
4255 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4256 errmsg(
"upper bound cannot be NaN"));
4259 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4260 errmsg(
"upper bound cannot be infinity"));
4319 rscale = log10val2 < 0 ? 0 : log10val2;
4339 static const int pow10[] = {1, 10, 100, 1000};
4340 #elif DEC_DIGITS == 2
4341 static const int pow10[] = {1, 10};
4342 #elif DEC_DIGITS == 1
4343 static const int pow10[] = {1};
4345 #error unsupported NBASE
4358 tmp = (int128) val1 * (int128) factor;
4360 int128_to_numericvar(tmp, &result);
4369 mul_var(&result, &tmp, &result, 0);
4407 *have_error =
false;
4420 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4421 errmsg(
"cannot convert NaN to %s",
"integer")));
4424 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4425 errmsg(
"cannot convert infinity to %s",
"integer")));
4442 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4443 errmsg(
"integer out of range")));
4495 *have_error =
false;
4508 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4509 errmsg(
"cannot convert NaN to %s",
"bigint")));
4512 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4513 errmsg(
"cannot convert infinity to %s",
"bigint")));
4530 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4531 errmsg(
"bigint out of range")));
4568 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4569 errmsg(
"cannot convert NaN to %s",
"smallint")));
4572 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4573 errmsg(
"cannot convert infinity to %s",
"smallint")));
4581 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4582 errmsg(
"smallint out of range")));
4586 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4587 errmsg(
"smallint out of range")));
4602 char buf[DBL_DIG + 100];
4696 char buf[FLT_DIG + 100];
4764 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4765 errmsg(
"cannot convert NaN to %s",
"pg_lsn")));
4768 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4769 errmsg(
"cannot convert infinity to %s",
"pg_lsn")));
4777 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4778 errmsg(
"pg_lsn out of range")));
4813 #define NA_TOTAL_COUNT(na) \
4814 ((na)->N + (na)->NaNcount + (na)->pInfcount + (na)->nInfcount)
4828 elog(
ERROR,
"aggregate function called in non-aggregate context");
4833 state->calcSumX2 = calcSumX2;
4834 state->agg_context = agg_context;
4851 state->calcSumX2 = calcSumX2;
4889 state->maxScaleCount = 1;
4892 state->maxScaleCount++;
4895 if (
state->calcSumX2)
4909 if (
state->calcSumX2)
4961 if (
state->maxScaleCount > 1 ||
state->maxScale == 0)
4967 state->maxScaleCount--;
4969 else if (
state->N == 1)
4972 state->maxScale = 0;
4973 state->maxScaleCount = 0;
4983 if (
state->calcSumX2)
4998 if (
state->calcSumX2)
5011 if (
state->calcSumX2)
5052 elog(
ERROR,
"aggregate function called in non-aggregate context");
5066 state1->
N = state2->
N;
5081 state1->
N += state2->
N;
5144 elog(
ERROR,
"aggregate function called in non-aggregate context");
5158 state1->
N = state2->
N;
5172 state1->
N += state2->
N;
5217 elog(
ERROR,
"aggregate function called in non-aggregate context");
5268 elog(
ERROR,
"aggregate function called in non-aggregate context");
5327 elog(
ERROR,
"aggregate function called in non-aggregate context");
5382 elog(
ERROR,
"aggregate function called in non-aggregate context");
5443 elog(
ERROR,
"numeric_accum_inv called with NULL state");
5471 typedef struct Int128AggState
5483 static Int128AggState *
5486 Int128AggState *
state;
5491 elog(
ERROR,
"aggregate function called in non-aggregate context");
5495 state = (Int128AggState *)
palloc0(
sizeof(Int128AggState));
5496 state->calcSumX2 = calcSumX2;
5507 static Int128AggState *
5508 makeInt128AggStateCurrentContext(
bool calcSumX2)
5510 Int128AggState *
state;
5512 state = (Int128AggState *)
palloc0(
sizeof(Int128AggState));
5513 state->calcSumX2 = calcSumX2;
5522 do_int128_accum(Int128AggState *
state, int128
newval)
5524 if (
state->calcSumX2)
5535 do_int128_discard(Int128AggState *
state, int128
newval)
5537 if (
state->calcSumX2)
5545 #define makePolyNumAggState makeInt128AggState
5546 #define makePolyNumAggStateCurrentContext makeInt128AggStateCurrentContext
5549 #define makePolyNumAggState makeNumericAggState
5550 #define makePolyNumAggStateCurrentContext makeNumericAggStateCurrentContext
5628 elog(
ERROR,
"aggregate function called in non-aggregate context");
5642 state1->
N = state2->
N;
5659 state1->
N += state2->
N;
5694 elog(
ERROR,
"aggregate function called in non-aggregate context");
5716 int128_to_numericvar(
state->sumX, &tmp_var);
5724 int128_to_numericvar(
state->sumX2, &tmp_var);
5751 elog(
ERROR,
"aggregate function called in non-aggregate context");
5772 numericvar_to_int128(&tmp_var, &result->
sumX);
5780 numericvar_to_int128(&tmp_var, &result->
sumX2);
5831 elog(
ERROR,
"aggregate function called in non-aggregate context");
5845 state1->
N = state2->
N;
5859 state1->
N += state2->
N;
5892 elog(
ERROR,
"aggregate function called in non-aggregate context");
5914 int128_to_numericvar(
state->sumX, &tmp_var);
5940 elog(
ERROR,
"aggregate function called in non-aggregate context");
5961 numericvar_to_int128(&tmp_var, &result->
sumX);
5986 elog(
ERROR,
"int2_accum_inv called with NULL state");
5995 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6011 elog(
ERROR,
"int4_accum_inv called with NULL state");
6020 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6036 elog(
ERROR,
"int8_accum_inv called with NULL state");
6042 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6057 elog(
ERROR,
"int8_avg_accum_inv called with NULL state");
6066 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6089 int128_to_numericvar(
state->sumX, &result);
6118 int128_to_numericvar(
state->sumX, &result);
6145 if (
state->NaNcount > 0)
6149 if (
state->pInfcount > 0 &&
state->nInfcount > 0)
6151 if (
state->pInfcount > 0)
6153 if (
state->nInfcount > 0)
6179 if (
state->NaNcount > 0)
6183 if (
state->pInfcount > 0 &&
state->nInfcount > 0)
6185 if (
state->pInfcount > 0)
6187 if (
state->nInfcount > 0)
6211 bool variance,
bool sample,
6233 if (sample && totCount <= 1)
6245 if (
state->NaNcount > 0 ||
state->pInfcount > 0 ||
state->nInfcount > 0)
6261 rscale = vsumX.
dscale * 2;
6263 mul_var(&vsumX, &vsumX, &vsumX, rscale);
6264 mul_var(&vN, &vsumX2, &vsumX2, rscale);
6265 sub_var(&vsumX2, &vsumX, &vsumX2);
6275 mul_var(&vN, &vNminus1, &vNminus1, 0);
6277 mul_var(&vN, &vN, &vNminus1, 0);
6279 div_var(&vsumX2, &vNminus1, &vsumX, rscale,
true);
6363 numeric_poly_stddev_internal(Int128AggState *
state,
6364 bool variance,
bool sample,
6381 int128_to_numericvar(
state->sumX, &tmp_var);
6384 int128_to_numericvar(
state->sumX2, &tmp_var);
6417 res = numeric_poly_stddev_internal(
state,
true,
true, &is_null);
6438 res = numeric_poly_stddev_internal(
state,
false,
true, &is_null);
6459 res = numeric_poly_stddev_internal(
state,
true,
false, &is_null);
6480 res = numeric_poly_stddev_internal(
state,
false,
false, &is_null);
6533 #ifndef USE_FLOAT8_BYVAL
6582 #ifndef USE_FLOAT8_BYVAL
6679 elog(
ERROR,
"expected 2-element int8 array");
6707 elog(
ERROR,
"expected 2-element int8 array");
6725 elog(
ERROR,
"aggregate function called in non-aggregate context");
6732 elog(
ERROR,
"expected 2-element int8 array");
6736 elog(
ERROR,
"expected 2-element int8 array");
6742 state1->
sum += state2->
sum;
6766 elog(
ERROR,
"expected 2-element int8 array");
6794 elog(
ERROR,
"expected 2-element int8 array");
6813 elog(
ERROR,
"expected 2-element int8 array");
6817 if (transdata->
count == 0)
6838 elog(
ERROR,
"expected 2-element int8 array");
6842 if (transdata->
count == 0)
6856 #ifdef NUMERIC_DEBUG
6894 for (
i = 0;
i < ndigits;
i++)
7020 bool have_dp =
false;
7022 unsigned char *decdigits;
7055 if (!isdigit((
unsigned char) *cp))
7056 goto invalid_syntax;
7066 if (isdigit((
unsigned char) *cp))
7068 decdigits[
i++] = *cp++ -
'0';
7074 else if (*cp ==
'.')
7077 goto invalid_syntax;
7082 goto invalid_syntax;
7084 else if (*cp ==
'_')
7088 if (!isdigit((
unsigned char) *cp))
7089 goto invalid_syntax;
7100 if (*cp ==
'e' || *cp ==
'E')
7118 else if (*cp ==
'-')
7125 if (!isdigit((
unsigned char) *cp))
7126 goto invalid_syntax;
7130 if (isdigit((
unsigned char) *cp))
7132 exponent = exponent * 10 + (*cp++ -
'0');
7136 else if (*cp ==
'_')
7140 if (!isdigit((
unsigned char) *cp))
7141 goto invalid_syntax;
7148 exponent = -exponent;
7150 dweight += (int) exponent;
7151 dscale -= (int) exponent;
7166 offset = (weight + 1) *
DEC_DIGITS - (dweight + 1);
7171 dest->weight = weight;
7172 dest->dscale = dscale;
7177 while (ndigits-- > 0)
7180 *
digits++ = ((decdigits[
i] * 10 + decdigits[
i + 1]) * 10 +
7181 decdigits[
i + 2]) * 10 + decdigits[
i + 3];
7182 #elif DEC_DIGITS == 2
7183 *
digits++ = decdigits[
i] * 10 + decdigits[
i + 1];
7184 #elif DEC_DIGITS == 1
7187 #error unsupported NBASE
7204 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7205 errmsg(
"value overflows numeric format")));
7209 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
7210 errmsg(
"invalid input syntax for type %s: \"%s\"",
7221 return dig >=
'0' && dig <=
'9' ? dig -
'0' :
7222 dig >=
'a' && dig <=
'f' ? dig -
'a' + 10 :
7223 dig >=
'A' && dig <=
'F' ? dig -
'A' + 10 : -1;
7248 const char **endptr,
Node *escontext)
7250 const char *firstdigit = cp;
7272 if (isxdigit((
unsigned char) *cp))
7294 else if (*cp ==
'_')
7298 if (!isxdigit((
unsigned char) *cp))
7299 goto invalid_syntax;
7309 if (*cp >=
'0' && *cp <=
'7')
7328 tmp = tmp * 8 + (*cp++ -
'0');
7331 else if (*cp ==
'_')
7335 if (*cp < '0' || *cp >
'7')
7336 goto invalid_syntax;
7346 if (*cp >=
'0' && *cp <=
'1')
7365 tmp = tmp * 2 + (*cp++ -
'0');
7368 else if (*cp ==
'_')
7372 if (*cp < '0' || *cp >
'1')
7373 goto invalid_syntax;
7381 goto invalid_syntax;
7385 goto invalid_syntax;
7407 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7408 errmsg(
"value overflows numeric format")));
7412 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
7413 errmsg(
"invalid input syntax for type %s: \"%s\"",
7478 if (
value->ndigits > 0)
7479 memcpy(newbuf + 1,
value->digits,
7486 dest->digits = newbuf + 1;
7545 for (d = 0; d <= var->
weight; d++)
7551 bool putit = (d > 0);
7570 #elif DEC_DIGITS == 2
7573 if (d1 > 0 || d > 0)
7576 #elif DEC_DIGITS == 1
7579 #error unsupported NBASE
7592 endcp = cp + dscale;
7697 div_var(var, &tmp_var, &tmp_var, rscale,
true);
7709 len = strlen(sig_out) + 13;
7756 for (
i = 0;
i <
len;
i++)
7790 int weight = var->
weight;
7796 *have_error =
false;
7823 while (n > 0 && *
digits == 0)
7830 while (n > 0 &&
digits[n - 1] == 0)
7846 result->choice.n_short.n_header =
7858 result->choice.n_long.n_sign_dscale =
7860 result->choice.n_long.n_weight = weight;
7879 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7880 errmsg(
"value overflows numeric format")));
7957 else if (dig < 1000)
7959 #elif DEC_DIGITS == 2
7962 #elif DEC_DIGITS == 1
7965 #error unsupported NBASE
7969 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7970 errmsg(
"numeric field overflow"),
7971 errdetail(
"A field with precision %d, scale %d must round to an absolute value less than %s%d.",
8020 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
8021 errmsg(
"numeric field overflow"),
8022 errdetail(
"A field with precision %d, scale %d cannot hold an infinite value.",
8023 precision,
scale)));
8063 Assert(weight >= 0 && ndigits <= weight + 1);
8073 for (
i = 1;
i <= weight;
i++)
8140 newuval = uval /
NBASE;
8141 *ptr = uval - newuval *
NBASE;
8146 var->
weight = ndigits - 1;
8191 Assert(weight >= 0 && ndigits <= weight + 1);
8196 for (
i = 1;
i <= weight;
i++)
8228 numericvar_to_int128(
const NumericVar *var, int128 *result)
8259 Assert(weight >= 0 && ndigits <= weight + 1);
8265 for (
i = 1;
i <= weight;
i++)
8281 if (!neg || (-
val) !=
val ||
val == 0 || oldval < 0)
8291 *result = neg ? -
val :
val;
8331 newuval = uval /
NBASE;
8332 *ptr = uval - newuval *
NBASE;
8337 var->
weight = ndigits - 1;
8354 val = strtod(tmp, &endptr);
8355 if (*endptr !=
'\0')
8359 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
8360 errmsg(
"invalid input syntax for type %s: \"%s\"",
8361 "double precision", tmp)));
8393 int var1weight,
int var1sign,
8395 int var2weight,
int var2sign)
8397 if (var1ndigits == 0)
8399 if (var2ndigits == 0)
8405 if (var2ndigits == 0)
8417 var2digits, var2ndigits, var2weight);
8424 var1digits, var1ndigits, var1weight);
8711 var1digits = var1->
digits;
8712 var2digits = var2->
digits;
8714 if (var1ndigits == 0)
8726 if (var1ndigits <= 4 && rscale == var1->dscale + var2->
dscale)
8751 res_ndigits = var1ndigits + var2ndigits + 1;
8756 if (res_ndigits < 3)
8780 dig = (
int *)
palloc0(res_ndigits *
sizeof(
int));
8792 for (i1 =
Min(var1ndigits - 1, res_ndigits - 3); i1 >= 0; i1--)
8800 maxdig += var1digit;
8801 if (maxdig > (INT_MAX - INT_MAX /
NBASE) / (
NBASE - 1))
8805 for (
i = res_ndigits - 1;
i >= 0;
i--)
8807 newdig = dig[
i] + carry;
8808 if (newdig >=
NBASE)
8810 carry = newdig /
NBASE;
8811 newdig -= carry *
NBASE;
8819 maxdig = 1 + var1digit;
8836 int i2limit =
Min(var2ndigits, res_ndigits - i1 - 2);
8837 int *dig_i1_2 = &dig[i1 + 2];
8839 for (i2 = 0; i2 < i2limit; i2++)
8840 dig_i1_2[i2] += var1digit * var2digits[i2];
8850 res_digits = result->
digits;
8852 for (
i = res_ndigits - 1;
i >= 0;
i--)
8854 newdig = dig[
i] + carry;
8855 if (newdig >=
NBASE)
8857 carry = newdig /
NBASE;
8858 newdig -= carry *
NBASE;
8862 res_digits[
i] = newdig;
8871 result->
weight = res_weight;
8872 result->
sign = res_sign;
8893 int var1ndigits = var1->
ndigits;
8894 int var2ndigits = var2->
ndigits;
8906 Assert(var1ndigits >= 1);
8907 Assert(var1ndigits <= 4);
8908 Assert(var2ndigits >= var1ndigits);
8922 res_ndigits = var1ndigits + var2ndigits;
8927 res_digits = res_buf + 1;
8934 switch (var1ndigits)
8945 for (
int i = res_ndigits - 2;
i >= 0;
i--)
8947 term = (
uint32) var1digits[0] * var2digits[
i] + carry;
8949 carry = term /
NBASE;
8963 term = (
uint32) var1digits[1] * var2digits[res_ndigits - 3];
8965 carry = term /
NBASE;
8968 for (
int i = res_ndigits - 3;
i >= 1;
i--)
8970 term = (
uint32) var1digits[0] * var2digits[
i] +
8971 (
uint32) var1digits[1] * var2digits[
i - 1] + carry;
8973 carry = term /
NBASE;
8977 term = (
uint32) var1digits[0] * var2digits[0] + carry;
8991 term = (
uint32) var1digits[2] * var2digits[res_ndigits - 4];
8993 carry = term /
NBASE;
8995 term = (
uint32) var1digits[1] * var2digits[res_ndigits - 4] +
8996 (
uint32) var1digits[2] * var2digits[res_ndigits - 5] + carry;
8998 carry = term /
NBASE;
9001 for (
int i = res_ndigits - 4;
i >= 2;
i--)
9003 term = (
uint32) var1digits[0] * var2digits[
i] +
9004 (
uint32) var1digits[1] * var2digits[
i - 1] +
9005 (
uint32) var1digits[2] * var2digits[
i - 2] + carry;
9007 carry = term /
NBASE;
9011 term = (
uint32) var1digits[0] * var2digits[1] +
9012 (
uint32) var1digits[1] * var2digits[0] + carry;
9014 carry = term /
NBASE;
9016 term = (
uint32) var1digits[0] * var2digits[0] + carry;
9030 term = (
uint32) var1digits[3] * var2digits[res_ndigits - 5];
9032 carry = term /
NBASE;
9034 term = (
uint32) var1digits[2] * var2digits[res_ndigits - 5] +
9035 (
uint32) var1digits[3] * var2digits[res_ndigits - 6] + carry;
9037 carry = term /
NBASE;
9039 term = (
uint32) var1digits[1] * var2digits[res_ndigits - 5] +
9040 (
uint32) var1digits[2] * var2digits[res_ndigits - 6] +
9041 (
uint32) var1digits[3] * var2digits[res_ndigits - 7] + carry;
9043 carry = term /
NBASE;
9046 for (
int i = res_ndigits - 5;
i >= 3;
i--)
9048 term = (
uint32) var1digits[0] * var2digits[
i] +
9049 (
uint32) var1digits[1] * var2digits[
i - 1] +
9050 (
uint32) var1digits[2] * var2digits[
i - 2] +
9051 (
uint32) var1digits[3] * var2digits[
i - 3] + carry;
9053 carry = term /
NBASE;
9057 term = (
uint32) var1digits[0] * var2digits[2] +
9058 (
uint32) var1digits[1] * var2digits[1] +
9059 (
uint32) var1digits[2] * var2digits[0] + carry;
9061 carry = term /
NBASE;
9063 term = (
uint32) var1digits[0] * var2digits[1] +
9064 (
uint32) var1digits[1] * var2digits[0] + carry;
9066 carry = term /
NBASE;
9068 term = (
uint32) var1digits[0] * var2digits[0] + carry;
9076 result->
ndigits = res_ndigits;
9077 result->
buf = res_buf;
9078 result->
digits = res_digits;
9079 result->
weight = res_weight;
9080 result->
sign = res_sign;
9098 int rscale,
bool round)
9115 int var1ndigits = var1->
ndigits;
9116 int var2ndigits = var2->
ndigits;
9122 if (var2ndigits == 0 || var2->
digits[0] == 0)
9124 (
errcode(ERRCODE_DIVISION_BY_ZERO),
9125 errmsg(
"division by zero")));
9134 if (var2ndigits <= 2)
9137 int idivisor_weight;
9139 idivisor = var2->
digits[0];
9140 idivisor_weight = var2->
weight;
9141 if (var2ndigits == 2)
9147 idivisor = -idivisor;
9149 div_var_int(var1, idivisor, idivisor_weight, result, rscale, round);
9153 if (var2ndigits <= 4)
9156 int idivisor_weight;
9158 idivisor = var2->
digits[0];
9159 idivisor_weight = var2->
weight;
9160 for (
i = 1;
i < var2ndigits;
i++)
9166 idivisor = -idivisor;
9168 div_var_int64(var1, idivisor, idivisor_weight, result, rscale, round);
9178 if (var1ndigits == 0)
9198 res_ndigits =
Max(res_ndigits, 1);
9210 div_ndigits = res_ndigits + var2ndigits;
9211 div_ndigits =
Max(div_ndigits, var1ndigits);
9225 divisor = dividend + (div_ndigits + 1);
9233 res_digits = result->
digits;
9246 int d =
NBASE / (divisor[1] + 1);
9249 for (
i = var2ndigits;
i > 0;
i--)
9251 carry += divisor[
i] * d;
9252 divisor[
i] = carry %
NBASE;
9253 carry = carry /
NBASE;
9258 for (
i = var1ndigits;
i >= 0;
i--)
9260 carry += dividend[
i] * d;
9261 dividend[
i] = carry %
NBASE;
9262 carry = carry /
NBASE;
9268 divisor1 = divisor[1];
9269 divisor2 = divisor[2];
9277 for (
j = 0;
j < res_ndigits;
j++)
9280 int next2digits = dividend[
j] *
NBASE + dividend[
j + 1];
9288 if (next2digits == 0)
9294 if (dividend[
j] == divisor1)
9297 qhat = next2digits / divisor1;
9305 while (divisor2 * qhat >
9306 (next2digits - qhat * divisor1) *
NBASE + dividend[
j + 2])
9323 for (
i = var2ndigits;
i >= 0;
i--)
9327 tmp_result = dividend_j[
i] - borrow - divisor[
i] * qhat;
9329 dividend_j[
i] = tmp_result + borrow *
NBASE;
9344 for (
i = var2ndigits;
i >= 0;
i--)
9346 carry += dividend_j[
i] + divisor[
i];
9349 dividend_j[
i] = carry -
NBASE;
9354 dividend_j[
i] = carry;
9364 res_digits[
j] = qhat;
9372 result->
weight = res_weight;
9373 result->
sign = res_sign;
9426 int var1ndigits = var1->
ndigits;
9427 int var2ndigits = var2->
ndigits;
9435 if (var2ndigits == 0 || var2digits[0] == 0)
9437 (
errcode(ERRCODE_DIVISION_BY_ZERO),
9438 errmsg(
"division by zero")));
9447 if (var2ndigits <= 2)
9450 int idivisor_weight;
9452 idivisor = var2->
digits[0];
9453 idivisor_weight = var2->
weight;
9454 if (var2ndigits == 2)
9460 idivisor = -idivisor;
9462 div_var_int(var1, idivisor, idivisor_weight, result, rscale, round);
9466 if (var2ndigits <= 4)
9469 int idivisor_weight;
9471 idivisor = var2->
digits[0];
9472 idivisor_weight = var2->
weight;
9473 for (
i = 1;
i < var2ndigits;
i++)
9479 idivisor = -idivisor;
9481 div_var_int64(var1, idivisor, idivisor_weight, result, rscale, round);
9491 if (var1ndigits == 0)
9531 div = (
int *)
palloc0((div_ndigits + 1) *
sizeof(int));
9532 load_ndigits =
Min(div_ndigits, var1ndigits);
9533 for (
i = 0;
i < load_ndigits;
i++)
9534 div[
i + 1] = var1digits[
i];
9542 fdivisor = (double) var2digits[0];
9543 for (
i = 1;
i < 4;
i++)
9546 if (
i < var2ndigits)
9547 fdivisor += (double) var2digits[
i];
9549 fdivisorinverse = 1.0 / fdivisor;
9573 for (qi = 0; qi < div_ndigits; qi++)
9576 fdividend = (double) div[qi];
9577 for (
i = 1;
i < 4;
i++)
9580 if (qi +
i <= div_ndigits)
9581 fdividend += (double) div[qi +
i];
9584 fquotient = fdividend * fdivisorinverse;
9585 qdigit = (fquotient >= 0.0) ? ((
int) fquotient) :
9586 (((
int) fquotient) - 1);
9591 maxdiv += abs(qdigit);
9592 if (maxdiv > (INT_MAX - INT_MAX /
NBASE - 1) / (
NBASE - 1))
9602 for (
i =
Min(qi + var2ndigits - 2, div_ndigits);
i > qi;
i--)
9604 newdig = div[
i] + carry;
9607 carry = -((-newdig - 1) /
NBASE) - 1;
9608 newdig -= carry *
NBASE;
9610 else if (newdig >=
NBASE)
9612 carry = newdig /
NBASE;
9613 newdig -= carry *
NBASE;
9619 newdig = div[qi] + carry;
9633 fdividend = (double) div[qi];
9634 for (
i = 1;
i < 4;
i++)
9637 if (qi +
i <= div_ndigits)
9638 fdividend += (double) div[qi +
i];
9641 fquotient = fdividend * fdivisorinverse;
9642 qdigit = (fquotient >= 0.0) ? ((
int) fquotient) :
9643 (((
int) fquotient) - 1);
9644 maxdiv += abs(qdigit);
9667 int istop =
Min(var2ndigits, div_ndigits - qi + 1);
9668 int *div_qi = &div[qi];
9670 for (
i = 0;
i < istop;
i++)
9697 div[qi + 1] += div[qi] *
NBASE;
9705 fdividend = (double) div[qi];
9706 for (
i = 1;
i < 4;
i++)
9708 fquotient = fdividend * fdivisorinverse;
9709 qdigit = (fquotient >= 0.0) ? ((
int) fquotient) :
9710 (((
int) fquotient) - 1);
9722 res_digits = result->
digits;
9724 for (
i = div_ndigits;
i >= 0;
i--)
9726 newdig = div[
i] + carry;
9729 carry = -((-newdig - 1) /
NBASE) - 1;
9730 newdig -= carry *
NBASE;
9732 else if (newdig >=
NBASE)
9734 carry = newdig /
NBASE;
9735 newdig -= carry *
NBASE;
9739 res_digits[
i] = newdig;
9748 result->
weight = res_weight;
9749 result->
sign = res_sign;
9773 int var_ndigits = var->
ndigits;
9785 errcode(ERRCODE_DIVISION_BY_ZERO),
9786 errmsg(
"division by zero"));
9789 if (var_ndigits == 0)
9805 res_weight = var->
weight - ival_weight;
9809 res_ndigits =
Max(res_ndigits, 1);
9816 res_digits = res_buf + 1;
9828 divisor = abs(ival);
9830 if (divisor <= UINT_MAX /
NBASE)
9835 for (
i = 0;
i < res_ndigits;
i++)
9837 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9839 carry = carry % divisor;
9847 for (
i = 0;
i < res_ndigits;
i++)
9849 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9851 carry = carry % divisor;
9857 result->
ndigits = res_ndigits;
9858 result->
buf = res_buf;
9859 result->
digits = res_digits;
9860 result->
weight = res_weight;
9861 result->
sign = res_sign;
9885 div_var_int64(
const NumericVar *var, int64 ival,
int ival_weight,
9889 int var_ndigits = var->
ndigits;
9901 errcode(ERRCODE_DIVISION_BY_ZERO),
9902 errmsg(
"division by zero"));
9905 if (var_ndigits == 0)
9921 res_weight = var->
weight - ival_weight;
9925 res_ndigits =
Max(res_ndigits, 1);
9932 res_digits = res_buf + 1;
9951 for (
i = 0;
i < res_ndigits;
i++)
9953 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9955 carry = carry % divisor;
9963 for (
i = 0;
i < res_ndigits;
i++)
9965 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9967 carry = carry % divisor;
9973 result->
ndigits = res_ndigits;
9974 result->
buf = res_buf;
9975 result->
digits = res_digits;
9976 result->
weight = res_weight;
9977 result->
sign = res_sign;
10021 firstdigit1 = var1->
digits[
i];
10022 if (firstdigit1 != 0)
10033 firstdigit2 = var2->
digits[
i];
10034 if (firstdigit2 != 0)
10045 qweight = weight1 - weight2;
10046 if (firstdigit1 <= firstdigit2)
10078 div_var(var1, var2, &tmp, 0,
false);
10135 while (
cmp_abs(&r, var2) >= 0)
10244 result->
dscale = res_dscale;
10260 mod_var(&tmp_arg, result, &mod);
10267 result->
dscale = res_dscale;
10306 result->
dscale = rscale;
10316 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
10317 errmsg(
"cannot take square root of a negative number")));
10330 if (
arg->weight >= 0)
10331 res_weight =
arg->weight / 2;
10333 res_weight = -((-
arg->weight - 1) / 2 + 1);
10341 if (rscale + 1 >= 0)
10344 res_ndigits = res_weight + 1 - (-rscale - 1) /
DEC_DIGITS;
10345 res_ndigits =
Max(res_ndigits, 1);
10353 src_ndigits =
arg->weight + 1 + (res_ndigits - res_weight - 1) * 2;
10354 src_ndigits =
Max(src_ndigits, 1);
10424 while ((ndigits[step] = src_ndigits) > 4)
10427 blen = src_ndigits / 4;
10428 if (blen * 4 == src_ndigits &&
arg->digits[0] <
NBASE / 4)
10432 src_ndigits -= 2 * blen;
10444 arg_int64 =
arg->digits[0];
10445 for (src_idx = 1; src_idx < src_ndigits; src_idx++)
10447 arg_int64 *=
NBASE;
10448 if (src_idx < arg->ndigits)
10449 arg_int64 +=
arg->digits[src_idx];
10452 s_int64 = (int64) sqrt((
double) arg_int64);
10453 r_int64 = arg_int64 - s_int64 * s_int64;
10465 while (r_int64 < 0 || r_int64 > 2 * s_int64)
10467 s_int64 = (s_int64 + arg_int64 / s_int64) / 2;
10468 r_int64 = arg_int64 - s_int64 * s_int64;
10491 while (step >= 0 && (src_ndigits = ndigits[step]) <= 8)
10502 blen = (src_ndigits - src_idx) / 2;
10509 for (
i = 0;
i < blen;
i++, src_idx++)
10513 if (src_idx < arg->ndigits)
10514 a1 +=
arg->digits[src_idx];
10517 for (
i = 0;
i < blen;
i++, src_idx++)
10520 if (src_idx < arg->ndigits)
10521 a0 +=
arg->digits[src_idx];
10525 numer = r_int64 *
b +
a1;
10526 denom = 2 * s_int64;
10528 u = numer - q * denom;
10531 s_int64 = s_int64 *
b + q;
10532 r_int64 = u *
b + a0 - q * q;
10537 r_int64 += s_int64;
10539 r_int64 += s_int64;
10542 Assert(src_idx == src_ndigits);
10556 s_int128 = s_int64;
10557 r_int128 = r_int64;
10565 while (step >= 0 && (src_ndigits = ndigits[step]) <= 16)
10576 blen = (src_ndigits - src_idx) / 2;
10583 for (
i = 0;
i < blen;
i++, src_idx++)
10587 if (src_idx < arg->ndigits)
10588 a1 +=
arg->digits[src_idx];
10591 for (
i = 0;
i < blen;
i++, src_idx++)
10594 if (src_idx < arg->ndigits)
10595 a0 +=
arg->digits[src_idx];
10599 numer = r_int128 *
b +
a1;
10600 denom = 2 * s_int128;
10602 u = numer - q * denom;
10605 s_int128 = s_int128 *
b + q;
10606 r_int128 = u *
b + a0 - q * q;
10611 r_int128 += s_int128;
10613 r_int128 += s_int128;
10616 Assert(src_idx == src_ndigits);
10626 int128_to_numericvar(s_int128, &s_var);
10628 int128_to_numericvar(r_int128, &r_var);
10649 src_ndigits = ndigits[step];
10650 blen = (src_ndigits - src_idx) / 2;
10653 if (src_idx < arg->ndigits)
10655 tmp_len =
Min(blen,
arg->ndigits - src_idx);
10657 memcpy(a1_var.
digits,
arg->digits + src_idx,
10659 a1_var.
weight = blen - 1;
10671 if (src_idx < arg->ndigits)
10673 tmp_len =
Min(blen,
arg->ndigits - src_idx);
10675 memcpy(a0_var.
digits,
arg->digits + src_idx,
10677 a0_var.
weight = blen - 1;
10692 add_var(&q_var, &a1_var, &q_var);
10693 add_var(&s_var, &s_var, &u_var);
10698 add_var(&s_var, &q_var, &s_var);
10708 add_var(&u_var, &a0_var, &u_var);
10709 mul_var(&q_var, &q_var, &q_var, 0);
10714 sub_var(&u_var, &q_var, &r_var);
10718 add_var(&r_var, &s_var, &r_var);
10720 add_var(&r_var, &s_var, &r_var);
10726 if (
cmp_var(&u_var, &q_var) < 0)
10730 Assert(src_idx == src_ndigits);
10738 result->
weight = res_weight;
10790 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
10791 errmsg(
"value overflows numeric format")));
10793 result->
dscale = rscale;
10798 dweight = (int) (
val * 0.434294481903252);
10807 if (fabs(
val) > 0.01)
10812 while (fabs(
val) > 0.01)
10818 local_rscale =
x.dscale + ndiv2;
10831 sig_digits = 1 + dweight + rscale + (int) (ndiv2 * 0.301029995663981);
10832 sig_digits =
Max(sig_digits, 0) + 8;
10834 local_rscale = sig_digits - 1;
10848 div_var_int(&elem, ni, 0, &elem, local_rscale,
true);
10852 add_var(result, &elem, result);
10854 mul_var(&elem, &
x, &elem, local_rscale);
10856 div_var_int(&elem, ni, 0, &elem, local_rscale,
true);
10864 while (ndiv2-- > 0)
10868 mul_var(result, result, result, local_rscale);
10916 ln_dweight =
x.weight *
DEC_DIGITS + (int) log10(
x.digits[0]);
10953 ln_var = log((
double)
digits) + dweight * 2.302585092994046;
10954 ln_dweight = (int) log10(fabs(
ln_var));
10987 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
10988 errmsg(
"cannot take logarithm of zero")));
10991 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
10992 errmsg(
"cannot take logarithm of a negative number")));
11020 local_rscale = rscale -
x.weight *
DEC_DIGITS / 2 + 8;
11027 local_rscale = rscale -
x.weight *
DEC_DIGITS / 2 + 8;
11048 local_rscale = rscale + (int) ((nsqrt + 1) * 0.301029995663981) + 8;
11052 div_var_fast(result, &elem, result, local_rscale,
true);
11054 mul_var(result, result, &
x, local_rscale);
11061 mul_var(&xx, &
x, &xx, local_rscale);
11062 div_var_int(&xx, ni, 0, &elem, local_rscale,
true);
11067 add_var(result, &elem, result);
11074 mul_var(result, &fact, result, rscale);
11095 int ln_base_dweight;
11096 int ln_num_dweight;
11097 int result_dweight;
11099 int ln_base_rscale;
11108 result_dweight = ln_num_dweight - ln_base_dweight;
11125 ln_base_rscale = rscale + result_dweight - ln_base_dweight + 8;
11128 ln_num_rscale = rscale + result_dweight - ln_num_dweight + 8;
11132 ln_var(base, &ln_base, ln_base_rscale);
11133 ln_var(num, &ln_num, ln_num_rscale);
11136 div_var_fast(&ln_num, &ln_base, result, rscale,
true);
11207 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
11208 errmsg(
"a negative number raised to a non-integer power yields a complex result")));
11251 local_rscale = 8 - ln_dweight;
11254 ln_var(base, &ln_base, local_rscale);
11256 mul_var(&ln_base, exp, &ln_num, local_rscale);
11265 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11266 errmsg(
"value overflows numeric format")));
11272 val *= 0.434294481903252;
11282 sig_digits = rscale + (int)
val;
11283 sig_digits =
Max(sig_digits, 0);
11286 local_rscale = sig_digits - ln_dweight + 8;
11291 ln_var(base, &ln_base, local_rscale);
11293 mul_var(&ln_base, exp, &ln_num, local_rscale);
11295 exp_var(&ln_num, result, rscale);
11351 f = exp * (log10(f) + p);
11359 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11360 errmsg(
"value overflows numeric format")));
11375 rscale =
Max(rscale, exp_dscale);
11391 result->
dscale = rscale;
11401 mul_var(base, base, result, rscale);
11412 (
errcode(ERRCODE_DIVISION_BY_ZERO),
11413 errmsg(
"division by zero")));
11415 result->
dscale = rscale;
11433 sig_digits = 1 + rscale + (int) f;
11440 sig_digits += (int) log(fabs((
double) exp)) + 8;
11456 while ((mask >>= 1) > 0)
11464 local_rscale =
Min(local_rscale, 2 * base_prod.
dscale);
11467 mul_var(&base_prod, &base_prod, &base_prod, local_rscale);
11471 local_rscale = sig_digits -
11473 local_rscale =
Min(local_rscale,
11477 mul_var(&base_prod, result, result, local_rscale);
11494 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11495 errmsg(
"value overflows numeric format")));
11524 result->
dscale = exp < 0 ? -exp : 0;
11536 result->
digits[0] *= 10;
11553 int rlen64_ndigits;
11563 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
11564 errmsg(
"lower bound must be less than or equal to upper bound"));
11570 result->
dscale = rscale;
11589 for (
i = 0;
i < n;
i++)
11615 rlen64 = (uint64) rlen.
digits[0];
11616 rlen64_ndigits = 1;
11617 while (rlen64_ndigits < res_ndigits && rlen64_ndigits < 4)
11620 if (rlen64_ndigits < rlen.
ndigits)
11621 rlen64 += rlen.
digits[rlen64_ndigits];
11635 result->
dscale = rscale;
11636 res_digits = result->
digits;
11645 if (rlen64_ndigits == res_ndigits && pow10 != 1)
11650 for (
i = rlen64_ndigits - 1;
i >= 0;
i--)
11653 rand = rand /
NBASE;
11660 whole_ndigits = res_ndigits;
11665 i = rlen64_ndigits;
11666 while (
i < whole_ndigits - 3)
11671 rand = rand /
NBASE;
11673 rand = rand /
NBASE;
11675 rand = rand /
NBASE;
11680 while (
i < whole_ndigits)
11687 if (
i < res_ndigits)
11698 }
while (
cmp_var(result, &rlen) > 0);
11701 add_var(result, rmin, result);
11741 const NumericDigit *var2digits,
int var2ndigits,
int var2weight)
11748 while (var1weight > var2weight && i1 < var1ndigits)
11750 if (var1digits[i1++] != 0)
11754 while (var2weight > var1weight && i2 < var2ndigits)
11756 if (var2digits[i2++] != 0)
11763 if (var1weight == var2weight)
11765 while (i1 < var1ndigits && i2 < var2ndigits)
11767 int stat = var1digits[i1++] - var2digits[i2++];
11782 while (i1 < var1ndigits)
11784 if (var1digits[i1++] != 0)
11787 while (i2 < var2ndigits)
11789 if (var2digits[i2++] != 0)
11820 int var1ndigits = var1->
ndigits;
11821 int var2ndigits = var2->
ndigits;
11832 res_rscale =
Max(rscale1, rscale2);
11834 res_ndigits = res_rscale + res_weight + 1;
11835 if (res_ndigits <= 0)
11840 res_digits = res_buf + 1;
11842 i1 = res_rscale + var1->
weight + 1;
11843 i2 = res_rscale + var2->
weight + 1;
11844 for (
i = res_ndigits - 1;
i >= 0;
i--)
11848 if (i1 >= 0 && i1 < var1ndigits)
11849 carry += var1digits[i1];
11850 if (i2 >= 0 && i2 < var2ndigits)
11851 carry += var2digits[i2];
11853 if (carry >=
NBASE)
11855 res_digits[
i] = carry -
NBASE;
11860 res_digits[
i] = carry;
11868 result->
ndigits = res_ndigits;
11869 result->
buf = res_buf;
11870 result->
digits = res_digits;
11871 result->
weight = res_weight;
11872 result->
dscale = res_dscale;
11905 int var1ndigits = var1->
ndigits;
11906 int var2ndigits = var2->
ndigits;
11910 res_weight = var1->
weight;
11917 res_rscale =
Max(rscale1, rscale2);
11919 res_ndigits = res_rscale + res_weight + 1;
11920 if (res_ndigits <= 0)
11925 res_digits = res_buf + 1;
11927 i1 = res_rscale + var1->
weight + 1;
11928 i2 = res_rscale + var2->
weight + 1;
11929 for (
i = res_ndigits - 1;
i >= 0;
i--)
11933 if (i1 >= 0 && i1 < var1ndigits)
11934 borrow += var1digits[i1];
11935 if (i2 >= 0 && i2 < var2ndigits)
11936 borrow -= var2digits[i2];
11940 res_digits[
i] = borrow +
NBASE;
11945 res_digits[
i] = borrow;
11953 result->
ndigits = res_ndigits;
11954 result->
buf = res_buf;
11955 result->
digits = res_digits;
11956 result->
weight = res_weight;
11957 result->
dscale = res_dscale;
12001 if (ndigits < var->ndigits ||
12002 (ndigits == var->
ndigits && di > 0))
12006 #if DEC_DIGITS == 1
12018 #if DEC_DIGITS == 4
12020 #elif DEC_DIGITS == 2
12023 #error unsupported NBASE
12025 extra =
digits[--ndigits] % pow10;
12026 digits[ndigits] -= extra;
12028 if (extra >= pow10 / 2)
12030 pow10 +=
digits[ndigits];
12031 if (pow10 >=
NBASE)
12036 digits[ndigits] = pow10;
12044 carry +=
digits[--ndigits];
12045 if (carry >=
NBASE)
12052 digits[ndigits] = carry;
12101 if (ndigits <= var->ndigits)
12105 #if DEC_DIGITS == 1
12118 #if DEC_DIGITS == 4
12120 #elif DEC_DIGITS == 2
12123 #error unsupported NBASE
12125 extra =
digits[--ndigits] % pow10;
12126 digits[ndigits] -= extra;
12145 while (ndigits > 0 && *
digits == 0)
12153 while (ndigits > 0 &&
digits[ndigits - 1] == 0)
12198 int32 *accum_digits;
12227 val_ndigits =
val->ndigits;
12228 val_digits =
val->digits;
12231 for (val_i = 0; val_i < val_ndigits; val_i++)
12233 accum_digits[
i] += (
int32) val_digits[val_i];
12273 for (
i = ndigits - 1;
i >= 0;
i--)
12275 newdig = dig[
i] + carry;
12276 if (newdig >=
NBASE)
12278 carry = newdig /
NBASE;
12279 newdig -= carry *
NBASE;
12292 for (
i = ndigits - 1;
i >= 0;
i--)
12294 newdig = dig[
i] + carry;
12295 if (newdig >=
NBASE)
12297 carry = newdig /
NBASE;
12298 newdig -= carry *
NBASE;
12319 int old_weight = accum->
weight;
12320 int old_ndigits = accum->
ndigits;
12326 accum_weight = old_weight;
12327 accum_ndigits = old_ndigits;
12338 if (
val->weight >= accum_weight)
12340 accum_weight =
val->weight + 1;
12341 accum_ndigits = accum_ndigits + (accum_weight - old_weight);
12356 accum_rscale = accum_ndigits - accum_weight - 1;
12357 val_rscale =
val->ndigits -
val->weight - 1;
12358 if (val_rscale > accum_rscale)
12359 accum_ndigits = accum_ndigits + (val_rscale - accum_rscale);
12361 if (accum_ndigits != old_ndigits ||
12362 accum_weight != old_weight)
12364 int32 *new_pos_digits;
12365 int32 *new_neg_digits;
12368 weightdiff = accum_weight - old_weight;
12370 new_pos_digits =
palloc0(accum_ndigits *
sizeof(
int32));
12371 new_neg_digits =
palloc0(accum_ndigits *
sizeof(
int32));
12375 memcpy(&new_pos_digits[weightdiff], accum->
pos_digits,
12376 old_ndigits *
sizeof(
int32));
12379 memcpy(&new_neg_digits[weightdiff], accum->
neg_digits,
12380 old_ndigits *
sizeof(
int32));
12387 accum->
weight = accum_weight;
12388 accum->
ndigits = accum_ndigits;
12444 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 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
static void compute_bucket(Numeric operand, Numeric bound1, Numeric bound2, const NumericVar *count_var, NumericVar *result_var)
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)
static void mul_var_short(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
#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)
#define NUMERIC_WEIGHT_MAX
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)