79#define MUL_GUARD_DIGITS 4
80#define DIV_GUARD_DIGITS 8
89#define MUL_GUARD_DIGITS 3
90#define DIV_GUARD_DIGITS 6
97#define HALF_NBASE 5000
99#define MUL_GUARD_DIGITS 2
100#define DIV_GUARD_DIGITS 4
105#define NBASE_SQR (NBASE * NBASE)
167#define NUMERIC_SIGN_MASK 0xC000
168#define NUMERIC_POS 0x0000
169#define NUMERIC_NEG 0x4000
170#define NUMERIC_SHORT 0x8000
171#define NUMERIC_SPECIAL 0xC000
173#define NUMERIC_FLAGBITS(n) ((n)->choice.n_header & NUMERIC_SIGN_MASK)
174#define NUMERIC_IS_SHORT(n) (NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)
175#define NUMERIC_IS_SPECIAL(n) (NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)
177#define NUMERIC_HDRSZ (VARHDRSZ + sizeof(uint16) + sizeof(int16))
178#define NUMERIC_HDRSZ_SHORT (VARHDRSZ + sizeof(uint16))
185#define NUMERIC_HEADER_IS_SHORT(n) (((n)->choice.n_header & 0x8000) != 0)
186#define NUMERIC_HEADER_SIZE(n) \
187 (VARHDRSZ + sizeof(uint16) + \
188 (NUMERIC_HEADER_IS_SHORT(n) ? 0 : sizeof(int16)))
199#define NUMERIC_EXT_SIGN_MASK 0xF000
200#define NUMERIC_NAN 0xC000
201#define NUMERIC_PINF 0xD000
202#define NUMERIC_NINF 0xF000
203#define NUMERIC_INF_SIGN_MASK 0x2000
205#define NUMERIC_EXT_FLAGBITS(n) ((n)->choice.n_header & NUMERIC_EXT_SIGN_MASK)
206#define NUMERIC_IS_NAN(n) ((n)->choice.n_header == NUMERIC_NAN)
207#define NUMERIC_IS_PINF(n) ((n)->choice.n_header == NUMERIC_PINF)
208#define NUMERIC_IS_NINF(n) ((n)->choice.n_header == NUMERIC_NINF)
209#define NUMERIC_IS_INF(n) \
210 (((n)->choice.n_header & ~NUMERIC_INF_SIGN_MASK) == NUMERIC_PINF)
216#define NUMERIC_SHORT_SIGN_MASK 0x2000
217#define NUMERIC_SHORT_DSCALE_MASK 0x1F80
218#define NUMERIC_SHORT_DSCALE_SHIFT 7
219#define NUMERIC_SHORT_DSCALE_MAX \
220 (NUMERIC_SHORT_DSCALE_MASK >> NUMERIC_SHORT_DSCALE_SHIFT)
221#define NUMERIC_SHORT_WEIGHT_SIGN_MASK 0x0040
222#define NUMERIC_SHORT_WEIGHT_MASK 0x003F
223#define NUMERIC_SHORT_WEIGHT_MAX NUMERIC_SHORT_WEIGHT_MASK
224#define NUMERIC_SHORT_WEIGHT_MIN (-(NUMERIC_SHORT_WEIGHT_MASK+1))
236#define NUMERIC_DSCALE_MASK 0x3FFF
237#define NUMERIC_DSCALE_MAX NUMERIC_DSCALE_MASK
239#define NUMERIC_SIGN(n) \
240 (NUMERIC_IS_SHORT(n) ? \
241 (((n)->choice.n_short.n_header & NUMERIC_SHORT_SIGN_MASK) ? \
242 NUMERIC_NEG : NUMERIC_POS) : \
243 (NUMERIC_IS_SPECIAL(n) ? \
244 NUMERIC_EXT_FLAGBITS(n) : NUMERIC_FLAGBITS(n)))
245#define NUMERIC_DSCALE(n) (NUMERIC_HEADER_IS_SHORT((n)) ? \
246 ((n)->choice.n_short.n_header & NUMERIC_SHORT_DSCALE_MASK) \
247 >> NUMERIC_SHORT_DSCALE_SHIFT \
248 : ((n)->choice.n_long.n_sign_dscale & NUMERIC_DSCALE_MASK))
249#define NUMERIC_WEIGHT(n) (NUMERIC_HEADER_IS_SHORT((n)) ? \
250 (((n)->choice.n_short.n_header & NUMERIC_SHORT_WEIGHT_SIGN_MASK ? \
251 ~NUMERIC_SHORT_WEIGHT_MASK : 0) \
252 | ((n)->choice.n_short.n_header & NUMERIC_SHORT_WEIGHT_MASK)) \
253 : ((n)->choice.n_long.n_weight))
260#define NUMERIC_WEIGHT_MAX PG_INT16_MAX
404#define NUMERIC_ABBREV_BITS (SIZEOF_DATUM * BITS_PER_BYTE)
406#define NumericAbbrevGetDatum(X) ((Datum) (X))
407#define DatumGetNumericAbbrev(X) ((int64) (X))
408#define NUMERIC_ABBREV_NAN NumericAbbrevGetDatum(PG_INT64_MIN)
409#define NUMERIC_ABBREV_PINF NumericAbbrevGetDatum(-PG_INT64_MAX)
410#define NUMERIC_ABBREV_NINF NumericAbbrevGetDatum(PG_INT64_MAX)
412#define NumericAbbrevGetDatum(X) ((Datum) (X))
413#define DatumGetNumericAbbrev(X) ((int32) (X))
414#define NUMERIC_ABBREV_NAN NumericAbbrevGetDatum(PG_INT32_MIN)
415#define NUMERIC_ABBREV_PINF NumericAbbrevGetDatum(-PG_INT32_MAX)
416#define NUMERIC_ABBREV_NINF NumericAbbrevGetDatum(PG_INT32_MAX)
482#define dump_numeric(s,n)
486#define digitbuf_alloc(ndigits) \
487 ((NumericDigit *) palloc((ndigits) * sizeof(NumericDigit)))
488#define digitbuf_free(buf) \
494#define init_var(v) memset(v, 0, sizeof(NumericVar))
496#define NUMERIC_DIGITS(num) (NUMERIC_HEADER_IS_SHORT(num) ? \
497 (num)->choice.n_short.n_data : (num)->choice.n_long.n_data)
498#define NUMERIC_NDIGITS(num) \
499 ((VARSIZE(num) - NUMERIC_HEADER_SIZE(num)) / sizeof(NumericDigit))
500#define NUMERIC_CAN_BE_SHORT(scale,weight) \
501 ((scale) <= NUMERIC_SHORT_DSCALE_MAX && \
502 (weight) <= NUMERIC_SHORT_WEIGHT_MAX && \
503 (weight) >= NUMERIC_SHORT_WEIGHT_MIN)
513 const char *cp,
int sign,
538static bool numericvar_to_int128(
const NumericVar *var, int128 *result);
539static void int128_to_numericvar(int128
val,
NumericVar *var);
554 int var1weight,
int var1sign,
556 int var2weight,
int var2sign);
567 NumericVar *result,
int rscale,
bool round,
bool exact);
571static 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")));
1867 ((
Const *) arg1)->constisnull) ||
1869 ((
Const *) arg2)->constisnull) ||
1870 (arg3 != NULL &&
IsA(arg3,
Const) &&
1871 ((
Const *) arg3)->constisnull))
1878 (arg3 == NULL ||
IsA(arg3,
Const)))
1978 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1979 errmsg(
"count must be greater than zero")));
1989 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1990 errmsg(
"operand, lower bound, and upper bound cannot be NaN")));
1994 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1995 errmsg(
"lower and upper bounds must be finite")));
2008 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
2009 errmsg(
"lower bound cannot equal upper bound")));
2038 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
2039 errmsg(
"integer out of range")));
2074 sub_var(&operand_var, &bound1_var, &operand_var);
2075 sub_var(&bound2_var, &bound1_var, &bound2_var);
2077 mul_var(&operand_var, count_var, &operand_var,
2079 div_var(&operand_var, &bound2_var, result_var, 0,
false,
true);
2218 pfree(original_varatt);
2237 if (memtupcount < 10000 || nss->input_count < 10000 || !nss->estimating)
2248 if (abbr_card > 100000.0)
2252 "numeric_abbrev: estimation ends at cardinality %f"
2268 if (abbr_card < nss->input_count / 10000.0 + 0.5)
2272 "numeric_abbrev: aborting abbreviation at cardinality %f"
2273 " below threshold %f after " INT64_FORMAT " values (%d rows)",
2281 "numeric_abbrev: cardinality %f"
2380#if NUMERIC_ABBREV_BITS == 64
2386 int weight = var->
weight;
2389 if (ndigits == 0 || weight < -44)
2393 else if (weight > 83)
2399 result = ((
int64) (weight + 44) << 56);
2435#if NUMERIC_ABBREV_BITS == 32
2441 int weight = var->
weight;
2444 if (ndigits == 0 || weight < -11)
2448 else if (weight > 20)
2456 weight = (weight + 11) * 4;
2468 result = (result * 1000) + (nxt1 / 10);
2471 else if (result > 99)
2474 result = (result * 10000) + nxt1;
2477 else if (result > 9)
2482 result = (result * 100000) + (nxt1 * 10) + (nxt2 / 1000);
2490 result = (result * 1000000) + (nxt1 * 100) + (nxt2 / 100);
2493 result = result | (weight << 24);
2697 (
errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
2698 errmsg(
"invalid preceding or following size in window function")));
2795 sub_var(&basev, &offsetv, &sum);
2797 add_var(&basev, &offsetv, &sum);
2800 result = (
cmp_var(&valv, &sum) <= 0);
2802 result = (
cmp_var(&valv, &sum) >= 0);
2885 result = digit_hash ^ weight;
3027 add_var(&arg1, &arg2, &result);
3105 sub_var(&arg1, &arg2, &result);
3271 *have_error =
false;
3293 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3294 errmsg(
"division by zero")));
3316 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3317 errmsg(
"division by zero")));
3352 if (have_error && (arg2.
ndigits == 0 || arg2.
digits[0] == 0))
3361 div_var(&arg1, &arg2, &result, rscale,
true,
true);
3401 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3402 errmsg(
"division by zero")));
3419 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3420 errmsg(
"division by zero")));
3450 div_var(&arg1, &arg2, &result, 0,
false,
true);
3494 *have_error =
false;
3515 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3516 errmsg(
"division by zero")));
3533 if (have_error && (arg2.
ndigits == 0 || arg2.
digits[0] == 0))
3539 mod_var(&arg1, &arg2, &result);
3666 gcd_var(&arg1, &arg2, &result);
3720 gcd_var(&arg1, &arg2, &result);
3721 div_var(&arg1, &result, &result, 0,
false,
true);
3751 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
3752 errmsg(
"factorial of a negative number is undefined")));
3761 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
3762 errmsg(
"value overflows numeric format")));
3769 for (num = num - 1; num > 1; num--)
3776 mul_var(&result, &fact, &result, 0);
3811 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
3812 errmsg(
"cannot take square root of a negative number")));
3833#if DEC_DIGITS == ((DEC_DIGITS / 2) * 2)
3836 if (
arg.weight >= 0)
3843 rscale =
Max(rscale,
arg.dscale);
3903 val *= 0.434294481903252;
3910 rscale =
Max(rscale,
arg.dscale);
3949 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
3950 errmsg(
"cannot take logarithm of a negative number")));
3962 rscale =
Max(rscale,
arg.dscale);
4004 if (sign1 < 0 || sign2 < 0)
4006 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
4007 errmsg(
"cannot take logarithm of a negative number")));
4009 if (sign1 == 0 || sign2 == 0)
4011 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
4012 errmsg(
"cannot take logarithm of zero")));
4037 log_var(&arg1, &arg2, &result);
4097 if (sign1 == 0 && sign2 < 0)
4099 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
4100 errmsg(
"zero raised to a negative power is undefined")));
4103 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
4104 errmsg(
"a negative number raised to a non-integer power yields a complex result")));
4130 if (sign1 == 0 && sign2 > 0)
4149 abs_x_gt_one =
true;
4158 if (abs_x_gt_one == (sign2 > 0))
4209 if (sign1 == 0 && sign2 < 0)
4211 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
4212 errmsg(
"zero raised to a negative power is undefined")));
4264 last_digit_pos = var->
ndigits - 1;
4265 while (last_digit_pos >= 0 &&
4266 var->
digits[last_digit_pos] == 0)
4269 if (last_digit_pos >= 0)
4286 while (last_digit % 10 == 0)
4358 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4359 errmsg(
"lower bound cannot be NaN"));
4362 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4363 errmsg(
"lower bound cannot be infinity"));
4369 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4370 errmsg(
"upper bound cannot be NaN"));
4373 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4374 errmsg(
"upper bound cannot be infinity"));
4433 rscale = log10val2 < 0 ? 0 : log10val2;
4453 static const int pow10[] = {1, 10, 100, 1000};
4454#elif DEC_DIGITS == 2
4455 static const int pow10[] = {1, 10};
4456#elif DEC_DIGITS == 1
4457 static const int pow10[] = {1};
4459#error unsupported NBASE
4472 tmp = (int128) val1 * (int128) factor;
4474 int128_to_numericvar(tmp, &result);
4483 mul_var(&result, &tmp, &result, 0);
4521 *have_error =
false;
4534 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4535 errmsg(
"cannot convert NaN to %s",
"integer")));
4538 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4539 errmsg(
"cannot convert infinity to %s",
"integer")));
4556 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4557 errmsg(
"integer out of range")));
4609 *have_error =
false;
4622 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4623 errmsg(
"cannot convert NaN to %s",
"bigint")));
4626 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4627 errmsg(
"cannot convert infinity to %s",
"bigint")));
4644 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4645 errmsg(
"bigint out of range")));
4682 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4683 errmsg(
"cannot convert NaN to %s",
"smallint")));
4686 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4687 errmsg(
"cannot convert infinity to %s",
"smallint")));
4695 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4696 errmsg(
"smallint out of range")));
4700 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4701 errmsg(
"smallint out of range")));
4716 char buf[DBL_DIG + 100];
4810 char buf[FLT_DIG + 100];
4878 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4879 errmsg(
"cannot convert NaN to %s",
"pg_lsn")));
4882 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4883 errmsg(
"cannot convert infinity to %s",
"pg_lsn")));
4891 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4892 errmsg(
"pg_lsn out of range")));
4927#define NA_TOTAL_COUNT(na) \
4928 ((na)->N + (na)->NaNcount + (na)->pInfcount + (na)->nInfcount)
4942 elog(
ERROR,
"aggregate function called in non-aggregate context");
4947 state->calcSumX2 = calcSumX2;
4948 state->agg_context = agg_context;
4965 state->calcSumX2 = calcSumX2;
5003 state->maxScaleCount = 1;
5006 state->maxScaleCount++;
5009 if (
state->calcSumX2)
5023 if (
state->calcSumX2)
5075 if (
state->maxScaleCount > 1 ||
state->maxScale == 0)
5081 state->maxScaleCount--;
5083 else if (
state->N == 1)
5086 state->maxScale = 0;
5087 state->maxScaleCount = 0;
5097 if (
state->calcSumX2)
5112 if (
state->calcSumX2)
5125 if (
state->calcSumX2)
5166 elog(
ERROR,
"aggregate function called in non-aggregate context");
5180 state1->
N = state2->
N;
5195 state1->
N += state2->
N;
5258 elog(
ERROR,
"aggregate function called in non-aggregate context");
5272 state1->
N = state2->
N;
5286 state1->
N += state2->
N;
5331 elog(
ERROR,
"aggregate function called in non-aggregate context");
5382 elog(
ERROR,
"aggregate function called in non-aggregate context");
5441 elog(
ERROR,
"aggregate function called in non-aggregate context");
5496 elog(
ERROR,
"aggregate function called in non-aggregate context");
5557 elog(
ERROR,
"numeric_accum_inv called with NULL state");
5585typedef struct Int128AggState
5597static Int128AggState *
5600 Int128AggState *
state;
5605 elog(
ERROR,
"aggregate function called in non-aggregate context");
5609 state = (Int128AggState *)
palloc0(
sizeof(Int128AggState));
5610 state->calcSumX2 = calcSumX2;
5621static Int128AggState *
5622makeInt128AggStateCurrentContext(
bool calcSumX2)
5624 Int128AggState *
state;
5626 state = (Int128AggState *)
palloc0(
sizeof(Int128AggState));
5627 state->calcSumX2 = calcSumX2;
5636do_int128_accum(Int128AggState *
state, int128
newval)
5638 if (
state->calcSumX2)
5649do_int128_discard(Int128AggState *
state, int128
newval)
5651 if (
state->calcSumX2)
5659#define makePolyNumAggState makeInt128AggState
5660#define makePolyNumAggStateCurrentContext makeInt128AggStateCurrentContext
5663#define makePolyNumAggState makeNumericAggState
5664#define makePolyNumAggStateCurrentContext makeNumericAggStateCurrentContext
5742 elog(
ERROR,
"aggregate function called in non-aggregate context");
5756 state1->
N = state2->
N;
5773 state1->
N += state2->
N;
5808 elog(
ERROR,
"aggregate function called in non-aggregate context");
5830 int128_to_numericvar(
state->sumX, &tmp_var);
5838 int128_to_numericvar(
state->sumX2, &tmp_var);
5865 elog(
ERROR,
"aggregate function called in non-aggregate context");
5886 numericvar_to_int128(&tmp_var, &result->
sumX);
5894 numericvar_to_int128(&tmp_var, &result->
sumX2);
5945 elog(
ERROR,
"aggregate function called in non-aggregate context");
5959 state1->
N = state2->
N;
5973 state1->
N += state2->
N;
6006 elog(
ERROR,
"aggregate function called in non-aggregate context");
6028 int128_to_numericvar(
state->sumX, &tmp_var);
6054 elog(
ERROR,
"aggregate function called in non-aggregate context");
6075 numericvar_to_int128(&tmp_var, &result->
sumX);
6100 elog(
ERROR,
"int2_accum_inv called with NULL state");
6109 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6125 elog(
ERROR,
"int4_accum_inv called with NULL state");
6134 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6150 elog(
ERROR,
"int8_accum_inv called with NULL state");
6156 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6171 elog(
ERROR,
"int8_avg_accum_inv called with NULL state");
6180 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6203 int128_to_numericvar(
state->sumX, &result);
6232 int128_to_numericvar(
state->sumX, &result);
6259 if (
state->NaNcount > 0)
6263 if (
state->pInfcount > 0 &&
state->nInfcount > 0)
6265 if (
state->pInfcount > 0)
6267 if (
state->nInfcount > 0)
6293 if (
state->NaNcount > 0)
6297 if (
state->pInfcount > 0 &&
state->nInfcount > 0)
6299 if (
state->pInfcount > 0)
6301 if (
state->nInfcount > 0)
6325 bool variance,
bool sample,
6347 if (sample && totCount <= 1)
6359 if (
state->NaNcount > 0 ||
state->pInfcount > 0 ||
state->nInfcount > 0)
6375 rscale = vsumX.
dscale * 2;
6377 mul_var(&vsumX, &vsumX, &vsumX, rscale);
6378 mul_var(&vN, &vsumX2, &vsumX2, rscale);
6379 sub_var(&vsumX2, &vsumX, &vsumX2);
6389 mul_var(&vN, &vNminus1, &vNminus1, 0);
6391 mul_var(&vN, &vN, &vNminus1, 0);
6393 div_var(&vsumX2, &vNminus1, &vsumX, rscale,
true,
true);
6477numeric_poly_stddev_internal(Int128AggState *
state,
6478 bool variance,
bool sample,
6495 int128_to_numericvar(
state->sumX, &tmp_var);
6498 int128_to_numericvar(
state->sumX2, &tmp_var);
6531 res = numeric_poly_stddev_internal(
state,
true,
true, &is_null);
6552 res = numeric_poly_stddev_internal(
state,
false,
true, &is_null);
6573 res = numeric_poly_stddev_internal(
state,
true,
false, &is_null);
6594 res = numeric_poly_stddev_internal(
state,
false,
false, &is_null);
6647#ifndef USE_FLOAT8_BYVAL
6696#ifndef USE_FLOAT8_BYVAL
6793 elog(
ERROR,
"expected 2-element int8 array");
6821 elog(
ERROR,
"expected 2-element int8 array");
6839 elog(
ERROR,
"aggregate function called in non-aggregate context");
6846 elog(
ERROR,
"expected 2-element int8 array");
6850 elog(
ERROR,
"expected 2-element int8 array");
6856 state1->
sum += state2->
sum;
6880 elog(
ERROR,
"expected 2-element int8 array");
6908 elog(
ERROR,
"expected 2-element int8 array");
6927 elog(
ERROR,
"expected 2-element int8 array");
6931 if (transdata->
count == 0)
6952 elog(
ERROR,
"expected 2-element int8 array");
6956 if (transdata->
count == 0)
7008 for (
i = 0;
i < ndigits;
i++)
7134 bool have_dp =
false;
7136 unsigned char *decdigits;
7169 if (!isdigit((
unsigned char) *cp))
7170 goto invalid_syntax;
7180 if (isdigit((
unsigned char) *cp))
7182 decdigits[
i++] = *cp++ -
'0';
7188 else if (*cp ==
'.')
7191 goto invalid_syntax;
7196 goto invalid_syntax;
7198 else if (*cp ==
'_')
7202 if (!isdigit((
unsigned char) *cp))
7203 goto invalid_syntax;
7214 if (*cp ==
'e' || *cp ==
'E')
7232 else if (*cp ==
'-')
7239 if (!isdigit((
unsigned char) *cp))
7240 goto invalid_syntax;
7244 if (isdigit((
unsigned char) *cp))
7246 exponent = exponent * 10 + (*cp++ -
'0');
7250 else if (*cp ==
'_')
7254 if (!isdigit((
unsigned char) *cp))
7255 goto invalid_syntax;
7262 exponent = -exponent;
7264 dweight += (int) exponent;
7265 dscale -= (int) exponent;
7280 offset = (weight + 1) *
DEC_DIGITS - (dweight + 1);
7285 dest->weight = weight;
7286 dest->dscale = dscale;
7291 while (ndigits-- > 0)
7294 *
digits++ = ((decdigits[
i] * 10 + decdigits[
i + 1]) * 10 +
7295 decdigits[
i + 2]) * 10 + decdigits[
i + 3];
7296#elif DEC_DIGITS == 2
7297 *
digits++ = decdigits[
i] * 10 + decdigits[
i + 1];
7298#elif DEC_DIGITS == 1
7301#error unsupported NBASE
7318 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7319 errmsg(
"value overflows numeric format")));
7323 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
7324 errmsg(
"invalid input syntax for type %s: \"%s\"",
7335 return dig >=
'0' && dig <=
'9' ? dig -
'0' :
7336 dig >=
'a' && dig <=
'f' ? dig -
'a' + 10 :
7337 dig >=
'A' && dig <=
'F' ? dig -
'A' + 10 : -1;
7362 const char **endptr,
Node *escontext)
7364 const char *firstdigit = cp;
7386 if (isxdigit((
unsigned char) *cp))
7408 else if (*cp ==
'_')
7412 if (!isxdigit((
unsigned char) *cp))
7413 goto invalid_syntax;
7423 if (*cp >=
'0' && *cp <=
'7')
7442 tmp = tmp * 8 + (*cp++ -
'0');
7445 else if (*cp ==
'_')
7449 if (*cp < '0' || *cp >
'7')
7450 goto invalid_syntax;
7460 if (*cp >=
'0' && *cp <=
'1')
7479 tmp = tmp * 2 + (*cp++ -
'0');
7482 else if (*cp ==
'_')
7486 if (*cp < '0' || *cp >
'1')
7487 goto invalid_syntax;
7495 goto invalid_syntax;
7499 goto invalid_syntax;
7521 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7522 errmsg(
"value overflows numeric format")));
7526 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
7527 errmsg(
"invalid input syntax for type %s: \"%s\"",
7592 if (
value->ndigits > 0)
7593 memcpy(newbuf + 1,
value->digits,
7600 dest->digits = newbuf + 1;
7659 for (d = 0; d <= var->
weight; d++)
7665 bool putit = (d > 0);
7684#elif DEC_DIGITS == 2
7687 if (d1 > 0 || d > 0)
7690#elif DEC_DIGITS == 1
7693#error unsupported NBASE
7706 endcp = cp + dscale;
7811 div_var(var, &tmp_var, &tmp_var, rscale,
true,
true);
7823 len = strlen(sig_out) + 13;
7870 for (
i = 0;
i <
len;
i++)
7904 int weight = var->
weight;
7910 *have_error =
false;
7937 while (n > 0 && *
digits == 0)
7944 while (n > 0 &&
digits[n - 1] == 0)
7960 result->choice.n_short.n_header =
7972 result->choice.n_long.n_sign_dscale =
7974 result->choice.n_long.n_weight = weight;
7993 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7994 errmsg(
"value overflows numeric format")));
8071 else if (dig < 1000)
8073#elif DEC_DIGITS == 2
8076#elif DEC_DIGITS == 1
8079#error unsupported NBASE
8083 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
8084 errmsg(
"numeric field overflow"),
8085 errdetail(
"A field with precision %d, scale %d must round to an absolute value less than %s%d.",
8134 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
8135 errmsg(
"numeric field overflow"),
8136 errdetail(
"A field with precision %d, scale %d cannot hold an infinite value.",
8137 precision,
scale)));
8177 Assert(weight >= 0 && ndigits <= weight + 1);
8187 for (
i = 1;
i <= weight;
i++)
8254 newuval = uval /
NBASE;
8255 *ptr = uval - newuval *
NBASE;
8260 var->
weight = ndigits - 1;
8305 Assert(weight >= 0 && ndigits <= weight + 1);
8310 for (
i = 1;
i <= weight;
i++)
8342numericvar_to_int128(
const NumericVar *var, int128 *result)
8373 Assert(weight >= 0 && ndigits <= weight + 1);
8379 for (
i = 1;
i <= weight;
i++)
8395 if (!neg || (-
val) !=
val ||
val == 0 || oldval < 0)
8405 *result = neg ? -
val :
val;
8445 newuval = uval /
NBASE;
8446 *ptr = uval - newuval *
NBASE;
8451 var->
weight = ndigits - 1;
8468 val = strtod(tmp, &endptr);
8469 if (*endptr !=
'\0')
8473 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
8474 errmsg(
"invalid input syntax for type %s: \"%s\"",
8475 "double precision", tmp)));
8507 int var1weight,
int var1sign,
8509 int var2weight,
int var2sign)
8511 if (var1ndigits == 0)
8513 if (var2ndigits == 0)
8519 if (var2ndigits == 0)
8531 var2digits, var2ndigits, var2weight);
8538 var1digits, var1ndigits, var1weight);
8791 int res_ndigitpairs;
8804 int var1ndigitpairs;
8805 int var2ndigitpairs;
8834 var1digits = var1->
digits;
8835 var2digits = var2->
digits;
8837 if (var1ndigits == 0)
8849 if (var1ndigits <= 6 && rscale == var1->dscale + var2->
dscale)
8885 var1ndigitpairs = (var1ndigits + 1) / 2;
8886 var2ndigitpairs = (var2ndigits + 1) / 2;
8889 res_ndigits = var1ndigits + var2ndigits;
8892 res_ndigitpairs = res_ndigits / 2 + 1;
8895 pair_offset = res_ndigitpairs - var1ndigitpairs - var2ndigitpairs + 1;
8898 res_weight = var1->
weight + var2->
weight + 1 + 2 * res_ndigitpairs -
8899 res_ndigits - (var1ndigits & 1) - (var2ndigits & 1);
8906 res_ndigitpairs =
Min(res_ndigitpairs, maxdigitpairs);
8907 res_ndigits = 2 * res_ndigitpairs;
8915 if (res_ndigitpairs <= pair_offset)
8922 var1ndigitpairs =
Min(var1ndigitpairs, res_ndigitpairs - pair_offset);
8923 var2ndigitpairs =
Min(var2ndigitpairs, res_ndigitpairs - pair_offset);
8949 var2ndigitpairs *
sizeof(
uint32));
8952 var2digitpairs = (
uint32 *) (dig + res_ndigitpairs);
8954 for (i2 = 0; i2 < var2ndigitpairs - 1; i2++)
8955 var2digitpairs[i2] = var2digits[2 * i2] *
NBASE + var2digits[2 * i2 + 1];
8957 if (2 * i2 + 1 < var2ndigits)
8958 var2digitpairs[i2] = var2digits[2 * i2] *
NBASE + var2digits[2 * i2 + 1];
8960 var2digitpairs[i2] = var2digits[2 * i2] *
NBASE;
8975 i1 = var1ndigitpairs - 1;
8976 if (2 * i1 + 1 < var1ndigits)
8977 var1digitpair = var1digits[2 * i1] *
NBASE + var1digits[2 * i1 + 1];
8979 var1digitpair = var1digits[2 * i1] *
NBASE;
8980 maxdig = var1digitpair;
8982 i2limit =
Min(var2ndigitpairs, res_ndigitpairs - i1 - pair_offset);
8983 dig_i1_off = &dig[i1 + pair_offset];
8985 memset(dig, 0, (i1 + pair_offset) *
sizeof(
uint64));
8986 for (i2 = 0; i2 < i2limit; i2++)
8987 dig_i1_off[i2] = (
uint64) var1digitpair * var2digitpairs[i2];
8994 for (i1 = i1 - 1; i1 >= 0; i1--)
8996 var1digitpair = var1digits[2 * i1] *
NBASE + var1digits[2 * i1 + 1];
8997 if (var1digitpair == 0)
9001 maxdig += var1digitpair;
9006 for (
i = res_ndigitpairs - 1;
i >= 0;
i--)
9008 newdig = dig[
i] + carry;
9020 maxdig = 1 + var1digitpair;
9024 i2limit =
Min(var2ndigitpairs, res_ndigitpairs - i1 - pair_offset);
9025 dig_i1_off = &dig[i1 + pair_offset];
9027 for (i2 = 0; i2 < i2limit; i2++)
9028 dig_i1_off[i2] += (
uint64) var1digitpair * var2digitpairs[i2];
9037 res_digits = result->
digits;
9039 for (
i = res_ndigitpairs - 1;
i >= 0;
i--)
9041 newdig = dig[
i] + carry;
9059 result->
weight = res_weight;
9060 result->
sign = res_sign;
9081 int var1ndigits = var1->
ndigits;
9082 int var2ndigits = var2->
ndigits;
9094 Assert(var1ndigits >= 1);
9095 Assert(var1ndigits <= 6);
9096 Assert(var2ndigits >= var1ndigits);
9110 res_ndigits = var1ndigits + var2ndigits;
9115 res_digits = res_buf + 1;
9122#define PRODSUM1(v1,i1,v2,i2) ((v1)[(i1)] * (v2)[(i2)])
9123#define PRODSUM2(v1,i1,v2,i2) (PRODSUM1(v1,i1,v2,i2) + (v1)[(i1)+1] * (v2)[(i2)-1])
9124#define PRODSUM3(v1,i1,v2,i2) (PRODSUM2(v1,i1,v2,i2) + (v1)[(i1)+2] * (v2)[(i2)-2])
9125#define PRODSUM4(v1,i1,v2,i2) (PRODSUM3(v1,i1,v2,i2) + (v1)[(i1)+3] * (v2)[(i2)-3])
9126#define PRODSUM5(v1,i1,v2,i2) (PRODSUM4(v1,i1,v2,i2) + (v1)[(i1)+4] * (v2)[(i2)-4])
9127#define PRODSUM6(v1,i1,v2,i2) (PRODSUM5(v1,i1,v2,i2) + (v1)[(i1)+5] * (v2)[(i2)-5])
9129 switch (var1ndigits)
9139 for (
int i = var2ndigits - 1;
i >= 0;
i--)
9141 term =
PRODSUM1(var1digits, 0, var2digits,
i) + carry;
9143 carry = term /
NBASE;
9157 term =
PRODSUM1(var1digits, 1, var2digits, var2ndigits - 1);
9159 carry = term /
NBASE;
9162 for (
int i = var2ndigits - 1;
i >= 1;
i--)
9164 term =
PRODSUM2(var1digits, 0, var2digits,
i) + carry;
9166 carry = term /
NBASE;
9179 term =
PRODSUM1(var1digits, 2, var2digits, var2ndigits - 1);
9181 carry = term /
NBASE;
9183 term =
PRODSUM2(var1digits, 1, var2digits, var2ndigits - 1) + carry;
9185 carry = term /
NBASE;
9188 for (
int i = var2ndigits - 1;
i >= 2;
i--)
9190 term =
PRODSUM3(var1digits, 0, var2digits,
i) + carry;
9192 carry = term /
NBASE;
9205 term =
PRODSUM1(var1digits, 3, var2digits, var2ndigits - 1);
9207 carry = term /
NBASE;
9209 term =
PRODSUM2(var1digits, 2, var2digits, var2ndigits - 1) + carry;
9211 carry = term /
NBASE;
9213 term =
PRODSUM3(var1digits, 1, var2digits, var2ndigits - 1) + carry;
9215 carry = term /
NBASE;
9218 for (
int i = var2ndigits - 1;
i >= 3;
i--)
9220 term =
PRODSUM4(var1digits, 0, var2digits,
i) + carry;
9222 carry = term /
NBASE;
9235 term =
PRODSUM1(var1digits, 4, var2digits, var2ndigits - 1);
9237 carry = term /
NBASE;
9239 term =
PRODSUM2(var1digits, 3, var2digits, var2ndigits - 1) + carry;
9241 carry = term /
NBASE;
9243 term =
PRODSUM3(var1digits, 2, var2digits, var2ndigits - 1) + carry;
9245 carry = term /
NBASE;
9247 term =
PRODSUM4(var1digits, 1, var2digits, var2ndigits - 1) + carry;
9249 carry = term /
NBASE;
9252 for (
int i = var2ndigits - 1;
i >= 4;
i--)
9254 term =
PRODSUM5(var1digits, 0, var2digits,
i) + carry;
9256 carry = term /
NBASE;
9269 term =
PRODSUM1(var1digits, 5, var2digits, var2ndigits - 1);
9271 carry = term /
NBASE;
9273 term =
PRODSUM2(var1digits, 4, var2digits, var2ndigits - 1) + carry;
9275 carry = term /
NBASE;
9277 term =
PRODSUM3(var1digits, 3, var2digits, var2ndigits - 1) + carry;
9279 carry = term /
NBASE;
9281 term =
PRODSUM4(var1digits, 2, var2digits, var2ndigits - 1) + carry;
9283 carry = term /
NBASE;
9285 term =
PRODSUM5(var1digits, 1, var2digits, var2ndigits - 1) + carry;
9287 carry = term /
NBASE;
9290 for (
int i = var2ndigits - 1;
i >= 5;
i--)
9292 term =
PRODSUM6(var1digits, 0, var2digits,
i) + carry;
9294 carry = term /
NBASE;
9303 switch (var1ndigits)
9306 term =
PRODSUM5(var1digits, 0, var2digits, 4) + carry;
9308 carry = term /
NBASE;
9311 term =
PRODSUM4(var1digits, 0, var2digits, 3) + carry;
9313 carry = term /
NBASE;
9316 term =
PRODSUM3(var1digits, 0, var2digits, 2) + carry;
9318 carry = term /
NBASE;
9321 term =
PRODSUM2(var1digits, 0, var2digits, 1) + carry;
9323 carry = term /
NBASE;
9326 term =
PRODSUM1(var1digits, 0, var2digits, 0) + carry;
9334 result->
ndigits = res_ndigits;
9335 result->
buf = res_buf;
9336 result->
digits = res_digits;
9337 result->
weight = res_weight;
9338 result->
sign = res_sign;
9366 int rscale,
bool round,
bool exact)
9368 int var1ndigits = var1->
ndigits;
9369 int var2ndigits = var2->
ndigits;
9373 int var1ndigitpairs;
9374 int var2ndigitpairs;
9375 int res_ndigitpairs;
9376 int div_ndigitpairs;
9396 if (var2ndigits == 0 || var2->
digits[0] == 0)
9398 (
errcode(ERRCODE_DIVISION_BY_ZERO),
9399 errmsg(
"division by zero")));
9408 if (var2ndigits <= 2)
9411 int idivisor_weight;
9413 idivisor = var2->
digits[0];
9414 idivisor_weight = var2->
weight;
9415 if (var2ndigits == 2)
9421 idivisor = -idivisor;
9423 div_var_int(var1, idivisor, idivisor_weight, result, rscale, round);
9427 if (var2ndigits <= 4)
9430 int idivisor_weight;
9432 idivisor = var2->
digits[0];
9433 idivisor_weight = var2->
weight;
9434 for (
i = 1;
i < var2ndigits;
i++)
9440 idivisor = -idivisor;
9442 div_var_int64(var1, idivisor, idivisor_weight, result, rscale, round);
9452 if (var1ndigits == 0)
9488 res_ndigits =
Max(res_ndigits, 1);
9503 var1ndigitpairs = (var1ndigits + 1) / 2;
9504 var2ndigitpairs = (var2ndigits + 1) / 2;
9505 res_ndigitpairs = (res_ndigits + 1) / 2;
9506 res_ndigits = 2 * res_ndigitpairs;
9523 div_ndigitpairs = res_ndigitpairs + var2ndigitpairs;
9524 var1ndigitpairs =
Min(var1ndigitpairs, div_ndigitpairs);
9528 div_ndigitpairs = res_ndigitpairs;
9529 var1ndigitpairs =
Min(var1ndigitpairs, div_ndigitpairs);
9530 var2ndigitpairs =
Min(var2ndigitpairs, div_ndigitpairs);
9542 var2ndigitpairs *
sizeof(
int32));
9543 divisor = (
int32 *) (dividend + div_ndigitpairs + 1);
9546 for (
i = 0;
i < var1ndigitpairs - 1;
i++)
9549 if (2 *
i + 1 < var1ndigits)
9554 memset(dividend +
i + 1, 0, (div_ndigitpairs -
i) *
sizeof(
int64));
9557 for (
i = 0;
i < var2ndigitpairs - 1;
i++)
9560 if (2 *
i + 1 < var2ndigits)
9578 fdivisor = (double) divisor[0] *
NBASE_SQR;
9579 if (var2ndigitpairs > 1)
9580 fdivisor += (double) divisor[1];
9581 fdivisorinverse = 1.0 / fdivisor;
9608 for (qi = 0; qi < res_ndigitpairs; qi++)
9611 fdividend = (double) dividend[qi] *
NBASE_SQR;
9612 fdividend += (double) dividend[qi + 1];
9615 fquotient = fdividend * fdivisorinverse;
9616 qdigit = (fquotient >= 0.0) ? ((
int32) fquotient) :
9617 (((
int32) fquotient) - 1);
9622 maxdiv += i64abs(qdigit);
9633 for (
i =
Min(qi + var2ndigitpairs - 2, div_ndigitpairs - 1);
i > qi;
i--)
9635 newdig = dividend[
i] + carry;
9638 carry = -((-newdig - 1) /
NBASE_SQR) - 1;
9648 dividend[
i] = newdig;
9650 dividend[qi] += carry;
9664 fdividend = (double) dividend[qi] *
NBASE_SQR;
9665 fdividend += (double) dividend[qi + 1];
9666 fquotient = fdividend * fdivisorinverse;
9667 qdigit = (fquotient >= 0.0) ? ((
int32) fquotient) :
9668 (((
int32) fquotient) - 1);
9670 maxdiv += i64abs(qdigit);
9690 int istop =
Min(var2ndigitpairs, div_ndigitpairs - qi);
9691 int64 *dividend_qi = ÷nd[qi];
9693 for (
i = 0;
i < istop;
i++)
9694 dividend_qi[
i] -= (
int64) qdigit * divisor[
i];
9723 dividend[qi + 1] += dividend[qi] *
NBASE_SQR;
9725 dividend[qi] = qdigit;
9745 for (
i = var2ndigitpairs - 2;
i >= 0;
i--)
9750 carry = -((-newdig - 1) /
NBASE_SQR) - 1;
9778 for (
i = var2ndigitpairs - 1;
i > 0;
i--)
9812 for (
i = 0;
i < var2ndigitpairs;
i++)
9827 for (
i = var2ndigitpairs - 1;
i > 0;
i--)
9858 res_digits = result->
digits;
9860 for (
i = res_ndigitpairs - 1;
i >= 0;
i--)
9862 newdig = dividend[
i] + carry;
9865 carry = -((-newdig - 1) /
NBASE_SQR) - 1;
9885 result->
weight = res_weight;
9886 result->
sign = res_sign;
9910 int var_ndigits = var->
ndigits;
9922 errcode(ERRCODE_DIVISION_BY_ZERO),
9923 errmsg(
"division by zero"));
9926 if (var_ndigits == 0)
9942 res_weight = var->
weight - ival_weight;
9946 res_ndigits =
Max(res_ndigits, 1);
9953 res_digits = res_buf + 1;
9965 divisor = abs(ival);
9967 if (divisor <= UINT_MAX /
NBASE)
9972 for (
i = 0;
i < res_ndigits;
i++)
9974 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9976 carry = carry % divisor;
9984 for (
i = 0;
i < res_ndigits;
i++)
9986 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9988 carry = carry % divisor;
9994 result->
ndigits = res_ndigits;
9995 result->
buf = res_buf;
9996 result->
digits = res_digits;
9997 result->
weight = res_weight;
9998 result->
sign = res_sign;
10026 int var_ndigits = var->
ndigits;
10038 errcode(ERRCODE_DIVISION_BY_ZERO),
10039 errmsg(
"division by zero"));
10042 if (var_ndigits == 0)
10045 result->
dscale = rscale;
10058 res_weight = var->
weight - ival_weight;
10062 res_ndigits =
Max(res_ndigits, 1);
10069 res_digits = res_buf + 1;
10081 divisor = i64abs(ival);
10088 for (
i = 0;
i < res_ndigits;
i++)
10090 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
10092 carry = carry % divisor;
10100 for (
i = 0;
i < res_ndigits;
i++)
10102 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
10104 carry = carry % divisor;
10110 result->
ndigits = res_ndigits;
10111 result->
buf = res_buf;
10112 result->
digits = res_digits;
10113 result->
weight = res_weight;
10114 result->
sign = res_sign;
10158 firstdigit1 = var1->
digits[
i];
10159 if (firstdigit1 != 0)
10170 firstdigit2 = var2->
digits[
i];
10171 if (firstdigit2 != 0)
10182 qweight = weight1 - weight2;
10183 if (firstdigit1 <= firstdigit2)
10215 div_var(var1, var2, &tmp, 0,
false,
true);
10246 div_var(var1, var2, &q, 0,
false,
false);
10272 while (
cmp_abs(&r, var2) >= 0)
10381 result->
dscale = res_dscale;
10397 mod_var(&tmp_arg, result, &mod);
10404 result->
dscale = res_dscale;
10443 result->
dscale = rscale;
10453 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
10454 errmsg(
"cannot take square root of a negative number")));
10467 if (
arg->weight >= 0)
10468 res_weight =
arg->weight / 2;
10470 res_weight = -((-
arg->weight - 1) / 2 + 1);
10478 if (rscale + 1 >= 0)
10481 res_ndigits = res_weight + 1 - (-rscale - 1) /
DEC_DIGITS;
10482 res_ndigits =
Max(res_ndigits, 1);
10490 src_ndigits =
arg->weight + 1 + (res_ndigits - res_weight - 1) * 2;
10491 src_ndigits =
Max(src_ndigits, 1);
10561 while ((ndigits[step] = src_ndigits) > 4)
10564 blen = src_ndigits / 4;
10565 if (blen * 4 == src_ndigits &&
arg->digits[0] <
NBASE / 4)
10569 src_ndigits -= 2 * blen;
10581 arg_int64 =
arg->digits[0];
10582 for (src_idx = 1; src_idx < src_ndigits; src_idx++)
10584 arg_int64 *=
NBASE;
10585 if (src_idx < arg->ndigits)
10586 arg_int64 +=
arg->digits[src_idx];
10589 s_int64 = (
int64) sqrt((
double) arg_int64);
10590 r_int64 = arg_int64 - s_int64 * s_int64;
10602 while (r_int64 < 0 || r_int64 > 2 * s_int64)
10604 s_int64 = (s_int64 + arg_int64 / s_int64) / 2;
10605 r_int64 = arg_int64 - s_int64 * s_int64;
10628 while (step >= 0 && (src_ndigits = ndigits[step]) <= 8)
10639 blen = (src_ndigits - src_idx) / 2;
10646 for (
i = 0;
i < blen;
i++, src_idx++)
10650 if (src_idx < arg->ndigits)
10651 a1 +=
arg->digits[src_idx];
10654 for (
i = 0;
i < blen;
i++, src_idx++)
10657 if (src_idx < arg->ndigits)
10658 a0 +=
arg->digits[src_idx];
10662 numer = r_int64 *
b +
a1;
10663 denom = 2 * s_int64;
10665 u = numer - q * denom;
10668 s_int64 = s_int64 *
b + q;
10669 r_int64 = u *
b + a0 - q * q;
10674 r_int64 += s_int64;
10676 r_int64 += s_int64;
10679 Assert(src_idx == src_ndigits);
10693 s_int128 = s_int64;
10694 r_int128 = r_int64;
10702 while (step >= 0 && (src_ndigits = ndigits[step]) <= 16)
10713 blen = (src_ndigits - src_idx) / 2;
10720 for (
i = 0;
i < blen;
i++, src_idx++)
10724 if (src_idx < arg->ndigits)
10725 a1 +=
arg->digits[src_idx];
10728 for (
i = 0;
i < blen;
i++, src_idx++)
10731 if (src_idx < arg->ndigits)
10732 a0 +=
arg->digits[src_idx];
10736 numer = r_int128 *
b +
a1;
10737 denom = 2 * s_int128;
10739 u = numer - q * denom;
10742 s_int128 = s_int128 *
b + q;
10743 r_int128 = u *
b + a0 - q * q;
10748 r_int128 += s_int128;
10750 r_int128 += s_int128;
10753 Assert(src_idx == src_ndigits);
10763 int128_to_numericvar(s_int128, &s_var);
10765 int128_to_numericvar(r_int128, &r_var);
10786 src_ndigits = ndigits[step];
10787 blen = (src_ndigits - src_idx) / 2;
10790 if (src_idx < arg->ndigits)
10792 tmp_len =
Min(blen,
arg->ndigits - src_idx);
10794 memcpy(a1_var.
digits,
arg->digits + src_idx,
10796 a1_var.
weight = blen - 1;
10808 if (src_idx < arg->ndigits)
10810 tmp_len =
Min(blen,
arg->ndigits - src_idx);
10812 memcpy(a0_var.
digits,
arg->digits + src_idx,
10814 a0_var.
weight = blen - 1;
10829 add_var(&q_var, &a1_var, &q_var);
10830 add_var(&s_var, &s_var, &u_var);
10835 add_var(&s_var, &q_var, &s_var);
10845 add_var(&u_var, &a0_var, &u_var);
10846 mul_var(&q_var, &q_var, &q_var, 0);
10851 sub_var(&u_var, &q_var, &r_var);
10855 add_var(&r_var, &s_var, &r_var);
10857 add_var(&r_var, &s_var, &r_var);
10863 if (
cmp_var(&u_var, &q_var) < 0)
10867 Assert(src_idx == src_ndigits);
10875 result->
weight = res_weight;
10927 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
10928 errmsg(
"value overflows numeric format")));
10930 result->
dscale = rscale;
10935 dweight = (int) (
val * 0.434294481903252);
10944 if (fabs(
val) > 0.01)
10949 while (fabs(
val) > 0.01)
10955 local_rscale =
x.dscale + ndiv2;
10968 sig_digits = 1 + dweight + rscale + (int) (ndiv2 * 0.301029995663981);
10969 sig_digits =
Max(sig_digits, 0) + 8;
10971 local_rscale = sig_digits - 1;
10985 div_var_int(&elem, ni, 0, &elem, local_rscale,
true);
10989 add_var(result, &elem, result);
10991 mul_var(&elem, &
x, &elem, local_rscale);
10993 div_var_int(&elem, ni, 0, &elem, local_rscale,
true);
11001 while (ndiv2-- > 0)
11005 mul_var(result, result, result, local_rscale);
11053 ln_dweight =
x.weight *
DEC_DIGITS + (int) log10(
x.digits[0]);
11090 ln_var = log((
double)
digits) + dweight * 2.302585092994046;
11091 ln_dweight = (int) log10(fabs(
ln_var));
11124 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
11125 errmsg(
"cannot take logarithm of zero")));
11128 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
11129 errmsg(
"cannot take logarithm of a negative number")));
11157 local_rscale = rscale -
x.weight *
DEC_DIGITS / 2 + 8;
11164 local_rscale = rscale -
x.weight *
DEC_DIGITS / 2 + 8;
11185 local_rscale = rscale + (int) ((nsqrt + 1) * 0.301029995663981) + 8;
11189 div_var(result, &elem, result, local_rscale,
true,
false);
11191 mul_var(result, result, &
x, local_rscale);
11198 mul_var(&xx, &
x, &xx, local_rscale);
11199 div_var_int(&xx, ni, 0, &elem, local_rscale,
true);
11204 add_var(result, &elem, result);
11211 mul_var(result, &fact, result, rscale);
11232 int ln_base_dweight;
11233 int ln_num_dweight;
11234 int result_dweight;
11236 int ln_base_rscale;
11245 result_dweight = ln_num_dweight - ln_base_dweight;
11262 ln_base_rscale = rscale + result_dweight - ln_base_dweight + 8;
11265 ln_num_rscale = rscale + result_dweight - ln_num_dweight + 8;
11269 ln_var(base, &ln_base, ln_base_rscale);
11270 ln_var(num, &ln_num, ln_num_rscale);
11273 div_var(&ln_num, &ln_base, result, rscale,
true,
false);
11344 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
11345 errmsg(
"a negative number raised to a non-integer power yields a complex result")));
11388 local_rscale = 8 - ln_dweight;
11391 ln_var(base, &ln_base, local_rscale);
11393 mul_var(&ln_base, exp, &ln_num, local_rscale);
11402 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11403 errmsg(
"value overflows numeric format")));
11409 val *= 0.434294481903252;
11419 sig_digits = rscale + (int)
val;
11420 sig_digits =
Max(sig_digits, 0);
11423 local_rscale = sig_digits - ln_dweight + 8;
11428 ln_var(base, &ln_base, local_rscale);
11430 mul_var(&ln_base, exp, &ln_num, local_rscale);
11432 exp_var(&ln_num, result, rscale);
11488 f = exp * (log10(f) + p);
11496 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11497 errmsg(
"value overflows numeric format")));
11512 rscale =
Max(rscale, exp_dscale);
11528 result->
dscale = rscale;
11538 mul_var(base, base, result, rscale);
11549 (
errcode(ERRCODE_DIVISION_BY_ZERO),
11550 errmsg(
"division by zero")));
11552 result->
dscale = rscale;
11570 sig_digits = 1 + rscale + (int) f;
11577 sig_digits += (int) log(fabs((
double) exp)) + 8;
11593 while ((mask >>= 1) > 0)
11601 local_rscale =
Min(local_rscale, 2 * base_prod.
dscale);
11604 mul_var(&base_prod, &base_prod, &base_prod, local_rscale);
11608 local_rscale = sig_digits -
11610 local_rscale =
Min(local_rscale,
11614 mul_var(&base_prod, result, result, local_rscale);
11631 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11632 errmsg(
"value overflows numeric format")));
11661 result->
dscale = exp < 0 ? -exp : 0;
11673 result->
digits[0] *= 10;
11690 int rlen64_ndigits;
11700 errcode(ERRCODE_INVALID_PARAMETER_VALUE),
11701 errmsg(
"lower bound must be less than or equal to upper bound"));
11707 result->
dscale = rscale;
11726 for (
i = 0;
i < n;
i++)
11753 rlen64_ndigits = 1;
11754 while (rlen64_ndigits < res_ndigits && rlen64_ndigits < 4)
11757 if (rlen64_ndigits < rlen.
ndigits)
11758 rlen64 += rlen.
digits[rlen64_ndigits];
11772 result->
dscale = rscale;
11773 res_digits = result->
digits;
11782 if (rlen64_ndigits == res_ndigits && pow10 != 1)
11787 for (
i = rlen64_ndigits - 1;
i >= 0;
i--)
11790 rand = rand /
NBASE;
11797 whole_ndigits = res_ndigits;
11802 i = rlen64_ndigits;
11803 while (
i < whole_ndigits - 3)
11808 rand = rand /
NBASE;
11810 rand = rand /
NBASE;
11812 rand = rand /
NBASE;
11817 while (
i < whole_ndigits)
11824 if (
i < res_ndigits)
11835 }
while (
cmp_var(result, &rlen) > 0);
11838 add_var(result, rmin, result);
11878 const NumericDigit *var2digits,
int var2ndigits,
int var2weight)
11885 while (var1weight > var2weight && i1 < var1ndigits)
11887 if (var1digits[i1++] != 0)
11891 while (var2weight > var1weight && i2 < var2ndigits)
11893 if (var2digits[i2++] != 0)
11900 if (var1weight == var2weight)
11902 while (i1 < var1ndigits && i2 < var2ndigits)
11904 int stat = var1digits[i1++] - var2digits[i2++];
11919 while (i1 < var1ndigits)
11921 if (var1digits[i1++] != 0)
11924 while (i2 < var2ndigits)
11926 if (var2digits[i2++] != 0)
11957 int var1ndigits = var1->
ndigits;
11958 int var2ndigits = var2->
ndigits;
11969 res_rscale =
Max(rscale1, rscale2);
11971 res_ndigits = res_rscale + res_weight + 1;
11972 if (res_ndigits <= 0)
11977 res_digits = res_buf + 1;
11979 i1 = res_rscale + var1->
weight + 1;
11980 i2 = res_rscale + var2->
weight + 1;
11981 for (
i = res_ndigits - 1;
i >= 0;
i--)
11985 if (i1 >= 0 && i1 < var1ndigits)
11986 carry += var1digits[i1];
11987 if (i2 >= 0 && i2 < var2ndigits)
11988 carry += var2digits[i2];
11990 if (carry >=
NBASE)
11992 res_digits[
i] = carry -
NBASE;
11997 res_digits[
i] = carry;
12005 result->
ndigits = res_ndigits;
12006 result->
buf = res_buf;
12007 result->
digits = res_digits;
12008 result->
weight = res_weight;
12009 result->
dscale = res_dscale;
12042 int var1ndigits = var1->
ndigits;
12043 int var2ndigits = var2->
ndigits;
12047 res_weight = var1->
weight;
12054 res_rscale =
Max(rscale1, rscale2);
12056 res_ndigits = res_rscale + res_weight + 1;
12057 if (res_ndigits <= 0)
12062 res_digits = res_buf + 1;
12064 i1 = res_rscale + var1->
weight + 1;
12065 i2 = res_rscale + var2->
weight + 1;
12066 for (
i = res_ndigits - 1;
i >= 0;
i--)
12070 if (i1 >= 0 && i1 < var1ndigits)
12071 borrow += var1digits[i1];
12072 if (i2 >= 0 && i2 < var2ndigits)
12073 borrow -= var2digits[i2];
12077 res_digits[
i] = borrow +
NBASE;
12082 res_digits[
i] = borrow;
12090 result->
ndigits = res_ndigits;
12091 result->
buf = res_buf;
12092 result->
digits = res_digits;
12093 result->
weight = res_weight;
12094 result->
dscale = res_dscale;
12138 if (ndigits < var->ndigits ||
12139 (ndigits == var->
ndigits && di > 0))
12157#elif DEC_DIGITS == 2
12160#error unsupported NBASE
12162 extra =
digits[--ndigits] % pow10;
12163 digits[ndigits] -= extra;
12165 if (extra >= pow10 / 2)
12167 pow10 +=
digits[ndigits];
12168 if (pow10 >=
NBASE)
12173 digits[ndigits] = pow10;
12181 carry +=
digits[--ndigits];
12182 if (carry >=
NBASE)
12189 digits[ndigits] = carry;
12238 if (ndigits <= var->ndigits)
12257#elif DEC_DIGITS == 2
12260#error unsupported NBASE
12262 extra =
digits[--ndigits] % pow10;
12263 digits[ndigits] -= extra;
12282 while (ndigits > 0 && *
digits == 0)
12290 while (ndigits > 0 &&
digits[ndigits - 1] == 0)
12335 int32 *accum_digits;
12364 val_ndigits =
val->ndigits;
12365 val_digits =
val->digits;
12368 for (val_i = 0; val_i < val_ndigits; val_i++)
12370 accum_digits[
i] += (
int32) val_digits[val_i];
12410 for (
i = ndigits - 1;
i >= 0;
i--)
12412 newdig = dig[
i] + carry;
12413 if (newdig >=
NBASE)
12415 carry = newdig /
NBASE;
12416 newdig -= carry *
NBASE;
12429 for (
i = ndigits - 1;
i >= 0;
i--)
12431 newdig = dig[
i] + carry;
12432 if (newdig >=
NBASE)
12434 carry = newdig /
NBASE;
12435 newdig -= carry *
NBASE;
12456 int old_weight = accum->
weight;
12457 int old_ndigits = accum->
ndigits;
12463 accum_weight = old_weight;
12464 accum_ndigits = old_ndigits;
12475 if (
val->weight >= accum_weight)
12477 accum_weight =
val->weight + 1;
12478 accum_ndigits = accum_ndigits + (accum_weight - old_weight);
12493 accum_rscale = accum_ndigits - accum_weight - 1;
12494 val_rscale =
val->ndigits -
val->weight - 1;
12495 if (val_rscale > accum_rscale)
12496 accum_ndigits = accum_ndigits + (val_rscale - accum_rscale);
12498 if (accum_ndigits != old_ndigits ||
12499 accum_weight != old_weight)
12501 int32 *new_pos_digits;
12502 int32 *new_neg_digits;
12505 weightdiff = accum_weight - old_weight;
12507 new_pos_digits =
palloc0(accum_ndigits *
sizeof(
int32));
12508 new_neg_digits =
palloc0(accum_ndigits *
sizeof(
int32));
12512 memcpy(&new_pos_digits[weightdiff], accum->
pos_digits,
12513 old_ndigits *
sizeof(
int32));
12516 memcpy(&new_neg_digits[weightdiff], accum->
neg_digits,
12517 old_ndigits *
sizeof(
int32));
12524 accum->
weight = accum_weight;
12525 accum->
ndigits = accum_ndigits;
12581 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]
char * numeric_normalize(Numeric num)
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)
#define PRODSUM2(v1, i1, v2, i2)
char * numeric_out_sci(Numeric num, int scale)
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)
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)
static NumericAggState * makeNumericAggState(FunctionCallInfo fcinfo, bool calcSumX2)
Datum numeric_avg(PG_FUNCTION_ARGS)
static void numericvar_serialize(StringInfo buf, const NumericVar *var)
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)
Datum numeric_poly_sum(PG_FUNCTION_ARGS)
Datum int2_accum(PG_FUNCTION_ARGS)
Datum float8_numeric(PG_FUNCTION_ARGS)
#define PRODSUM3(v1, i1, v2, i2)
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)
#define PRODSUM1(v1, i1, v2, i2)
Datum numerictypmodout(PG_FUNCTION_ARGS)
Datum generate_series_numeric_support(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)
#define PRODSUM5(v1, i1, v2, i2)
static const NumericVar const_minus_one
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)
#define PRODSUM6(v1, i1, v2, i2)
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 NumericAggState * makeNumericAggStateCurrentContext(bool calcSumX2)
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)
#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)
#define PRODSUM4(v1, i1, v2, i2)
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 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 div_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale, bool round, bool exact)
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)
#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)
Node * estimate_expression_value(PlannerInfo *root, Node *node)
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 uint64 pg_abs_s64(int64 a)
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)
static uint32 pg_abs_s32(int32 a)
if(TABLE==NULL||TABLE_index==NULL)
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)
static bool is_funcclause(const void *clause)
#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 MemoryContext MemoryContextSwitchTo(MemoryContext context)
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 Datum UInt64GetDatum(uint64 X)
static char * DatumGetCString(Datum X)
static Pointer DatumGetPointer(Datum X)
static Datum CStringGetDatum(const char *X)
static int32 DatumGetInt32(Datum X)
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 PlannerInfo * root
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)