78 #define MUL_GUARD_DIGITS 4
79 #define DIV_GUARD_DIGITS 8
88 #define MUL_GUARD_DIGITS 3
89 #define DIV_GUARD_DIGITS 6
96 #define HALF_NBASE 5000
98 #define MUL_GUARD_DIGITS 2
99 #define DIV_GUARD_DIGITS 4
164 #define NUMERIC_SIGN_MASK 0xC000
165 #define NUMERIC_POS 0x0000
166 #define NUMERIC_NEG 0x4000
167 #define NUMERIC_SHORT 0x8000
168 #define NUMERIC_SPECIAL 0xC000
170 #define NUMERIC_FLAGBITS(n) ((n)->choice.n_header & NUMERIC_SIGN_MASK)
171 #define NUMERIC_IS_SHORT(n) (NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)
172 #define NUMERIC_IS_SPECIAL(n) (NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)
174 #define NUMERIC_HDRSZ (VARHDRSZ + sizeof(uint16) + sizeof(int16))
175 #define NUMERIC_HDRSZ_SHORT (VARHDRSZ + sizeof(uint16))
182 #define NUMERIC_HEADER_IS_SHORT(n) (((n)->choice.n_header & 0x8000) != 0)
183 #define NUMERIC_HEADER_SIZE(n) \
184 (VARHDRSZ + sizeof(uint16) + \
185 (NUMERIC_HEADER_IS_SHORT(n) ? 0 : sizeof(int16)))
196 #define NUMERIC_EXT_SIGN_MASK 0xF000
197 #define NUMERIC_NAN 0xC000
198 #define NUMERIC_PINF 0xD000
199 #define NUMERIC_NINF 0xF000
200 #define NUMERIC_INF_SIGN_MASK 0x2000
202 #define NUMERIC_EXT_FLAGBITS(n) ((n)->choice.n_header & NUMERIC_EXT_SIGN_MASK)
203 #define NUMERIC_IS_NAN(n) ((n)->choice.n_header == NUMERIC_NAN)
204 #define NUMERIC_IS_PINF(n) ((n)->choice.n_header == NUMERIC_PINF)
205 #define NUMERIC_IS_NINF(n) ((n)->choice.n_header == NUMERIC_NINF)
206 #define NUMERIC_IS_INF(n) \
207 (((n)->choice.n_header & ~NUMERIC_INF_SIGN_MASK) == NUMERIC_PINF)
213 #define NUMERIC_SHORT_SIGN_MASK 0x2000
214 #define NUMERIC_SHORT_DSCALE_MASK 0x1F80
215 #define NUMERIC_SHORT_DSCALE_SHIFT 7
216 #define NUMERIC_SHORT_DSCALE_MAX \
217 (NUMERIC_SHORT_DSCALE_MASK >> NUMERIC_SHORT_DSCALE_SHIFT)
218 #define NUMERIC_SHORT_WEIGHT_SIGN_MASK 0x0040
219 #define NUMERIC_SHORT_WEIGHT_MASK 0x003F
220 #define NUMERIC_SHORT_WEIGHT_MAX NUMERIC_SHORT_WEIGHT_MASK
221 #define NUMERIC_SHORT_WEIGHT_MIN (-(NUMERIC_SHORT_WEIGHT_MASK+1))
233 #define NUMERIC_DSCALE_MASK 0x3FFF
234 #define NUMERIC_DSCALE_MAX NUMERIC_DSCALE_MASK
236 #define NUMERIC_SIGN(n) \
237 (NUMERIC_IS_SHORT(n) ? \
238 (((n)->choice.n_short.n_header & NUMERIC_SHORT_SIGN_MASK) ? \
239 NUMERIC_NEG : NUMERIC_POS) : \
240 (NUMERIC_IS_SPECIAL(n) ? \
241 NUMERIC_EXT_FLAGBITS(n) : NUMERIC_FLAGBITS(n)))
242 #define NUMERIC_DSCALE(n) (NUMERIC_HEADER_IS_SHORT((n)) ? \
243 ((n)->choice.n_short.n_header & NUMERIC_SHORT_DSCALE_MASK) \
244 >> NUMERIC_SHORT_DSCALE_SHIFT \
245 : ((n)->choice.n_long.n_sign_dscale & NUMERIC_DSCALE_MASK))
246 #define NUMERIC_WEIGHT(n) (NUMERIC_HEADER_IS_SHORT((n)) ? \
247 (((n)->choice.n_short.n_header & NUMERIC_SHORT_WEIGHT_SIGN_MASK ? \
248 ~NUMERIC_SHORT_WEIGHT_MASK : 0) \
249 | ((n)->choice.n_short.n_header & NUMERIC_SHORT_WEIGHT_MASK)) \
250 : ((n)->choice.n_long.n_weight))
394 #define NUMERIC_ABBREV_BITS (SIZEOF_DATUM * BITS_PER_BYTE)
395 #if SIZEOF_DATUM == 8
396 #define NumericAbbrevGetDatum(X) ((Datum) (X))
397 #define DatumGetNumericAbbrev(X) ((int64) (X))
398 #define NUMERIC_ABBREV_NAN NumericAbbrevGetDatum(PG_INT64_MIN)
399 #define NUMERIC_ABBREV_PINF NumericAbbrevGetDatum(-PG_INT64_MAX)
400 #define NUMERIC_ABBREV_NINF NumericAbbrevGetDatum(PG_INT64_MAX)
402 #define NumericAbbrevGetDatum(X) ((Datum) (X))
403 #define DatumGetNumericAbbrev(X) ((int32) (X))
404 #define NUMERIC_ABBREV_NAN NumericAbbrevGetDatum(PG_INT32_MIN)
405 #define NUMERIC_ABBREV_PINF NumericAbbrevGetDatum(-PG_INT32_MAX)
406 #define NUMERIC_ABBREV_NINF NumericAbbrevGetDatum(PG_INT32_MAX)
431 #elif DEC_DIGITS == 2
433 #elif DEC_DIGITS == 1
441 #elif DEC_DIGITS == 2
443 #elif DEC_DIGITS == 1
472 #define dump_numeric(s,n)
473 #define dump_var(s,v)
476 #define digitbuf_alloc(ndigits) \
477 ((NumericDigit *) palloc((ndigits) * sizeof(NumericDigit)))
478 #define digitbuf_free(buf) \
484 #define init_var(v) memset(v, 0, sizeof(NumericVar))
486 #define NUMERIC_DIGITS(num) (NUMERIC_HEADER_IS_SHORT(num) ? \
487 (num)->choice.n_short.n_data : (num)->choice.n_long.n_data)
488 #define NUMERIC_NDIGITS(num) \
489 ((VARSIZE(num) - NUMERIC_HEADER_SIZE(num)) / sizeof(NumericDigit))
490 #define NUMERIC_CAN_BE_SHORT(scale,weight) \
491 ((scale) <= NUMERIC_SHORT_DSCALE_MAX && \
492 (weight) <= NUMERIC_SHORT_WEIGHT_MAX && \
493 (weight) >= NUMERIC_SHORT_WEIGHT_MIN)
503 const char *cp,
int sign,
528 static bool numericvar_to_int128(
const NumericVar *var, int128 *result);
529 static void int128_to_numericvar(int128
val,
NumericVar *var);
544 int var1weight,
int var1sign,
546 int var2weight,
int var2sign);
556 int rscale,
bool round);
562 static void div_var_int64(
const NumericVar *var, int64 ival,
int ival_weight,
600 const NumericVar *count_var,
bool reversed_bounds,
633 Node *escontext = fcinfo->context;
636 const char *numstart;
643 if (!isspace((
unsigned char) *cp))
671 if (!isdigit((
unsigned char) *cp) && *cp !=
'.')
704 if (!isspace((
unsigned char) *cp))
761 &
value, &cp, escontext))
771 if (!isspace((
unsigned char) *cp))
783 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
784 errmsg(
"value overflows numeric format")));
793 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
794 errmsg(
"invalid input syntax for type %s: \"%s\"",
877 return (
arg.ndigits == 0 ||
arg.ndigits <=
arg.weight + 1);
918 return ((typmod -
VARHDRSZ) >> 16) & 0xffff;
933 return (((typmod -
VARHDRSZ) & 0x7ff) ^ 1024) - 1024;
1039 if (strchr(
str,
'.') != NULL)
1045 last = strlen(
str) - 1;
1046 while (
str[last] ==
'0')
1050 if (
str[last] ==
'.')
1054 str[last + 1] =
'\0';
1096 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1097 errmsg(
"invalid sign in external \"numeric\" value")));
1102 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1103 errmsg(
"invalid scale in external \"numeric\" value")));
1105 for (
i = 0;
i <
len;
i++)
1109 if (d < 0 || d >=
NBASE)
1111 (
errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
1112 errmsg(
"invalid digit in external \"numeric\" value")));
1167 for (
i = 0;
i <
x.ndigits;
i++)
1219 new_scale == old_scale && new_precision >= old_precision))
1288 new->choice.n_short.n_header =
1326 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1327 errmsg(
"NUMERIC precision %d must be between 1 and %d",
1331 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1332 errmsg(
"NUMERIC scale %d must be between %d and %d",
1340 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1341 errmsg(
"NUMERIC precision %d must be between 1 and %d",
1349 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1350 errmsg(
"invalid NUMERIC type modifier")));
1393 res->choice.n_short.n_header =
1398 res->choice.n_short.n_header =
1423 res->choice.n_short.n_header =
1436 res->choice.n_short.n_header =
1439 res->choice.n_long.n_sign_dscale =
1442 res->choice.n_long.n_sign_dscale =
1707 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1708 errmsg(
"start value cannot be NaN")));
1711 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1712 errmsg(
"start value cannot be infinity")));
1718 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1719 errmsg(
"stop value cannot be NaN")));
1722 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1723 errmsg(
"stop value cannot be infinity")));
1735 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1736 errmsg(
"step size cannot be NaN")));
1739 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1740 errmsg(
"step size cannot be infinity")));
1747 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1748 errmsg(
"step size cannot equal zero")));
1839 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1840 errmsg(
"count must be greater than zero")));
1850 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1851 errmsg(
"operand, lower bound, and upper bound cannot be NaN")));
1855 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1856 errmsg(
"lower and upper bounds must be finite")));
1869 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
1870 errmsg(
"lower bound cannot equal upper bound")));
1899 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1900 errmsg(
"integer out of range")));
1916 const NumericVar *count_var,
bool reversed_bounds,
1927 if (!reversed_bounds)
1929 sub_var(&operand_var, &bound1_var, &operand_var);
1930 sub_var(&bound2_var, &bound1_var, &bound2_var);
1934 sub_var(&bound1_var, &operand_var, &operand_var);
1935 sub_var(&bound1_var, &bound2_var, &bound2_var);
1938 mul_var(&operand_var, count_var, &operand_var,
1940 div_var(&operand_var, &bound2_var, result_var,
1948 if (
cmp_var(result_var, count_var) >= 0)
2092 pfree(original_varatt);
2111 if (memtupcount < 10000 || nss->input_count < 10000 || !nss->estimating)
2122 if (abbr_card > 100000.0)
2127 "numeric_abbrev: estimation ends at cardinality %f"
2144 if (abbr_card < nss->input_count / 10000.0 + 0.5)
2149 "numeric_abbrev: aborting abbreviation at cardinality %f"
2150 " below threshold %f after " INT64_FORMAT " values (%d rows)",
2160 "numeric_abbrev: cardinality %f"
2260 #if NUMERIC_ABBREV_BITS == 64
2266 int weight = var->
weight;
2269 if (ndigits == 0 || weight < -44)
2273 else if (weight > 83)
2279 result = ((int64) (weight + 44) << 56);
2284 result |= ((int64) var->
digits[3]);
2287 result |= ((int64) var->
digits[2]) << 14;
2290 result |= ((int64) var->
digits[1]) << 28;
2293 result |= ((int64) var->
digits[0]) << 42;
2305 ^ (
uint32) ((uint64) result >> 32));
2315 #if NUMERIC_ABBREV_BITS == 32
2321 int weight = var->
weight;
2324 if (ndigits == 0 || weight < -11)
2328 else if (weight > 20)
2336 weight = (weight + 11) * 4;
2348 result = (result * 1000) + (nxt1 / 10);
2351 else if (result > 99)
2354 result = (result * 10000) + nxt1;
2357 else if (result > 9)
2362 result = (result * 100000) + (nxt1 * 10) + (nxt2 / 1000);
2370 result = (result * 1000000) + (nxt1 * 100) + (nxt2 / 100);
2373 result = result | (weight << 24);
2577 (
errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
2578 errmsg(
"invalid preceding or following size in window function")));
2675 sub_var(&basev, &offsetv, &sum);
2677 add_var(&basev, &offsetv, &sum);
2680 result = (
cmp_var(&valv, &sum) <= 0);
2682 result = (
cmp_var(&valv, &sum) >= 0);
2765 result = digit_hash ^ weight;
2907 add_var(&arg1, &arg2, &result);
2985 sub_var(&arg1, &arg2, &result);
3151 *have_error =
false;
3173 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3174 errmsg(
"division by zero")));
3196 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3197 errmsg(
"division by zero")));
3232 if (have_error && (arg2.
ndigits == 0 || arg2.
digits[0] == 0))
3241 div_var(&arg1, &arg2, &result, rscale,
true);
3281 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3282 errmsg(
"division by zero")));
3299 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3300 errmsg(
"division by zero")));
3330 div_var(&arg1, &arg2, &result, 0,
false);
3374 *have_error =
false;
3395 (
errcode(ERRCODE_DIVISION_BY_ZERO),
3396 errmsg(
"division by zero")));
3413 if (have_error && (arg2.
ndigits == 0 || arg2.
digits[0] == 0))
3419 mod_var(&arg1, &arg2, &result);
3546 gcd_var(&arg1, &arg2, &result);
3600 gcd_var(&arg1, &arg2, &result);
3601 div_var(&arg1, &result, &result, 0,
false);
3631 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
3632 errmsg(
"factorial of a negative number is undefined")));
3641 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
3642 errmsg(
"value overflows numeric format")));
3649 for (num = num - 1; num > 1; num--)
3656 mul_var(&result, &fact, &result, 0);
3691 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
3692 errmsg(
"cannot take square root of a negative number")));
3713 #if DEC_DIGITS == ((DEC_DIGITS / 2) * 2)
3716 if (
arg.weight >= 0)
3723 rscale =
Max(rscale,
arg.dscale);
3783 val *= 0.434294481903252;
3790 rscale =
Max(rscale,
arg.dscale);
3829 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
3830 errmsg(
"cannot take logarithm of a negative number")));
3842 rscale =
Max(rscale,
arg.dscale);
3884 if (sign1 < 0 || sign2 < 0)
3886 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
3887 errmsg(
"cannot take logarithm of a negative number")));
3889 if (sign1 == 0 || sign2 == 0)
3891 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
3892 errmsg(
"cannot take logarithm of zero")));
3917 log_var(&arg1, &arg2, &result);
3977 if (sign1 == 0 && sign2 < 0)
3979 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
3980 errmsg(
"zero raised to a negative power is undefined")));
3983 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
3984 errmsg(
"a negative number raised to a non-integer power yields a complex result")));
4010 if (sign1 == 0 && sign2 > 0)
4029 abs_x_gt_one =
true;
4038 if (abs_x_gt_one == (sign2 > 0))
4089 if (sign1 == 0 && sign2 < 0)
4091 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
4092 errmsg(
"zero raised to a negative power is undefined")));
4144 last_digit_pos = var->
ndigits - 1;
4145 while (last_digit_pos >= 0 &&
4146 var->
digits[last_digit_pos] == 0)
4149 if (last_digit_pos >= 0)
4166 while (last_digit % 10 == 0)
4263 rscale = log10val2 < 0 ? 0 : log10val2;
4283 static const int pow10[] = {1, 10, 100, 1000};
4284 #elif DEC_DIGITS == 2
4285 static const int pow10[] = {1, 10};
4286 #elif DEC_DIGITS == 1
4287 static const int pow10[] = {1};
4289 #error unsupported NBASE
4302 tmp = (int128) val1 * (int128) factor;
4304 int128_to_numericvar(tmp, &result);
4313 mul_var(&result, &tmp, &result, 0);
4351 *have_error =
false;
4364 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4365 errmsg(
"cannot convert NaN to %s",
"integer")));
4368 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4369 errmsg(
"cannot convert infinity to %s",
"integer")));
4386 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4387 errmsg(
"integer out of range")));
4439 *have_error =
false;
4452 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4453 errmsg(
"cannot convert NaN to %s",
"bigint")));
4456 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4457 errmsg(
"cannot convert infinity to %s",
"bigint")));
4474 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4475 errmsg(
"bigint out of range")));
4512 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4513 errmsg(
"cannot convert NaN to %s",
"smallint")));
4516 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4517 errmsg(
"cannot convert infinity to %s",
"smallint")));
4525 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4526 errmsg(
"smallint out of range")));
4530 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
4531 errmsg(
"smallint out of range")));
4546 char buf[DBL_DIG + 100];
4640 char buf[FLT_DIG + 100];
4708 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4709 errmsg(
"cannot convert NaN to %s",
"pg_lsn")));
4712 (
errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
4713 errmsg(
"cannot convert infinity to %s",
"pg_lsn")));
4721 (
errcode(ERRCODE_INVALID_PARAMETER_VALUE),
4722 errmsg(
"pg_lsn out of range")));
4757 #define NA_TOTAL_COUNT(na) \
4758 ((na)->N + (na)->NaNcount + (na)->pInfcount + (na)->nInfcount)
4772 elog(
ERROR,
"aggregate function called in non-aggregate context");
4777 state->calcSumX2 = calcSumX2;
4778 state->agg_context = agg_context;
4795 state->calcSumX2 = calcSumX2;
4833 state->maxScaleCount = 1;
4836 state->maxScaleCount++;
4839 if (
state->calcSumX2)
4853 if (
state->calcSumX2)
4905 if (
state->maxScaleCount > 1 ||
state->maxScale == 0)
4911 state->maxScaleCount--;
4913 else if (
state->N == 1)
4916 state->maxScale = 0;
4917 state->maxScaleCount = 0;
4927 if (
state->calcSumX2)
4942 if (
state->calcSumX2)
4955 if (
state->calcSumX2)
4996 elog(
ERROR,
"aggregate function called in non-aggregate context");
5010 state1->
N = state2->
N;
5025 state1->
N += state2->
N;
5088 elog(
ERROR,
"aggregate function called in non-aggregate context");
5102 state1->
N = state2->
N;
5116 state1->
N += state2->
N;
5161 elog(
ERROR,
"aggregate function called in non-aggregate context");
5212 elog(
ERROR,
"aggregate function called in non-aggregate context");
5271 elog(
ERROR,
"aggregate function called in non-aggregate context");
5326 elog(
ERROR,
"aggregate function called in non-aggregate context");
5387 elog(
ERROR,
"numeric_accum_inv called with NULL state");
5415 typedef struct Int128AggState
5427 static Int128AggState *
5430 Int128AggState *
state;
5435 elog(
ERROR,
"aggregate function called in non-aggregate context");
5439 state = (Int128AggState *)
palloc0(
sizeof(Int128AggState));
5440 state->calcSumX2 = calcSumX2;
5451 static Int128AggState *
5452 makeInt128AggStateCurrentContext(
bool calcSumX2)
5454 Int128AggState *
state;
5456 state = (Int128AggState *)
palloc0(
sizeof(Int128AggState));
5457 state->calcSumX2 = calcSumX2;
5466 do_int128_accum(Int128AggState *
state, int128
newval)
5468 if (
state->calcSumX2)
5479 do_int128_discard(Int128AggState *
state, int128
newval)
5481 if (
state->calcSumX2)
5489 #define makePolyNumAggState makeInt128AggState
5490 #define makePolyNumAggStateCurrentContext makeInt128AggStateCurrentContext
5493 #define makePolyNumAggState makeNumericAggState
5494 #define makePolyNumAggStateCurrentContext makeNumericAggStateCurrentContext
5572 elog(
ERROR,
"aggregate function called in non-aggregate context");
5586 state1->
N = state2->
N;
5603 state1->
N += state2->
N;
5638 elog(
ERROR,
"aggregate function called in non-aggregate context");
5660 int128_to_numericvar(
state->sumX, &tmp_var);
5668 int128_to_numericvar(
state->sumX2, &tmp_var);
5695 elog(
ERROR,
"aggregate function called in non-aggregate context");
5716 numericvar_to_int128(&tmp_var, &result->
sumX);
5724 numericvar_to_int128(&tmp_var, &result->
sumX2);
5775 elog(
ERROR,
"aggregate function called in non-aggregate context");
5789 state1->
N = state2->
N;
5803 state1->
N += state2->
N;
5836 elog(
ERROR,
"aggregate function called in non-aggregate context");
5858 int128_to_numericvar(
state->sumX, &tmp_var);
5884 elog(
ERROR,
"aggregate function called in non-aggregate context");
5905 numericvar_to_int128(&tmp_var, &result->
sumX);
5930 elog(
ERROR,
"int2_accum_inv called with NULL state");
5939 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
5955 elog(
ERROR,
"int4_accum_inv called with NULL state");
5964 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
5980 elog(
ERROR,
"int8_accum_inv called with NULL state");
5986 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6001 elog(
ERROR,
"int8_avg_accum_inv called with NULL state");
6010 elog(
ERROR,
"do_numeric_discard failed unexpectedly");
6033 int128_to_numericvar(
state->sumX, &result);
6062 int128_to_numericvar(
state->sumX, &result);
6089 if (
state->NaNcount > 0)
6093 if (
state->pInfcount > 0 &&
state->nInfcount > 0)
6095 if (
state->pInfcount > 0)
6097 if (
state->nInfcount > 0)
6123 if (
state->NaNcount > 0)
6127 if (
state->pInfcount > 0 &&
state->nInfcount > 0)
6129 if (
state->pInfcount > 0)
6131 if (
state->nInfcount > 0)
6155 bool variance,
bool sample,
6177 if (sample && totCount <= 1)
6189 if (
state->NaNcount > 0 ||
state->pInfcount > 0 ||
state->nInfcount > 0)
6205 rscale = vsumX.
dscale * 2;
6207 mul_var(&vsumX, &vsumX, &vsumX, rscale);
6208 mul_var(&vN, &vsumX2, &vsumX2, rscale);
6209 sub_var(&vsumX2, &vsumX, &vsumX2);
6219 mul_var(&vN, &vNminus1, &vNminus1, 0);
6221 mul_var(&vN, &vN, &vNminus1, 0);
6223 div_var(&vsumX2, &vNminus1, &vsumX, rscale,
true);
6307 numeric_poly_stddev_internal(Int128AggState *
state,
6308 bool variance,
bool sample,
6325 int128_to_numericvar(
state->sumX, &tmp_var);
6328 int128_to_numericvar(
state->sumX2, &tmp_var);
6361 res = numeric_poly_stddev_internal(
state,
true,
true, &is_null);
6382 res = numeric_poly_stddev_internal(
state,
false,
true, &is_null);
6403 res = numeric_poly_stddev_internal(
state,
true,
false, &is_null);
6424 res = numeric_poly_stddev_internal(
state,
false,
false, &is_null);
6477 #ifndef USE_FLOAT8_BYVAL
6526 #ifndef USE_FLOAT8_BYVAL
6623 elog(
ERROR,
"expected 2-element int8 array");
6651 elog(
ERROR,
"expected 2-element int8 array");
6669 elog(
ERROR,
"aggregate function called in non-aggregate context");
6676 elog(
ERROR,
"expected 2-element int8 array");
6680 elog(
ERROR,
"expected 2-element int8 array");
6686 state1->
sum += state2->
sum;
6710 elog(
ERROR,
"expected 2-element int8 array");
6738 elog(
ERROR,
"expected 2-element int8 array");
6757 elog(
ERROR,
"expected 2-element int8 array");
6761 if (transdata->
count == 0)
6782 elog(
ERROR,
"expected 2-element int8 array");
6786 if (transdata->
count == 0)
6800 #ifdef NUMERIC_DEBUG
6838 for (
i = 0;
i < ndigits;
i++)
6964 bool have_dp =
false;
6966 unsigned char *decdigits;
6999 if (!isdigit((
unsigned char) *cp))
7000 goto invalid_syntax;
7010 if (isdigit((
unsigned char) *cp))
7012 decdigits[
i++] = *cp++ -
'0';
7018 else if (*cp ==
'.')
7021 goto invalid_syntax;
7026 goto invalid_syntax;
7028 else if (*cp ==
'_')
7032 if (!isdigit((
unsigned char) *cp))
7033 goto invalid_syntax;
7044 if (*cp ==
'e' || *cp ==
'E')
7062 else if (*cp ==
'-')
7069 if (!isdigit((
unsigned char) *cp))
7070 goto invalid_syntax;
7074 if (isdigit((
unsigned char) *cp))
7076 exponent = exponent * 10 + (*cp++ -
'0');
7080 else if (*cp ==
'_')
7084 if (!isdigit((
unsigned char) *cp))
7085 goto invalid_syntax;
7092 exponent = -exponent;
7094 dweight += (int) exponent;
7095 dscale -= (int) exponent;
7110 offset = (weight + 1) *
DEC_DIGITS - (dweight + 1);
7115 dest->weight = weight;
7116 dest->dscale = dscale;
7121 while (ndigits-- > 0)
7124 *
digits++ = ((decdigits[
i] * 10 + decdigits[
i + 1]) * 10 +
7125 decdigits[
i + 2]) * 10 + decdigits[
i + 3];
7126 #elif DEC_DIGITS == 2
7127 *
digits++ = decdigits[
i] * 10 + decdigits[
i + 1];
7128 #elif DEC_DIGITS == 1
7131 #error unsupported NBASE
7148 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7149 errmsg(
"value overflows numeric format")));
7153 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
7154 errmsg(
"invalid input syntax for type %s: \"%s\"",
7165 return dig >=
'0' && dig <=
'9' ? dig -
'0' :
7166 dig >=
'a' && dig <=
'f' ? dig -
'a' + 10 :
7167 dig >=
'A' && dig <=
'F' ? dig -
'A' + 10 : -1;
7192 const char **endptr,
Node *escontext)
7194 const char *firstdigit = cp;
7216 if (isxdigit((
unsigned char) *cp))
7227 if (
dest->weight > SHRT_MAX)
7238 else if (*cp ==
'_')
7242 if (!isxdigit((
unsigned char) *cp))
7243 goto invalid_syntax;
7253 if (*cp >=
'0' && *cp <=
'7')
7264 if (
dest->weight > SHRT_MAX)
7272 tmp = tmp * 8 + (*cp++ -
'0');
7275 else if (*cp ==
'_')
7279 if (*cp < '0' || *cp >
'7')
7280 goto invalid_syntax;
7290 if (*cp >=
'0' && *cp <=
'1')
7301 if (
dest->weight > SHRT_MAX)
7309 tmp = tmp * 2 + (*cp++ -
'0');
7312 else if (*cp ==
'_')
7316 if (*cp < '0' || *cp >
'1')
7317 goto invalid_syntax;
7325 goto invalid_syntax;
7329 goto invalid_syntax;
7337 if (
dest->weight > SHRT_MAX)
7351 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7352 errmsg(
"value overflows numeric format")));
7356 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
7357 errmsg(
"invalid input syntax for type %s: \"%s\"",
7422 if (
value->ndigits > 0)
7423 memcpy(newbuf + 1,
value->digits,
7430 dest->digits = newbuf + 1;
7489 for (d = 0; d <= var->
weight; d++)
7495 bool putit = (d > 0);
7514 #elif DEC_DIGITS == 2
7517 if (d1 > 0 || d > 0)
7520 #elif DEC_DIGITS == 1
7523 #error unsupported NBASE
7536 endcp = cp + dscale;
7641 div_var(var, &tmp_var, &tmp_var, rscale,
true);
7653 len = strlen(sig_out) + 13;
7700 for (
i = 0;
i <
len;
i++)
7734 int weight = var->
weight;
7740 *have_error =
false;
7767 while (n > 0 && *
digits == 0)
7774 while (n > 0 &&
digits[n - 1] == 0)
7790 result->choice.n_short.n_header =
7802 result->choice.n_long.n_sign_dscale =
7804 result->choice.n_long.n_weight = weight;
7823 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7824 errmsg(
"value overflows numeric format")));
7901 else if (dig < 1000)
7903 #elif DEC_DIGITS == 2
7906 #elif DEC_DIGITS == 1
7909 #error unsupported NBASE
7913 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7914 errmsg(
"numeric field overflow"),
7915 errdetail(
"A field with precision %d, scale %d must round to an absolute value less than %s%d.",
7964 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
7965 errmsg(
"numeric field overflow"),
7966 errdetail(
"A field with precision %d, scale %d cannot hold an infinite value.",
7967 precision,
scale)));
8007 Assert(weight >= 0 && ndigits <= weight + 1);
8017 for (
i = 1;
i <= weight;
i++)
8084 newuval = uval /
NBASE;
8085 *ptr = uval - newuval *
NBASE;
8090 var->
weight = ndigits - 1;
8135 Assert(weight >= 0 && ndigits <= weight + 1);
8140 for (
i = 1;
i <= weight;
i++)
8172 numericvar_to_int128(
const NumericVar *var, int128 *result)
8203 Assert(weight >= 0 && ndigits <= weight + 1);
8209 for (
i = 1;
i <= weight;
i++)
8225 if (!neg || (-
val) !=
val ||
val == 0 || oldval < 0)
8235 *result = neg ? -
val :
val;
8275 newuval = uval /
NBASE;
8276 *ptr = uval - newuval *
NBASE;
8281 var->
weight = ndigits - 1;
8298 val = strtod(tmp, &endptr);
8299 if (*endptr !=
'\0')
8303 (
errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
8304 errmsg(
"invalid input syntax for type %s: \"%s\"",
8305 "double precision", tmp)));
8337 int var1weight,
int var1sign,
8339 int var2weight,
int var2sign)
8341 if (var1ndigits == 0)
8343 if (var2ndigits == 0)
8349 if (var2ndigits == 0)
8361 var2digits, var2ndigits, var2weight);
8368 var1digits, var1ndigits, var1weight);
8655 var1digits = var1->
digits;
8656 var2digits = var2->
digits;
8658 if (var1ndigits == 0 || var2ndigits == 0)
8685 res_ndigits = var1ndigits + var2ndigits + 1;
8690 if (res_ndigits < 3)
8714 dig = (
int *)
palloc0(res_ndigits *
sizeof(
int));
8726 for (i1 =
Min(var1ndigits - 1, res_ndigits - 3); i1 >= 0; i1--)
8734 maxdig += var1digit;
8735 if (maxdig > (INT_MAX - INT_MAX /
NBASE) / (
NBASE - 1))
8739 for (
i = res_ndigits - 1;
i >= 0;
i--)
8741 newdig = dig[
i] + carry;
8742 if (newdig >=
NBASE)
8744 carry = newdig /
NBASE;
8745 newdig -= carry *
NBASE;
8753 maxdig = 1 + var1digit;
8770 int i2limit =
Min(var2ndigits, res_ndigits - i1 - 2);
8771 int *dig_i1_2 = &dig[i1 + 2];
8773 for (i2 = 0; i2 < i2limit; i2++)
8774 dig_i1_2[i2] += var1digit * var2digits[i2];
8784 res_digits = result->
digits;
8786 for (
i = res_ndigits - 1;
i >= 0;
i--)
8788 newdig = dig[
i] + carry;
8789 if (newdig >=
NBASE)
8791 carry = newdig /
NBASE;
8792 newdig -= carry *
NBASE;
8796 res_digits[
i] = newdig;
8805 result->
weight = res_weight;
8806 result->
sign = res_sign;
8826 int rscale,
bool round)
8843 int var1ndigits = var1->
ndigits;
8844 int var2ndigits = var2->
ndigits;
8850 if (var2ndigits == 0 || var2->
digits[0] == 0)
8852 (
errcode(ERRCODE_DIVISION_BY_ZERO),
8853 errmsg(
"division by zero")));
8862 if (var2ndigits <= 2)
8865 int idivisor_weight;
8867 idivisor = var2->
digits[0];
8868 idivisor_weight = var2->
weight;
8869 if (var2ndigits == 2)
8875 idivisor = -idivisor;
8877 div_var_int(var1, idivisor, idivisor_weight, result, rscale, round);
8881 if (var2ndigits <= 4)
8884 int idivisor_weight;
8886 idivisor = var2->
digits[0];
8887 idivisor_weight = var2->
weight;
8888 for (
i = 1;
i < var2ndigits;
i++)
8894 idivisor = -idivisor;
8896 div_var_int64(var1, idivisor, idivisor_weight, result, rscale, round);
8906 if (var1ndigits == 0)
8926 res_ndigits =
Max(res_ndigits, 1);
8938 div_ndigits = res_ndigits + var2ndigits;
8939 div_ndigits =
Max(div_ndigits, var1ndigits);
8953 divisor = dividend + (div_ndigits + 1);
8961 res_digits = result->
digits;
8974 int d =
NBASE / (divisor[1] + 1);
8977 for (
i = var2ndigits;
i > 0;
i--)
8979 carry += divisor[
i] * d;
8980 divisor[
i] = carry %
NBASE;
8981 carry = carry /
NBASE;
8986 for (
i = var1ndigits;
i >= 0;
i--)
8988 carry += dividend[
i] * d;
8989 dividend[
i] = carry %
NBASE;
8990 carry = carry /
NBASE;
8996 divisor1 = divisor[1];
8997 divisor2 = divisor[2];
9005 for (
j = 0;
j < res_ndigits;
j++)
9008 int next2digits = dividend[
j] *
NBASE + dividend[
j + 1];
9016 if (next2digits == 0)
9022 if (dividend[
j] == divisor1)
9025 qhat = next2digits / divisor1;
9033 while (divisor2 * qhat >
9034 (next2digits - qhat * divisor1) *
NBASE + dividend[
j + 2])
9051 for (
i = var2ndigits;
i >= 0;
i--)
9055 tmp_result = dividend_j[
i] - borrow - divisor[
i] * qhat;
9057 dividend_j[
i] = tmp_result + borrow *
NBASE;
9072 for (
i = var2ndigits;
i >= 0;
i--)
9074 carry += dividend_j[
i] + divisor[
i];
9077 dividend_j[
i] = carry -
NBASE;
9082 dividend_j[
i] = carry;
9092 res_digits[
j] = qhat;
9100 result->
weight = res_weight;
9101 result->
sign = res_sign;
9154 int var1ndigits = var1->
ndigits;
9155 int var2ndigits = var2->
ndigits;
9163 if (var2ndigits == 0 || var2digits[0] == 0)
9165 (
errcode(ERRCODE_DIVISION_BY_ZERO),
9166 errmsg(
"division by zero")));
9175 if (var2ndigits <= 2)
9178 int idivisor_weight;
9180 idivisor = var2->
digits[0];
9181 idivisor_weight = var2->
weight;
9182 if (var2ndigits == 2)
9188 idivisor = -idivisor;
9190 div_var_int(var1, idivisor, idivisor_weight, result, rscale, round);
9194 if (var2ndigits <= 4)
9197 int idivisor_weight;
9199 idivisor = var2->
digits[0];
9200 idivisor_weight = var2->
weight;
9201 for (
i = 1;
i < var2ndigits;
i++)
9207 idivisor = -idivisor;
9209 div_var_int64(var1, idivisor, idivisor_weight, result, rscale, round);
9219 if (var1ndigits == 0)
9259 div = (
int *)
palloc0((div_ndigits + 1) *
sizeof(int));
9260 load_ndigits =
Min(div_ndigits, var1ndigits);
9261 for (
i = 0;
i < load_ndigits;
i++)
9262 div[
i + 1] = var1digits[
i];
9270 fdivisor = (double) var2digits[0];
9271 for (
i = 1;
i < 4;
i++)
9274 if (
i < var2ndigits)
9275 fdivisor += (double) var2digits[
i];
9277 fdivisorinverse = 1.0 / fdivisor;
9301 for (qi = 0; qi < div_ndigits; qi++)
9304 fdividend = (double) div[qi];
9305 for (
i = 1;
i < 4;
i++)
9308 if (qi +
i <= div_ndigits)
9309 fdividend += (double) div[qi +
i];
9312 fquotient = fdividend * fdivisorinverse;
9313 qdigit = (fquotient >= 0.0) ? ((
int) fquotient) :
9314 (((
int) fquotient) - 1);
9319 maxdiv += abs(qdigit);
9320 if (maxdiv > (INT_MAX - INT_MAX /
NBASE - 1) / (
NBASE - 1))
9330 for (
i =
Min(qi + var2ndigits - 2, div_ndigits);
i > qi;
i--)
9332 newdig = div[
i] + carry;
9335 carry = -((-newdig - 1) /
NBASE) - 1;
9336 newdig -= carry *
NBASE;
9338 else if (newdig >=
NBASE)
9340 carry = newdig /
NBASE;
9341 newdig -= carry *
NBASE;
9347 newdig = div[qi] + carry;
9361 fdividend = (double) div[qi];
9362 for (
i = 1;
i < 4;
i++)
9365 if (qi +
i <= div_ndigits)
9366 fdividend += (double) div[qi +
i];
9369 fquotient = fdividend * fdivisorinverse;
9370 qdigit = (fquotient >= 0.0) ? ((
int) fquotient) :
9371 (((
int) fquotient) - 1);
9372 maxdiv += abs(qdigit);
9395 int istop =
Min(var2ndigits, div_ndigits - qi + 1);
9396 int *div_qi = &div[qi];
9398 for (
i = 0;
i < istop;
i++)
9425 div[qi + 1] += div[qi] *
NBASE;
9433 fdividend = (double) div[qi];
9434 for (
i = 1;
i < 4;
i++)
9436 fquotient = fdividend * fdivisorinverse;
9437 qdigit = (fquotient >= 0.0) ? ((
int) fquotient) :
9438 (((
int) fquotient) - 1);
9450 res_digits = result->
digits;
9452 for (
i = div_ndigits;
i >= 0;
i--)
9454 newdig = div[
i] + carry;
9457 carry = -((-newdig - 1) /
NBASE) - 1;
9458 newdig -= carry *
NBASE;
9460 else if (newdig >=
NBASE)
9462 carry = newdig /
NBASE;
9463 newdig -= carry *
NBASE;
9467 res_digits[
i] = newdig;
9476 result->
weight = res_weight;
9477 result->
sign = res_sign;
9501 int var_ndigits = var->
ndigits;
9513 errcode(ERRCODE_DIVISION_BY_ZERO),
9514 errmsg(
"division by zero"));
9517 if (var_ndigits == 0)
9533 res_weight = var->
weight - ival_weight;
9537 res_ndigits =
Max(res_ndigits, 1);
9544 res_digits = res_buf + 1;
9556 divisor = abs(ival);
9558 if (divisor <= UINT_MAX /
NBASE)
9563 for (
i = 0;
i < res_ndigits;
i++)
9565 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9567 carry = carry % divisor;
9575 for (
i = 0;
i < res_ndigits;
i++)
9577 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9579 carry = carry % divisor;
9585 result->
ndigits = res_ndigits;
9586 result->
buf = res_buf;
9587 result->
digits = res_digits;
9588 result->
weight = res_weight;
9589 result->
sign = res_sign;
9613 div_var_int64(
const NumericVar *var, int64 ival,
int ival_weight,
9617 int var_ndigits = var->
ndigits;
9629 errcode(ERRCODE_DIVISION_BY_ZERO),
9630 errmsg(
"division by zero"));
9633 if (var_ndigits == 0)
9649 res_weight = var->
weight - ival_weight;
9653 res_ndigits =
Max(res_ndigits, 1);
9660 res_digits = res_buf + 1;
9679 for (
i = 0;
i < res_ndigits;
i++)
9681 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9683 carry = carry % divisor;
9691 for (
i = 0;
i < res_ndigits;
i++)
9693 carry = carry *
NBASE + (
i < var_ndigits ? var_digits[
i] : 0);
9695 carry = carry % divisor;
9701 result->
ndigits = res_ndigits;
9702 result->
buf = res_buf;
9703 result->
digits = res_digits;
9704 result->
weight = res_weight;
9705 result->
sign = res_sign;
9749 firstdigit1 = var1->
digits[
i];
9750 if (firstdigit1 != 0)
9761 firstdigit2 = var2->
digits[
i];
9762 if (firstdigit2 != 0)
9773 qweight = weight1 - weight2;
9774 if (firstdigit1 <= firstdigit2)
9806 div_var(var1, var2, &tmp, 0,
false);
9863 while (
cmp_abs(&r, var2) >= 0)
9972 result->
dscale = res_dscale;
9988 mod_var(&tmp_arg, result, &mod);
9995 result->
dscale = res_dscale;
10034 result->
dscale = rscale;
10044 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
10045 errmsg(
"cannot take square root of a negative number")));
10058 if (
arg->weight >= 0)
10059 res_weight =
arg->weight / 2;
10061 res_weight = -((-
arg->weight - 1) / 2 + 1);
10069 if (rscale + 1 >= 0)
10072 res_ndigits = res_weight + 1 - (-rscale - 1) /
DEC_DIGITS;
10073 res_ndigits =
Max(res_ndigits, 1);
10081 src_ndigits =
arg->weight + 1 + (res_ndigits - res_weight - 1) * 2;
10082 src_ndigits =
Max(src_ndigits, 1);
10152 while ((ndigits[step] = src_ndigits) > 4)
10155 blen = src_ndigits / 4;
10156 if (blen * 4 == src_ndigits &&
arg->digits[0] <
NBASE / 4)
10160 src_ndigits -= 2 * blen;
10172 arg_int64 =
arg->digits[0];
10173 for (src_idx = 1; src_idx < src_ndigits; src_idx++)
10175 arg_int64 *=
NBASE;
10176 if (src_idx < arg->ndigits)
10177 arg_int64 +=
arg->digits[src_idx];
10180 s_int64 = (int64) sqrt((
double) arg_int64);
10181 r_int64 = arg_int64 - s_int64 * s_int64;
10193 while (r_int64 < 0 || r_int64 > 2 * s_int64)
10195 s_int64 = (s_int64 + arg_int64 / s_int64) / 2;
10196 r_int64 = arg_int64 - s_int64 * s_int64;
10219 while (step >= 0 && (src_ndigits = ndigits[step]) <= 8)
10230 blen = (src_ndigits - src_idx) / 2;
10237 for (
i = 0;
i < blen;
i++, src_idx++)
10241 if (src_idx < arg->ndigits)
10242 a1 +=
arg->digits[src_idx];
10245 for (
i = 0;
i < blen;
i++, src_idx++)
10248 if (src_idx < arg->ndigits)
10249 a0 +=
arg->digits[src_idx];
10253 numer = r_int64 *
b +
a1;
10254 denom = 2 * s_int64;
10256 u = numer - q * denom;
10259 s_int64 = s_int64 *
b + q;
10260 r_int64 = u *
b + a0 - q * q;
10265 r_int64 += s_int64;
10267 r_int64 += s_int64;
10270 Assert(src_idx == src_ndigits);
10284 s_int128 = s_int64;
10285 r_int128 = r_int64;
10293 while (step >= 0 && (src_ndigits = ndigits[step]) <= 16)
10304 blen = (src_ndigits - src_idx) / 2;
10311 for (
i = 0;
i < blen;
i++, src_idx++)
10315 if (src_idx < arg->ndigits)
10316 a1 +=
arg->digits[src_idx];
10319 for (
i = 0;
i < blen;
i++, src_idx++)
10322 if (src_idx < arg->ndigits)
10323 a0 +=
arg->digits[src_idx];
10327 numer = r_int128 *
b +
a1;
10328 denom = 2 * s_int128;
10330 u = numer - q * denom;
10333 s_int128 = s_int128 *
b + q;
10334 r_int128 = u *
b + a0 - q * q;
10339 r_int128 += s_int128;
10341 r_int128 += s_int128;
10344 Assert(src_idx == src_ndigits);
10354 int128_to_numericvar(s_int128, &s_var);
10356 int128_to_numericvar(r_int128, &r_var);
10377 src_ndigits = ndigits[step];
10378 blen = (src_ndigits - src_idx) / 2;
10381 if (src_idx < arg->ndigits)
10383 tmp_len =
Min(blen,
arg->ndigits - src_idx);
10385 memcpy(a1_var.
digits,
arg->digits + src_idx,
10387 a1_var.
weight = blen - 1;
10399 if (src_idx < arg->ndigits)
10401 tmp_len =
Min(blen,
arg->ndigits - src_idx);
10403 memcpy(a0_var.
digits,
arg->digits + src_idx,
10405 a0_var.
weight = blen - 1;
10420 add_var(&q_var, &a1_var, &q_var);
10421 add_var(&s_var, &s_var, &u_var);
10426 add_var(&s_var, &q_var, &s_var);
10436 add_var(&u_var, &a0_var, &u_var);
10437 mul_var(&q_var, &q_var, &q_var, 0);
10442 sub_var(&u_var, &q_var, &r_var);
10446 add_var(&r_var, &s_var, &r_var);
10448 add_var(&r_var, &s_var, &r_var);
10454 if (
cmp_var(&u_var, &q_var) < 0)
10458 Assert(src_idx == src_ndigits);
10466 result->
weight = res_weight;
10518 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
10519 errmsg(
"value overflows numeric format")));
10521 result->
dscale = rscale;
10526 dweight = (int) (
val * 0.434294481903252);
10535 if (fabs(
val) > 0.01)
10540 while (fabs(
val) > 0.01)
10546 local_rscale =
x.dscale + ndiv2;
10559 sig_digits = 1 + dweight + rscale + (int) (ndiv2 * 0.301029995663981);
10560 sig_digits =
Max(sig_digits, 0) + 8;
10562 local_rscale = sig_digits - 1;
10576 div_var_int(&elem, ni, 0, &elem, local_rscale,
true);
10580 add_var(result, &elem, result);
10582 mul_var(&elem, &
x, &elem, local_rscale);
10584 div_var_int(&elem, ni, 0, &elem, local_rscale,
true);
10592 while (ndiv2-- > 0)
10596 mul_var(result, result, result, local_rscale);
10644 ln_dweight =
x.weight *
DEC_DIGITS + (int) log10(
x.digits[0]);
10681 ln_var = log((
double)
digits) + dweight * 2.302585092994046;
10682 ln_dweight = (int) log10(fabs(
ln_var));
10715 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
10716 errmsg(
"cannot take logarithm of zero")));
10719 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
10720 errmsg(
"cannot take logarithm of a negative number")));
10748 local_rscale = rscale -
x.weight *
DEC_DIGITS / 2 + 8;
10755 local_rscale = rscale -
x.weight *
DEC_DIGITS / 2 + 8;
10776 local_rscale = rscale + (int) ((nsqrt + 1) * 0.301029995663981) + 8;
10780 div_var_fast(result, &elem, result, local_rscale,
true);
10782 mul_var(result, result, &
x, local_rscale);
10789 mul_var(&xx, &
x, &xx, local_rscale);
10790 div_var_int(&xx, ni, 0, &elem, local_rscale,
true);
10795 add_var(result, &elem, result);
10802 mul_var(result, &fact, result, rscale);
10823 int ln_base_dweight;
10824 int ln_num_dweight;
10825 int result_dweight;
10827 int ln_base_rscale;
10836 result_dweight = ln_num_dweight - ln_base_dweight;
10853 ln_base_rscale = rscale + result_dweight - ln_base_dweight + 8;
10856 ln_num_rscale = rscale + result_dweight - ln_num_dweight + 8;
10860 ln_var(base, &ln_base, ln_base_rscale);
10861 ln_var(num, &ln_num, ln_num_rscale);
10864 div_var_fast(&ln_num, &ln_base, result, rscale,
true);
10935 (
errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
10936 errmsg(
"a negative number raised to a non-integer power yields a complex result")));
10978 local_rscale = 8 - ln_dweight;
10981 ln_var(base, &ln_base, local_rscale);
10983 mul_var(&ln_base, exp, &ln_num, local_rscale);
10992 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
10993 errmsg(
"value overflows numeric format")));
10999 val *= 0.434294481903252;
11009 sig_digits = rscale + (int)
val;
11010 sig_digits =
Max(sig_digits, 0);
11013 local_rscale = sig_digits - ln_dweight + 8;
11018 ln_var(base, &ln_base, local_rscale);
11020 mul_var(&ln_base, exp, &ln_num, local_rscale);
11022 exp_var(&ln_num, result, rscale);
11078 f = exp * (log10(f) + p);
11086 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11087 errmsg(
"value overflows numeric format")));
11102 rscale =
Max(rscale, exp_dscale);
11118 result->
dscale = rscale;
11128 mul_var(base, base, result, rscale);
11139 (
errcode(ERRCODE_DIVISION_BY_ZERO),
11140 errmsg(
"division by zero")));
11142 result->
dscale = rscale;
11160 sig_digits = 1 + rscale + (int) f;
11167 sig_digits += (int) log(fabs((
double) exp)) + 8;
11183 while ((mask >>= 1) > 0)
11191 local_rscale =
Min(local_rscale, 2 * base_prod.
dscale);
11194 mul_var(&base_prod, &base_prod, &base_prod, local_rscale);
11198 local_rscale = sig_digits -
11200 local_rscale =
Min(local_rscale,
11204 mul_var(&base_prod, result, result, local_rscale);
11215 if (base_prod.
weight > SHRT_MAX || result->
weight > SHRT_MAX)
11220 (
errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
11221 errmsg(
"value overflows numeric format")));
11250 result->
dscale = exp < 0 ? -exp : 0;
11262 result->
digits[0] *= 10;
11300 const NumericDigit *var2digits,
int var2ndigits,
int var2weight)
11307 while (var1weight > var2weight && i1 < var1ndigits)
11309 if (var1digits[i1++] != 0)
11313 while (var2weight > var1weight && i2 < var2ndigits)
11315 if (var2digits[i2++] != 0)
11322 if (var1weight == var2weight)
11324 while (i1 < var1ndigits && i2 < var2ndigits)
11326 int stat = var1digits[i1++] - var2digits[i2++];
11341 while (i1 < var1ndigits)
11343 if (var1digits[i1++] != 0)
11346 while (i2 < var2ndigits)
11348 if (var2digits[i2++] != 0)
11379 int var1ndigits = var1->
ndigits;
11380 int var2ndigits = var2->
ndigits;
11391 res_rscale =
Max(rscale1, rscale2);
11393 res_ndigits = res_rscale + res_weight + 1;
11394 if (res_ndigits <= 0)
11399 res_digits = res_buf + 1;
11401 i1 = res_rscale + var1->
weight + 1;
11402 i2 = res_rscale + var2->
weight + 1;
11403 for (
i = res_ndigits - 1;
i >= 0;
i--)
11407 if (i1 >= 0 && i1 < var1ndigits)
11408 carry += var1digits[i1];
11409 if (i2 >= 0 && i2 < var2ndigits)
11410 carry += var2digits[i2];
11412 if (carry >=
NBASE)
11414 res_digits[
i] = carry -
NBASE;
11419 res_digits[
i] = carry;
11427 result->
ndigits = res_ndigits;
11428 result->
buf = res_buf;
11429 result->
digits = res_digits;
11430 result->
weight = res_weight;
11431 result->
dscale = res_dscale;
11464 int var1ndigits = var1->
ndigits;
11465 int var2ndigits = var2->
ndigits;
11469 res_weight = var1->
weight;
11476 res_rscale =
Max(rscale1, rscale2);
11478 res_ndigits = res_rscale + res_weight + 1;
11479 if (res_ndigits <= 0)
11484 res_digits = res_buf + 1;
11486 i1 = res_rscale + var1->
weight + 1;
11487 i2 = res_rscale + var2->
weight + 1;
11488 for (
i = res_ndigits - 1;
i >= 0;
i--)
11492 if (i1 >= 0 && i1 < var1ndigits)
11493 borrow += var1digits[i1];
11494 if (i2 >= 0 && i2 < var2ndigits)
11495 borrow -= var2digits[i2];
11499 res_digits[
i] = borrow +
NBASE;
11504 res_digits[
i] = borrow;
11512 result->
ndigits = res_ndigits;
11513 result->
buf = res_buf;
11514 result->
digits = res_digits;
11515 result->
weight = res_weight;
11516 result->
dscale = res_dscale;
11560 if (ndigits < var->ndigits ||
11561 (ndigits == var->
ndigits && di > 0))
11565 #if DEC_DIGITS == 1
11577 #if DEC_DIGITS == 4
11579 #elif DEC_DIGITS == 2
11582 #error unsupported NBASE
11584 extra =
digits[--ndigits] % pow10;
11585 digits[ndigits] -= extra;
11587 if (extra >= pow10 / 2)
11589 pow10 +=
digits[ndigits];
11590 if (pow10 >=
NBASE)
11595 digits[ndigits] = pow10;
11603 carry +=
digits[--ndigits];
11604 if (carry >=
NBASE)
11611 digits[ndigits] = carry;
11660 if (ndigits <= var->ndigits)
11664 #if DEC_DIGITS == 1
11677 #if DEC_DIGITS == 4
11679 #elif DEC_DIGITS == 2
11682 #error unsupported NBASE
11684 extra =
digits[--ndigits] % pow10;
11685 digits[ndigits] -= extra;
11704 while (ndigits > 0 && *
digits == 0)
11712 while (ndigits > 0 &&
digits[ndigits - 1] == 0)
11757 int32 *accum_digits;
11786 val_ndigits =
val->ndigits;
11787 val_digits =
val->digits;
11790 for (val_i = 0; val_i < val_ndigits; val_i++)
11792 accum_digits[
i] += (
int32) val_digits[val_i];
11832 for (
i = ndigits - 1;
i >= 0;
i--)
11834 newdig = dig[
i] + carry;
11835 if (newdig >=
NBASE)
11837 carry = newdig /
NBASE;
11838 newdig -= carry *
NBASE;
11851 for (
i = ndigits - 1;
i >= 0;
i--)
11853 newdig = dig[
i] + carry;
11854 if (newdig >=
NBASE)
11856 carry = newdig /
NBASE;
11857 newdig -= carry *
NBASE;
11878 int old_weight = accum->
weight;
11879 int old_ndigits = accum->
ndigits;
11885 accum_weight = old_weight;
11886 accum_ndigits = old_ndigits;
11897 if (
val->weight >= accum_weight)
11899 accum_weight =
val->weight + 1;
11900 accum_ndigits = accum_ndigits + (accum_weight - old_weight);
11915 accum_rscale = accum_ndigits - accum_weight - 1;
11916 val_rscale =
val->ndigits -
val->weight - 1;
11917 if (val_rscale > accum_rscale)
11918 accum_ndigits = accum_ndigits + (val_rscale - accum_rscale);
11920 if (accum_ndigits != old_ndigits ||
11921 accum_weight != old_weight)
11923 int32 *new_pos_digits;
11924 int32 *new_neg_digits;
11927 weightdiff = accum_weight - old_weight;
11929 new_pos_digits =
palloc0(accum_ndigits *
sizeof(
int32));
11930 new_neg_digits =
palloc0(accum_ndigits *
sizeof(
int32));
11934 memcpy(&new_pos_digits[weightdiff], accum->
pos_digits,
11935 old_ndigits *
sizeof(
int32));
11938 memcpy(&new_neg_digits[weightdiff], accum->
neg_digits,
11939 old_ndigits *
sizeof(
int32));
11946 accum->
weight = accum_weight;
11947 accum->
ndigits = accum_ndigits;
12003 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)
Datum float4_numeric(PG_FUNCTION_ARGS)
Datum numeric_poly_stddev_samp(PG_FUNCTION_ARGS)
static void add_abs(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
Datum generate_series_step_numeric(PG_FUNCTION_ARGS)
Datum numeric_int8(PG_FUNCTION_ARGS)
static void do_numeric_accum(NumericAggState *state, Numeric newval)
Datum int4_numeric(PG_FUNCTION_ARGS)
Datum numeric_sum(PG_FUNCTION_ARGS)
Datum numeric_ge(PG_FUNCTION_ARGS)
static const NumericVar const_ninf
Datum numeric_uplus(PG_FUNCTION_ARGS)
Datum numeric_stddev_pop(PG_FUNCTION_ARGS)
Datum numeric_uminus(PG_FUNCTION_ARGS)
static void add_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static Datum numeric_abbrev_convert(Datum original_datum, SortSupport ssup)
#define NUMERIC_IS_SPECIAL(n)
#define NA_TOTAL_COUNT(na)
Datum numeric_le(PG_FUNCTION_ARGS)
Datum numeric_ceil(PG_FUNCTION_ARGS)
Datum numeric_send(PG_FUNCTION_ARGS)
struct Int8TransTypeData Int8TransTypeData
static void gcd_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static bool set_var_from_non_decimal_integer_str(const char *str, const char *cp, int sign, int base, NumericVar *dest, const char **endptr, Node *escontext)
Datum numerictypmodin(PG_FUNCTION_ARGS)
Datum in_range_numeric_numeric(PG_FUNCTION_ARGS)
Datum numeric_power(PG_FUNCTION_ARGS)
Numeric int64_div_fast_to_numeric(int64 val1, int log10val2)
static const NumericVar const_minus_one
static void div_var_fast(const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale, bool round)
static bool numericvar_to_int32(const NumericVar *var, int32 *result)
static int numeric_fast_cmp(Datum x, Datum y, SortSupport ssup)
static void floor_var(const NumericVar *var, NumericVar *result)
Datum numeric_int4(PG_FUNCTION_ARGS)
Datum numeric_gcd(PG_FUNCTION_ARGS)
static void compute_bucket(Numeric operand, Numeric bound1, Numeric bound2, const NumericVar *count_var, bool reversed_bounds, NumericVar *result_var)
static const NumericDigit const_one_data[1]
Datum numeric_poly_combine(PG_FUNCTION_ARGS)
static void init_var_from_num(Numeric num, NumericVar *dest)
static const NumericDigit const_two_data[1]
Datum numeric_fac(PG_FUNCTION_ARGS)
Datum numeric_serialize(PG_FUNCTION_ARGS)
#define NUMERIC_SHORT_WEIGHT_MASK
#define NUMERIC_IS_PINF(n)
static void zero_var(NumericVar *var)
Datum numeric_ne(PG_FUNCTION_ARGS)
#define NUMERIC_SHORT_WEIGHT_SIGN_MASK
Datum numeric(PG_FUNCTION_ARGS)
Datum int4_avg_accum_inv(PG_FUNCTION_ARGS)
static bool do_numeric_discard(NumericAggState *state, Numeric newval)
Datum int8_avg_serialize(PG_FUNCTION_ARGS)
Datum numeric_exp(PG_FUNCTION_ARGS)
static int numeric_cmp_abbrev(Datum x, Datum y, SortSupport ssup)
Datum numeric_log(PG_FUNCTION_ARGS)
static void mul_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale)
Datum numeric_scale(PG_FUNCTION_ARGS)
static Numeric make_result_opt_error(const NumericVar *var, bool *have_error)
Datum numeric_sqrt(PG_FUNCTION_ARGS)
static bool apply_typmod_special(Numeric num, int32 typmod, Node *escontext)
Datum int4_accum_inv(PG_FUNCTION_ARGS)
Datum numeric_poly_deserialize(PG_FUNCTION_ARGS)
#define NUMERIC_IS_INF(n)
Datum numeric_inc(PG_FUNCTION_ARGS)
static char * get_str_from_var(const NumericVar *var)
Datum int8_avg_accum_inv(PG_FUNCTION_ARGS)
Datum int4_accum(PG_FUNCTION_ARGS)
Datum generate_series_numeric(PG_FUNCTION_ARGS)
#define NUMERIC_ABBREV_PINF
Datum numeric_out(PG_FUNCTION_ARGS)
Datum numeric_int2(PG_FUNCTION_ARGS)
int64 numeric_int8_opt_error(Numeric num, bool *have_error)
#define digitbuf_alloc(ndigits)
struct NumericAggState NumericAggState
static void sqrt_var(const NumericVar *arg, NumericVar *result, int rscale)
Datum numeric_trunc(PG_FUNCTION_ARGS)
static bool set_var_from_str(const char *str, const char *cp, NumericVar *dest, const char **endptr, Node *escontext)
static int estimate_ln_dweight(const NumericVar *var)
Datum numeric_lcm(PG_FUNCTION_ARGS)
static int cmp_var(const NumericVar *var1, const NumericVar *var2)
Datum numeric_div_trunc(PG_FUNCTION_ARGS)
static int numeric_sign_internal(Numeric num)
Datum int8_accum(PG_FUNCTION_ARGS)
static int select_div_scale(const NumericVar *var1, const NumericVar *var2)
Datum numeric_avg_deserialize(PG_FUNCTION_ARGS)
#define NUMERIC_ABBREV_NAN
static int cmp_abs_common(const NumericDigit *var1digits, int var1ndigits, int var1weight, const NumericDigit *var2digits, int var2ndigits, int var2weight)
Datum numeric_poly_stddev_pop(PG_FUNCTION_ARGS)
static bool apply_typmod(NumericVar *var, int32 typmod, Node *escontext)
#define NUMERIC_IS_NINF(n)
Datum numeric_float8(PG_FUNCTION_ARGS)
Datum int2_avg_accum_inv(PG_FUNCTION_ARGS)
static const NumericVar const_zero_point_nine
static int cmp_abs(const NumericVar *var1, const NumericVar *var2)
static const NumericVar const_zero
Datum numeric_in(PG_FUNCTION_ARGS)
#define NUMERIC_ABBREV_NINF
static void accum_sum_combine(NumericSumAccum *accum, NumericSumAccum *accum2)
static void numericvar_deserialize(StringInfo buf, NumericVar *var)
static const int round_powers[4]
Datum numeric_mod(PG_FUNCTION_ARGS)
struct NumericSumAccum NumericSumAccum
bool numeric_is_nan(Numeric num)
#define NUMERIC_SIGN_MASK
Datum numeric_lt(PG_FUNCTION_ARGS)
static void div_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale, bool round)
#define NUMERIC_DSCALE_MASK
Numeric numeric_sub_opt_error(Numeric num1, Numeric num2, bool *have_error)
Datum numeric_var_samp(PG_FUNCTION_ARGS)
Datum numeric_sortsupport(PG_FUNCTION_ARGS)
Numeric numeric_mul_opt_error(Numeric num1, Numeric num2, bool *have_error)
struct NumericVar NumericVar
static void int64_to_numericvar(int64 val, NumericVar *var)
Datum int8_avg_deserialize(PG_FUNCTION_ARGS)
static bool numericvar_to_int64(const NumericVar *var, int64 *result)
Datum numeric_float8_no_overflow(PG_FUNCTION_ARGS)
Datum numeric_combine(PG_FUNCTION_ARGS)
Datum int8_avg_combine(PG_FUNCTION_ARGS)
Datum int8_avg_accum(PG_FUNCTION_ARGS)
Datum numeric_sign(PG_FUNCTION_ARGS)
Datum int2_numeric(PG_FUNCTION_ARGS)
static int numeric_typmod_precision(int32 typmod)
#define NUMERIC_DSCALE_MAX
Datum int4_sum(PG_FUNCTION_ARGS)
static void alloc_var(NumericVar *var, int ndigits)
static int xdigit_value(char dig)
static Numeric make_result(const NumericVar *var)
static const NumericDigit const_one_point_one_data[2]
#define NUMERIC_SHORT_DSCALE_MASK
#define NumericAbbrevGetDatum(X)
#define NUMERIC_SHORT_DSCALE_SHIFT
static void accum_sum_reset(NumericSumAccum *accum)
#define NUMERIC_WEIGHT(n)
Datum numeric_add(PG_FUNCTION_ARGS)
static void round_var(NumericVar *var, int rscale)
Datum numeric_poly_avg(PG_FUNCTION_ARGS)
Datum numeric_eq(PG_FUNCTION_ARGS)
static void set_var_from_var(const NumericVar *value, NumericVar *dest)
static void log_var(const NumericVar *base, const NumericVar *num, NumericVar *result)
Datum numeric_ln(PG_FUNCTION_ARGS)
#define NUMERIC_SHORT_SIGN_MASK
static bool numericvar_to_uint64(const NumericVar *var, uint64 *result)
Datum numeric_abs(PG_FUNCTION_ARGS)
Datum int8_avg(PG_FUNCTION_ARGS)
Datum numeric_avg_accum(PG_FUNCTION_ARGS)
Datum numeric_larger(PG_FUNCTION_ARGS)
static const NumericVar const_one_point_one
Datum int4_avg_accum(PG_FUNCTION_ARGS)
static void strip_var(NumericVar *var)
static const NumericVar const_nan
#define NUMERIC_IS_SHORT(n)
Datum numeric_smaller(PG_FUNCTION_ARGS)
Datum numeric_gt(PG_FUNCTION_ARGS)
Datum numeric_deserialize(PG_FUNCTION_ARGS)
char * numeric_out_sci(Numeric num, int scale)
#define NUMERIC_DIGITS(num)
Datum int8_numeric(PG_FUNCTION_ARGS)
Datum numeric_mul(PG_FUNCTION_ARGS)
#define NUMERIC_IS_NAN(n)
#define makePolyNumAggStateCurrentContext
static const NumericDigit const_zero_data[1]
static double numericvar_to_double_no_overflow(const NumericVar *var)
Datum numeric_avg_combine(PG_FUNCTION_ARGS)
Datum numeric_min_scale(PG_FUNCTION_ARGS)
Numeric numeric_add_opt_error(Numeric num1, Numeric num2, bool *have_error)
Datum numeric_float4(PG_FUNCTION_ARGS)
Datum numeric_support(PG_FUNCTION_ARGS)
static const NumericVar const_one
#define NUMERIC_NDIGITS(num)
NumericAggState PolyNumAggState
static void accum_sum_rescale(NumericSumAccum *accum, const NumericVar *val)
static int cmp_var_common(const NumericDigit *var1digits, int var1ndigits, int var1weight, int var1sign, const NumericDigit *var2digits, int var2ndigits, int var2weight, int var2sign)
bool numeric_is_inf(Numeric num)
static void ln_var(const NumericVar *arg, NumericVar *result, int rscale)
Datum numeric_pg_lsn(PG_FUNCTION_ARGS)
static void power_ten_int(int exp, NumericVar *result)
static void accum_sum_copy(NumericSumAccum *dst, NumericSumAccum *src)
Datum numeric_floor(PG_FUNCTION_ARGS)
Datum int2_avg_accum(PG_FUNCTION_ARGS)
static void div_mod_var(const NumericVar *var1, const NumericVar *var2, NumericVar *quot, NumericVar *rem)
#define 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)
Assert(fmt[strlen(fmt) - 1] !='\n')
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 MemoryContext MemoryContextSwitchTo(MemoryContext context)
static int list_length(const List *l)
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)
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)