numeric.c File Reference

#include "postgres.h"
#include <ctype.h>
#include <float.h>
#include <limits.h>
#include <math.h>
#include "common/hashfn.h"
#include "common/int.h"
#include "common/int128.h"
#include "funcapi.h"
#include "lib/hyperloglog.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "nodes/supportnodes.h"
#include "optimizer/optimizer.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/numeric.h"
#include "utils/pg_lsn.h"
#include "utils/sortsupport.h"

Include dependency graph for numeric.c:

Go to the source code of this file.

Data Structures
struct	NumericShort
struct	NumericLong
union	NumericChoice
struct	NumericData
struct	NumericVar
struct	generate_series_numeric_fctx
struct	NumericSortSupport
struct	NumericSumAccum
struct	NumericAggState
struct	Int128AggState
struct	Int8TransTypeData

Macros
#define	NBASE   10000
#define	HALF_NBASE   5000
#define	DEC_DIGITS   4 /* decimal digits per NBASE digit */
#define	MUL_GUARD_DIGITS   2 /* these are measured in NBASE digits */
#define	DIV_GUARD_DIGITS   4
#define	NBASE_SQR   (NBASE * NBASE)
#define	NUMERIC_SIGN_MASK   0xC000
#define	NUMERIC_POS   0x0000
#define	NUMERIC_NEG   0x4000
#define	NUMERIC_SHORT   0x8000
#define	NUMERIC_SPECIAL   0xC000
#define	NUMERIC_FLAGBITS(n)   ((n)->choice.n_header & NUMERIC_SIGN_MASK)
#define	NUMERIC_IS_SHORT(n)   (NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)
#define	NUMERIC_IS_SPECIAL(n)   (NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)
#define	NUMERIC_HDRSZ   (VARHDRSZ + sizeof(uint16) + sizeof(int16))
#define	NUMERIC_HDRSZ_SHORT   (VARHDRSZ + sizeof(uint16))
#define	NUMERIC_HEADER_IS_SHORT(n)   (((n)->choice.n_header & 0x8000) != 0)
#define	NUMERIC_HEADER_SIZE(n)
#define	NUMERIC_EXT_SIGN_MASK   0xF000 /* high bits plus NaN/Inf flag bits */
#define	NUMERIC_NAN   0xC000
#define	NUMERIC_PINF   0xD000
#define	NUMERIC_NINF   0xF000
#define	NUMERIC_INF_SIGN_MASK   0x2000
#define	NUMERIC_EXT_FLAGBITS(n)   ((n)->choice.n_header & NUMERIC_EXT_SIGN_MASK)
#define	NUMERIC_IS_NAN(n)   ((n)->choice.n_header == NUMERIC_NAN)
#define	NUMERIC_IS_PINF(n)   ((n)->choice.n_header == NUMERIC_PINF)
#define	NUMERIC_IS_NINF(n)   ((n)->choice.n_header == NUMERIC_NINF)
#define	NUMERIC_IS_INF(n)    (((n)->choice.n_header & ~NUMERIC_INF_SIGN_MASK) == NUMERIC_PINF)
#define	NUMERIC_SHORT_SIGN_MASK   0x2000
#define	NUMERIC_SHORT_DSCALE_MASK   0x1F80
#define	NUMERIC_SHORT_DSCALE_SHIFT   7
#define	NUMERIC_SHORT_DSCALE_MAX    (NUMERIC_SHORT_DSCALE_MASK >> NUMERIC_SHORT_DSCALE_SHIFT)
#define	NUMERIC_SHORT_WEIGHT_SIGN_MASK   0x0040
#define	NUMERIC_SHORT_WEIGHT_MASK   0x003F
#define	NUMERIC_SHORT_WEIGHT_MAX   NUMERIC_SHORT_WEIGHT_MASK
#define	NUMERIC_SHORT_WEIGHT_MIN   (-(NUMERIC_SHORT_WEIGHT_MASK+1))
#define	NUMERIC_DSCALE_MASK   0x3FFF
#define	NUMERIC_DSCALE_MAX   NUMERIC_DSCALE_MASK
#define	NUMERIC_SIGN(n)
#define	NUMERIC_DSCALE(n)
#define	NUMERIC_WEIGHT(n)
#define	NUMERIC_WEIGHT_MAX   PG_INT16_MAX
#define	NumericAbbrevGetDatum(X)   Int64GetDatum(X)
#define	DatumGetNumericAbbrev(X)   DatumGetInt64(X)
#define	NUMERIC_ABBREV_NAN   NumericAbbrevGetDatum(PG_INT64_MIN)
#define	NUMERIC_ABBREV_PINF   NumericAbbrevGetDatum(-PG_INT64_MAX)
#define	NUMERIC_ABBREV_NINF   NumericAbbrevGetDatum(PG_INT64_MAX)
#define	dump_numeric(s, n)
#define	dump_var(s, v)
#define	digitbuf_alloc(ndigits)    ((NumericDigit *) palloc((ndigits) * sizeof(NumericDigit)))
#define	digitbuf_free(buf)
#define	init_var(v)   memset(v, 0, sizeof(NumericVar))
#define	NUMERIC_DIGITS(num)
#define	NUMERIC_NDIGITS(num)    ((VARSIZE(num) - NUMERIC_HEADER_SIZE(num)) / sizeof(NumericDigit))
#define	NUMERIC_CAN_BE_SHORT(scale, weight)
#define	NA_TOTAL_COUNT(na)    ((na)->N + (na)->NaNcount + (na)->pInfcount + (na)->nInfcount)
#define	PRODSUM1(v1, i1, v2, i2)   ((v1)[(i1)] * (v2)[(i2)])
#define	PRODSUM2(v1, i1, v2, i2)   (PRODSUM1(v1,i1,v2,i2) + (v1)[(i1)+1] * (v2)[(i2)-1])
#define	PRODSUM3(v1, i1, v2, i2)   (PRODSUM2(v1,i1,v2,i2) + (v1)[(i1)+2] * (v2)[(i2)-2])
#define	PRODSUM4(v1, i1, v2, i2)   (PRODSUM3(v1,i1,v2,i2) + (v1)[(i1)+3] * (v2)[(i2)-3])
#define	PRODSUM5(v1, i1, v2, i2)   (PRODSUM4(v1,i1,v2,i2) + (v1)[(i1)+4] * (v2)[(i2)-4])
#define	PRODSUM6(v1, i1, v2, i2)   (PRODSUM5(v1,i1,v2,i2) + (v1)[(i1)+5] * (v2)[(i2)-5])

Typedefs
typedef int16	NumericDigit
typedef struct NumericVar	NumericVar
typedef struct NumericSumAccum	NumericSumAccum
typedef struct NumericAggState	NumericAggState
typedef struct Int128AggState	Int128AggState
typedef struct Int8TransTypeData	Int8TransTypeData

Functions
static void	alloc_var (NumericVar *var, int ndigits)
static void	free_var (NumericVar *var)
static void	zero_var (NumericVar *var)
static bool	set_var_from_str (const char *str, const char *cp, NumericVar *dest, const char **endptr, Node *escontext)
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)
static void	set_var_from_num (Numeric num, NumericVar *dest)
static void	init_var_from_num (Numeric num, NumericVar *dest)
static void	set_var_from_var (const NumericVar *value, NumericVar *dest)
static char *	get_str_from_var (const NumericVar *var)
static char *	get_str_from_var_sci (const NumericVar *var, int rscale)
static void	numericvar_serialize (StringInfo buf, const NumericVar *var)
static void	numericvar_deserialize (StringInfo buf, NumericVar *var)
static Numeric	duplicate_numeric (Numeric num)
static Numeric	make_result (const NumericVar *var)
static Numeric	make_result_safe (const NumericVar *var, Node *escontext)
static bool	apply_typmod (NumericVar *var, int32 typmod, Node *escontext)
static bool	apply_typmod_special (Numeric num, int32 typmod, Node *escontext)
static bool	numericvar_to_int32 (const NumericVar *var, int32 *result)
static bool	numericvar_to_int64 (const NumericVar *var, int64 *result)
static void	int64_to_numericvar (int64 val, NumericVar *var)
static bool	numericvar_to_uint64 (const NumericVar *var, uint64 *result)
static void	int128_to_numericvar (INT128 val, NumericVar *var)
static double	numericvar_to_double_no_overflow (const NumericVar *var)
static Datum	numeric_abbrev_convert (Datum original_datum, SortSupport ssup)
static bool	numeric_abbrev_abort (int memtupcount, SortSupport ssup)
static int	numeric_fast_cmp (Datum x, Datum y, SortSupport ssup)
static int	numeric_cmp_abbrev (Datum x, Datum y, SortSupport ssup)
static Datum	numeric_abbrev_convert_var (const NumericVar *var, NumericSortSupport *nss)
static int	cmp_numerics (Numeric num1, Numeric num2)
static int	cmp_var (const NumericVar *var1, const NumericVar *var2)
static int	cmp_var_common (const NumericDigit *var1digits, int var1ndigits, int var1weight, int var1sign, const NumericDigit *var2digits, int var2ndigits, int var2weight, int var2sign)
static void	add_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	sub_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	mul_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale)
static void	mul_var_short (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	div_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale, bool round, bool exact)
static void	div_var_int (const NumericVar *var, int ival, int ival_weight, NumericVar *result, int rscale, bool round)
static int	select_div_scale (const NumericVar *var1, const NumericVar *var2)
static void	mod_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	div_mod_var (const NumericVar *var1, const NumericVar *var2, NumericVar *quot, NumericVar *rem)
static void	ceil_var (const NumericVar *var, NumericVar *result)
static void	floor_var (const NumericVar *var, NumericVar *result)
static void	gcd_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	sqrt_var (const NumericVar *arg, NumericVar *result, int rscale)
static void	exp_var (const NumericVar *arg, NumericVar *result, int rscale)
static int	estimate_ln_dweight (const NumericVar *var)
static void	ln_var (const NumericVar *arg, NumericVar *result, int rscale)
static void	log_var (const NumericVar *base, const NumericVar *num, NumericVar *result)
static void	power_var (const NumericVar *base, const NumericVar *exp, NumericVar *result)
static void	power_var_int (const NumericVar *base, int exp, int exp_dscale, NumericVar *result)
static void	power_ten_int (int exp, NumericVar *result)
static void	random_var (pg_prng_state *state, const NumericVar *rmin, const NumericVar *rmax, NumericVar *result)
static int	cmp_abs (const NumericVar *var1, const NumericVar *var2)
static int	cmp_abs_common (const NumericDigit *var1digits, int var1ndigits, int var1weight, const NumericDigit *var2digits, int var2ndigits, int var2weight)
static void	add_abs (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	sub_abs (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	round_var (NumericVar *var, int rscale)
static void	trunc_var (NumericVar *var, int rscale)
static void	strip_var (NumericVar *var)
static void	compute_bucket (Numeric operand, Numeric bound1, Numeric bound2, const NumericVar *count_var, NumericVar *result_var)
static void	accum_sum_add (NumericSumAccum *accum, const NumericVar *val)
static void	accum_sum_rescale (NumericSumAccum *accum, const NumericVar *val)
static void	accum_sum_carry (NumericSumAccum *accum)
static void	accum_sum_reset (NumericSumAccum *accum)
static void	accum_sum_final (NumericSumAccum *accum, NumericVar *result)
static void	accum_sum_copy (NumericSumAccum *dst, NumericSumAccum *src)
static void	accum_sum_combine (NumericSumAccum *accum, NumericSumAccum *accum2)
Datum	numeric_in (PG_FUNCTION_ARGS)
Datum	numeric_out (PG_FUNCTION_ARGS)
bool	numeric_is_nan (Numeric num)
bool	numeric_is_inf (Numeric num)
static bool	numeric_is_integral (Numeric num)
static int32	make_numeric_typmod (int precision, int scale)
static bool	is_valid_numeric_typmod (int32 typmod)
static int	numeric_typmod_precision (int32 typmod)
static int	numeric_typmod_scale (int32 typmod)
int32	numeric_maximum_size (int32 typmod)
char *	numeric_out_sci (Numeric num, int scale)
char *	numeric_normalize (Numeric num)
Datum	numeric_recv (PG_FUNCTION_ARGS)
Datum	numeric_send (PG_FUNCTION_ARGS)
Datum	numeric_support (PG_FUNCTION_ARGS)
Datum	numeric (PG_FUNCTION_ARGS)
Datum	numerictypmodin (PG_FUNCTION_ARGS)
Datum	numerictypmodout (PG_FUNCTION_ARGS)
Datum	numeric_abs (PG_FUNCTION_ARGS)
Datum	numeric_uminus (PG_FUNCTION_ARGS)
Datum	numeric_uplus (PG_FUNCTION_ARGS)
static int	numeric_sign_internal (Numeric num)
Datum	numeric_sign (PG_FUNCTION_ARGS)
Datum	numeric_round (PG_FUNCTION_ARGS)
Datum	numeric_trunc (PG_FUNCTION_ARGS)
Datum	numeric_ceil (PG_FUNCTION_ARGS)
Datum	numeric_floor (PG_FUNCTION_ARGS)
Datum	generate_series_numeric (PG_FUNCTION_ARGS)
Datum	generate_series_step_numeric (PG_FUNCTION_ARGS)
Datum	generate_series_numeric_support (PG_FUNCTION_ARGS)
Datum	width_bucket_numeric (PG_FUNCTION_ARGS)
Datum	numeric_sortsupport (PG_FUNCTION_ARGS)
Datum	numeric_cmp (PG_FUNCTION_ARGS)
Datum	numeric_eq (PG_FUNCTION_ARGS)
Datum	numeric_ne (PG_FUNCTION_ARGS)
Datum	numeric_gt (PG_FUNCTION_ARGS)
Datum	numeric_ge (PG_FUNCTION_ARGS)
Datum	numeric_lt (PG_FUNCTION_ARGS)
Datum	numeric_le (PG_FUNCTION_ARGS)
Datum	in_range_numeric_numeric (PG_FUNCTION_ARGS)
Datum	hash_numeric (PG_FUNCTION_ARGS)
Datum	hash_numeric_extended (PG_FUNCTION_ARGS)
Datum	numeric_add (PG_FUNCTION_ARGS)
Numeric	numeric_add_safe (Numeric num1, Numeric num2, Node *escontext)
Datum	numeric_sub (PG_FUNCTION_ARGS)
Numeric	numeric_sub_safe (Numeric num1, Numeric num2, Node *escontext)
Datum	numeric_mul (PG_FUNCTION_ARGS)
Numeric	numeric_mul_safe (Numeric num1, Numeric num2, Node *escontext)
Datum	numeric_div (PG_FUNCTION_ARGS)
Numeric	numeric_div_safe (Numeric num1, Numeric num2, Node *escontext)
Datum	numeric_div_trunc (PG_FUNCTION_ARGS)
Datum	numeric_mod (PG_FUNCTION_ARGS)
Numeric	numeric_mod_safe (Numeric num1, Numeric num2, Node *escontext)
Datum	numeric_inc (PG_FUNCTION_ARGS)
Datum	numeric_smaller (PG_FUNCTION_ARGS)
Datum	numeric_larger (PG_FUNCTION_ARGS)
Datum	numeric_gcd (PG_FUNCTION_ARGS)
Datum	numeric_lcm (PG_FUNCTION_ARGS)
Datum	numeric_fac (PG_FUNCTION_ARGS)
Datum	numeric_sqrt (PG_FUNCTION_ARGS)
Datum	numeric_exp (PG_FUNCTION_ARGS)
Datum	numeric_ln (PG_FUNCTION_ARGS)
Datum	numeric_log (PG_FUNCTION_ARGS)
Datum	numeric_power (PG_FUNCTION_ARGS)
Datum	numeric_scale (PG_FUNCTION_ARGS)
static int	get_min_scale (NumericVar *var)
Datum	numeric_min_scale (PG_FUNCTION_ARGS)
Datum	numeric_trim_scale (PG_FUNCTION_ARGS)
Numeric	random_numeric (pg_prng_state *state, Numeric rmin, Numeric rmax)
Numeric	int64_to_numeric (int64 val)
Numeric	int64_div_fast_to_numeric (int64 val1, int log10val2)
Datum	int4_numeric (PG_FUNCTION_ARGS)
int32	numeric_int4_safe (Numeric num, Node *escontext)
Datum	numeric_int4 (PG_FUNCTION_ARGS)
Datum	int8_numeric (PG_FUNCTION_ARGS)
int64	numeric_int8_safe (Numeric num, Node *escontext)
Datum	numeric_int8 (PG_FUNCTION_ARGS)
Datum	int2_numeric (PG_FUNCTION_ARGS)
Datum	numeric_int2 (PG_FUNCTION_ARGS)
Datum	float8_numeric (PG_FUNCTION_ARGS)
Datum	numeric_float8 (PG_FUNCTION_ARGS)
Datum	numeric_float8_no_overflow (PG_FUNCTION_ARGS)
Datum	float4_numeric (PG_FUNCTION_ARGS)
Datum	numeric_float4 (PG_FUNCTION_ARGS)
Datum	numeric_pg_lsn (PG_FUNCTION_ARGS)
static NumericAggState *	makeNumericAggState (FunctionCallInfo fcinfo, bool calcSumX2)
static NumericAggState *	makeNumericAggStateCurrentContext (bool calcSumX2)
static void	do_numeric_accum (NumericAggState *state, Numeric newval)
static bool	do_numeric_discard (NumericAggState *state, Numeric newval)
Datum	numeric_accum (PG_FUNCTION_ARGS)
Datum	numeric_combine (PG_FUNCTION_ARGS)
Datum	numeric_avg_accum (PG_FUNCTION_ARGS)
Datum	numeric_avg_combine (PG_FUNCTION_ARGS)
Datum	numeric_avg_serialize (PG_FUNCTION_ARGS)
Datum	numeric_avg_deserialize (PG_FUNCTION_ARGS)
Datum	numeric_serialize (PG_FUNCTION_ARGS)
Datum	numeric_deserialize (PG_FUNCTION_ARGS)
Datum	numeric_accum_inv (PG_FUNCTION_ARGS)
static Int128AggState *	makeInt128AggState (FunctionCallInfo fcinfo, bool calcSumX2)
static Int128AggState *	makeInt128AggStateCurrentContext (bool calcSumX2)
static void	do_int128_accum (Int128AggState *state, int64 newval)
static void	do_int128_discard (Int128AggState *state, int64 newval)
Datum	int2_accum (PG_FUNCTION_ARGS)
Datum	int4_accum (PG_FUNCTION_ARGS)
Datum	int8_accum (PG_FUNCTION_ARGS)
Datum	numeric_poly_combine (PG_FUNCTION_ARGS)
static void	int128_serialize (StringInfo buf, INT128 val)
static INT128	int128_deserialize (StringInfo buf)
Datum	numeric_poly_serialize (PG_FUNCTION_ARGS)
Datum	numeric_poly_deserialize (PG_FUNCTION_ARGS)
Datum	int8_avg_accum (PG_FUNCTION_ARGS)
Datum	int8_avg_combine (PG_FUNCTION_ARGS)
Datum	int8_avg_serialize (PG_FUNCTION_ARGS)
Datum	int8_avg_deserialize (PG_FUNCTION_ARGS)
Datum	int2_accum_inv (PG_FUNCTION_ARGS)
Datum	int4_accum_inv (PG_FUNCTION_ARGS)
Datum	int8_accum_inv (PG_FUNCTION_ARGS)
Datum	int8_avg_accum_inv (PG_FUNCTION_ARGS)
Datum	numeric_poly_sum (PG_FUNCTION_ARGS)
Datum	numeric_poly_avg (PG_FUNCTION_ARGS)
Datum	numeric_avg (PG_FUNCTION_ARGS)
Datum	numeric_sum (PG_FUNCTION_ARGS)
static Numeric	numeric_stddev_internal (NumericAggState *state, bool variance, bool sample, bool *is_null)
Datum	numeric_var_samp (PG_FUNCTION_ARGS)
Datum	numeric_stddev_samp (PG_FUNCTION_ARGS)
Datum	numeric_var_pop (PG_FUNCTION_ARGS)
Datum	numeric_stddev_pop (PG_FUNCTION_ARGS)
static Numeric	numeric_poly_stddev_internal (Int128AggState *state, bool variance, bool sample, bool *is_null)
Datum	numeric_poly_var_samp (PG_FUNCTION_ARGS)
Datum	numeric_poly_stddev_samp (PG_FUNCTION_ARGS)
Datum	numeric_poly_var_pop (PG_FUNCTION_ARGS)
Datum	numeric_poly_stddev_pop (PG_FUNCTION_ARGS)
Datum	int2_sum (PG_FUNCTION_ARGS)
Datum	int4_sum (PG_FUNCTION_ARGS)
Datum	int8_sum (PG_FUNCTION_ARGS)
Datum	int2_avg_accum (PG_FUNCTION_ARGS)
Datum	int4_avg_accum (PG_FUNCTION_ARGS)
Datum	int4_avg_combine (PG_FUNCTION_ARGS)
Datum	int2_avg_accum_inv (PG_FUNCTION_ARGS)
Datum	int4_avg_accum_inv (PG_FUNCTION_ARGS)
Datum	int8_avg (PG_FUNCTION_ARGS)
Datum	int2int4_sum (PG_FUNCTION_ARGS)
static int	xdigit_value (char dig)

Variables
static const NumericDigit	const_zero_data [1] = {0}
static const NumericVar	const_zero
static const NumericDigit	const_one_data [1] = {1}
static const NumericVar	const_one
static const NumericVar	const_minus_one
static const NumericDigit	const_two_data [1] = {2}
static const NumericVar	const_two
static const NumericDigit	const_zero_point_nine_data [1] = {9000}
static const NumericVar	const_zero_point_nine
static const NumericDigit	const_one_point_one_data [2] = {1, 1000}
static const NumericVar	const_one_point_one
static const NumericVar	const_nan
static const NumericVar	const_pinf
static const NumericVar	const_ninf
static const int	round_powers [4] = {0, 1000, 100, 10}

Macro Definition Documentation

DatumGetNumericAbbrev

#define DatumGetNumericAbbrev

(

X

)

DatumGetInt64(X)

Definition at line 406 of file numeric.c.

DEC_DIGITS

#define DEC_DIGITS   4 /* decimal digits per NBASE digit */

Definition at line 99 of file numeric.c.

digitbuf_alloc

#define digitbuf_alloc

(

ndigits

)

((NumericDigit *) palloc((ndigits) * sizeof(NumericDigit)))

Definition at line 478 of file numeric.c.

digitbuf_free

#define digitbuf_free

(

buf

)

Value:

    do { \
         if ((buf) != NULL) \
             pfree(buf); \
    } while (0)

Definition at line 480 of file numeric.c.

DIV_GUARD_DIGITS

#define DIV_GUARD_DIGITS   4

Definition at line 101 of file numeric.c.

dump_numeric

#define dump_numeric	(		s,
			n
	)

Definition at line 474 of file numeric.c.

dump_var

#define dump_var	(		s,
			v
	)

Definition at line 475 of file numeric.c.

HALF_NBASE

#define HALF_NBASE   5000

Definition at line 98 of file numeric.c.

init_var

#define init_var

(

v

)

memset(v, 0, sizeof(NumericVar))

Definition at line 486 of file numeric.c.

MUL_GUARD_DIGITS

#define MUL_GUARD_DIGITS   2 /* these are measured in NBASE digits */

Definition at line 100 of file numeric.c.

NA_TOTAL_COUNT

#define NA_TOTAL_COUNT

(

na

)

((na)->N + (na)->NaNcount + (na)->pInfcount + (na)->nInfcount)

Definition at line 4738 of file numeric.c.

NBASE

#define NBASE   10000

Definition at line 97 of file numeric.c.

NBASE_SQR

#define NBASE_SQR   (NBASE * NBASE)

Definition at line 106 of file numeric.c.

NUMERIC_ABBREV_NAN

#define NUMERIC_ABBREV_NAN   NumericAbbrevGetDatum(PG_INT64_MIN)

Definition at line 407 of file numeric.c.

NUMERIC_ABBREV_NINF

#define NUMERIC_ABBREV_NINF   NumericAbbrevGetDatum(PG_INT64_MAX)

Definition at line 409 of file numeric.c.

NUMERIC_ABBREV_PINF

#define NUMERIC_ABBREV_PINF   NumericAbbrevGetDatum(-PG_INT64_MAX)

Definition at line 408 of file numeric.c.

NUMERIC_CAN_BE_SHORT

#define NUMERIC_CAN_BE_SHORT	(		scale,
			weight
	)

Value:

    ((scale) <= NUMERIC_SHORT_DSCALE_MAX && \
    (weight) <= NUMERIC_SHORT_WEIGHT_MAX && \
    (weight) >= NUMERIC_SHORT_WEIGHT_MIN)

Definition at line 492 of file numeric.c.

NUMERIC_DIGITS

#define NUMERIC_DIGITS

(

num

)

Value:

    (NUMERIC_HEADER_IS_SHORT(num) ? \
    (num)->choice.n_short.n_data : (num)->choice.n_long.n_data)

Definition at line 488 of file numeric.c.

NUMERIC_DSCALE

#define NUMERIC_DSCALE

(

n

)

Value:

    (NUMERIC_HEADER_IS_SHORT((n)) ? \
    ((n)->choice.n_short.n_header & NUMERIC_SHORT_DSCALE_MASK) \
        >> NUMERIC_SHORT_DSCALE_SHIFT \
    : ((n)->choice.n_long.n_sign_dscale & NUMERIC_DSCALE_MASK))

Definition at line 246 of file numeric.c.

NUMERIC_DSCALE_MASK

#define NUMERIC_DSCALE_MASK   0x3FFF

Definition at line 237 of file numeric.c.

NUMERIC_DSCALE_MAX

#define NUMERIC_DSCALE_MAX   NUMERIC_DSCALE_MASK

Definition at line 238 of file numeric.c.

NUMERIC_EXT_FLAGBITS

#define NUMERIC_EXT_FLAGBITS

(

n

)

((n)->choice.n_header & NUMERIC_EXT_SIGN_MASK)

Definition at line 206 of file numeric.c.

NUMERIC_EXT_SIGN_MASK

#define NUMERIC_EXT_SIGN_MASK   0xF000 /* high bits plus NaN/Inf flag bits */

Definition at line 200 of file numeric.c.

NUMERIC_FLAGBITS

#define NUMERIC_FLAGBITS

(

n

)

((n)->choice.n_header & NUMERIC_SIGN_MASK)

Definition at line 174 of file numeric.c.

NUMERIC_HDRSZ

#define NUMERIC_HDRSZ   (VARHDRSZ + sizeof(uint16) + sizeof(int16))

Definition at line 178 of file numeric.c.

NUMERIC_HDRSZ_SHORT

#define NUMERIC_HDRSZ_SHORT   (VARHDRSZ + sizeof(uint16))

Definition at line 179 of file numeric.c.

NUMERIC_HEADER_IS_SHORT

#define NUMERIC_HEADER_IS_SHORT

(

n

)

(((n)->choice.n_header & 0x8000) != 0)

Definition at line 186 of file numeric.c.

NUMERIC_HEADER_SIZE

#define NUMERIC_HEADER_SIZE

(

n

)

Value:

    (VARHDRSZ + sizeof(uint16) + \
     (NUMERIC_HEADER_IS_SHORT(n) ? 0 : sizeof(int16)))

Definition at line 187 of file numeric.c.

NUMERIC_INF_SIGN_MASK

#define NUMERIC_INF_SIGN_MASK   0x2000

Definition at line 204 of file numeric.c.

NUMERIC_IS_INF

#define NUMERIC_IS_INF

(

n

)

(((n)->choice.n_header & ~NUMERIC_INF_SIGN_MASK) == NUMERIC_PINF)

Definition at line 210 of file numeric.c.

NUMERIC_IS_NAN

#define NUMERIC_IS_NAN

(

n

)

((n)->choice.n_header == NUMERIC_NAN)

Definition at line 207 of file numeric.c.

NUMERIC_IS_NINF

#define NUMERIC_IS_NINF

(

n

)

((n)->choice.n_header == NUMERIC_NINF)

Definition at line 209 of file numeric.c.

NUMERIC_IS_PINF

#define NUMERIC_IS_PINF

(

n

)

((n)->choice.n_header == NUMERIC_PINF)

Definition at line 208 of file numeric.c.

NUMERIC_IS_SHORT

#define NUMERIC_IS_SHORT

(

n

)

(NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)

Definition at line 175 of file numeric.c.

NUMERIC_IS_SPECIAL

#define NUMERIC_IS_SPECIAL

(

n

)

(NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)

Definition at line 176 of file numeric.c.

NUMERIC_NAN

#define NUMERIC_NAN   0xC000

Definition at line 201 of file numeric.c.

NUMERIC_NDIGITS

#define NUMERIC_NDIGITS

(

num

)

((VARSIZE(num) - NUMERIC_HEADER_SIZE(num)) / sizeof(NumericDigit))

Definition at line 490 of file numeric.c.

NUMERIC_NEG

#define NUMERIC_NEG   0x4000

Definition at line 170 of file numeric.c.

NUMERIC_NINF

#define NUMERIC_NINF   0xF000

Definition at line 203 of file numeric.c.

NUMERIC_PINF

#define NUMERIC_PINF   0xD000

Definition at line 202 of file numeric.c.

NUMERIC_POS

#define NUMERIC_POS   0x0000

Definition at line 169 of file numeric.c.

NUMERIC_SHORT

#define NUMERIC_SHORT   0x8000

Definition at line 171 of file numeric.c.

NUMERIC_SHORT_DSCALE_MASK

#define NUMERIC_SHORT_DSCALE_MASK   0x1F80

Definition at line 218 of file numeric.c.

NUMERIC_SHORT_DSCALE_MAX

#define NUMERIC_SHORT_DSCALE_MAX    (NUMERIC_SHORT_DSCALE_MASK >> NUMERIC_SHORT_DSCALE_SHIFT)

Definition at line 220 of file numeric.c.

NUMERIC_SHORT_DSCALE_SHIFT

#define NUMERIC_SHORT_DSCALE_SHIFT   7

Definition at line 219 of file numeric.c.

NUMERIC_SHORT_SIGN_MASK

#define NUMERIC_SHORT_SIGN_MASK   0x2000

Definition at line 217 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MASK

#define NUMERIC_SHORT_WEIGHT_MASK   0x003F

Definition at line 223 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MAX

#define NUMERIC_SHORT_WEIGHT_MAX   NUMERIC_SHORT_WEIGHT_MASK

Definition at line 224 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MIN

#define NUMERIC_SHORT_WEIGHT_MIN   (-(NUMERIC_SHORT_WEIGHT_MASK+1))

Definition at line 225 of file numeric.c.

NUMERIC_SHORT_WEIGHT_SIGN_MASK

#define NUMERIC_SHORT_WEIGHT_SIGN_MASK   0x0040

Definition at line 222 of file numeric.c.

NUMERIC_SIGN

#define NUMERIC_SIGN

(

n

)

Value:

    (NUMERIC_IS_SHORT(n) ? \
        (((n)->choice.n_short.n_header & NUMERIC_SHORT_SIGN_MASK) ? \
         NUMERIC_NEG : NUMERIC_POS) : \
        (NUMERIC_IS_SPECIAL(n) ? \
         NUMERIC_EXT_FLAGBITS(n) : NUMERIC_FLAGBITS(n)))

Definition at line 240 of file numeric.c.

NUMERIC_SIGN_MASK

#define NUMERIC_SIGN_MASK   0xC000

Definition at line 168 of file numeric.c.

NUMERIC_SPECIAL

#define NUMERIC_SPECIAL   0xC000

Definition at line 172 of file numeric.c.

NUMERIC_WEIGHT

#define NUMERIC_WEIGHT

(

n

)

Value:

    (NUMERIC_HEADER_IS_SHORT((n)) ? \
    (((n)->choice.n_short.n_header & NUMERIC_SHORT_WEIGHT_SIGN_MASK ? \
        ~NUMERIC_SHORT_WEIGHT_MASK : 0) \
     | ((n)->choice.n_short.n_header & NUMERIC_SHORT_WEIGHT_MASK)) \
    : ((n)->choice.n_long.n_weight))

Definition at line 250 of file numeric.c.

NUMERIC_WEIGHT_MAX

#define NUMERIC_WEIGHT_MAX   PG_INT16_MAX

Definition at line 261 of file numeric.c.

NumericAbbrevGetDatum

#define NumericAbbrevGetDatum

(

X

)

Int64GetDatum(X)

Definition at line 405 of file numeric.c.

PRODSUM1

#define PRODSUM1	(		v1,
			i1,
			v2,
			i2
	)		((v1)[(i1)] * (v2)[(i2)])

PRODSUM2

#define PRODSUM2	(		v1,
			i1,
			v2,
			i2
	)		(PRODSUM1(v1,i1,v2,i2) + (v1)[(i1)+1] * (v2)[(i2)-1])

PRODSUM3

#define PRODSUM3	(		v1,
			i1,
			v2,
			i2
	)		(PRODSUM2(v1,i1,v2,i2) + (v1)[(i1)+2] * (v2)[(i2)-2])

PRODSUM4

#define PRODSUM4	(		v1,
			i1,
			v2,
			i2
	)		(PRODSUM3(v1,i1,v2,i2) + (v1)[(i1)+3] * (v2)[(i2)-3])

PRODSUM5

#define PRODSUM5	(		v1,
			i1,
			v2,
			i2
	)		(PRODSUM4(v1,i1,v2,i2) + (v1)[(i1)+4] * (v2)[(i2)-4])

PRODSUM6

#define PRODSUM6	(		v1,
			i1,
			v2,
			i2
	)		(PRODSUM5(v1,i1,v2,i2) + (v1)[(i1)+5] * (v2)[(i2)-5])

Typedef Documentation

Int128AggState

typedef struct Int128AggState Int128AggState

Int8TransTypeData

typedef struct Int8TransTypeData Int8TransTypeData

NumericAggState

typedef struct NumericAggState NumericAggState

NumericDigit

typedef int16 NumericDigit

Definition at line 103 of file numeric.c.

NumericSumAccum

typedef struct NumericSumAccum NumericSumAccum

NumericVar

typedef struct NumericVar NumericVar

Function Documentation

accum_sum_add()

static void accum_sum_add ( NumericSumAccum *  accum, const NumericVar *  val  )

static

Definition at line 11846 of file numeric.c.

{
    int32      *accum_digits;
    int         i,
                val_i;
    int         val_ndigits;
    NumericDigit *val_digits;
 
    /*
     * If we have accumulated too many values since the last carry
     * propagation, do it now, to avoid overflowing.  (We could allow more
     * than NBASE - 1, if we reserved two extra digits, rather than one, for
     * carry propagation.  But even with NBASE - 1, this needs to be done so
     * seldom, that the performance difference is negligible.)
     */
    if (accum->num_uncarried == NBASE - 1)
        accum_sum_carry(accum);
 
    /*
     * Adjust the weight or scale of the old value, so that it can accommodate
     * the new value.
     */
    accum_sum_rescale(accum, val);
 
    /* */
    if (val->sign == NUMERIC_POS)
        accum_digits = accum->pos_digits;
    else
        accum_digits = accum->neg_digits;
 
    /* copy these values into local vars for speed in loop */
    val_ndigits = val->ndigits;
    val_digits = val->digits;
 
    i = accum->weight - val->weight;
    for (val_i = 0; val_i < val_ndigits; val_i++)
    {
        accum_digits[i] += (int32) val_digits[val_i];
        i++;
    }
 
    accum->num_uncarried++;
}

References accum_sum_carry(), accum_sum_rescale(), i, NBASE, NumericSumAccum::neg_digits, NumericSumAccum::num_uncarried, NUMERIC_POS, NumericSumAccum::pos_digits, val, and NumericSumAccum::weight.

Referenced by accum_sum_combine(), do_numeric_accum(), do_numeric_discard(), numeric_avg_deserialize(), numeric_deserialize(), and numeric_poly_stddev_internal().

accum_sum_carry()

static void accum_sum_carry ( NumericSumAccum *  accum )

static

Definition at line 11894 of file numeric.c.

{
    int         i;
    int         ndigits;
    int32      *dig;
    int32       carry;
    int32       newdig = 0;
 
    /*
     * If no new values have been added since last carry propagation, nothing
     * to do.
     */
    if (accum->num_uncarried == 0)
        return;
 
    /*
     * We maintain that the weight of the accumulator is always one larger
     * than needed to hold the current value, before carrying, to make sure
     * there is enough space for the possible extra digit when carry is
     * propagated.  We cannot expand the buffer here, unless we require
     * callers of accum_sum_final() to switch to the right memory context.
     */
    Assert(accum->pos_digits[0] == 0 && accum->neg_digits[0] == 0);
 
    ndigits = accum->ndigits;
 
    /* Propagate carry in the positive sum */
    dig = accum->pos_digits;
    carry = 0;
    for (i = ndigits - 1; i >= 0; i--)
    {
        newdig = dig[i] + carry;
        if (newdig >= NBASE)
        {
            carry = newdig / NBASE;
            newdig -= carry * NBASE;
        }
        else
            carry = 0;
        dig[i] = newdig;
    }
    /* Did we use up the digit reserved for carry propagation? */
    if (newdig > 0)
        accum->have_carry_space = false;
 
    /* And the same for the negative sum */
    dig = accum->neg_digits;
    carry = 0;
    for (i = ndigits - 1; i >= 0; i--)
    {
        newdig = dig[i] + carry;
        if (newdig >= NBASE)
        {
            carry = newdig / NBASE;
            newdig -= carry * NBASE;
        }
        else
            carry = 0;
        dig[i] = newdig;
    }
    if (newdig > 0)
        accum->have_carry_space = false;
 
    accum->num_uncarried = 0;
}

References Assert(), NumericSumAccum::have_carry_space, i, NBASE, NumericSumAccum::ndigits, NumericSumAccum::neg_digits, NumericSumAccum::num_uncarried, and NumericSumAccum::pos_digits.

Referenced by accum_sum_add(), and accum_sum_final().

accum_sum_combine()

static void accum_sum_combine ( NumericSumAccum *  accum, NumericSumAccum *  accum2  )

static

Definition at line 12124 of file numeric.c.

{
    NumericVar  tmp_var;
 
    init_var(&tmp_var);
 
    accum_sum_final(accum2, &tmp_var);
    accum_sum_add(accum, &tmp_var);
 
    free_var(&tmp_var);
}

References accum_sum_add(), accum_sum_final(), free_var(), and init_var.

Referenced by numeric_avg_combine(), and numeric_combine().

accum_sum_copy()

static void accum_sum_copy ( NumericSumAccum *  dst, NumericSumAccum *  src  )

static

Definition at line 12107 of file numeric.c.

{
    dst->pos_digits = palloc(src->ndigits * sizeof(int32));
    dst->neg_digits = palloc(src->ndigits * sizeof(int32));
 
    memcpy(dst->pos_digits, src->pos_digits, src->ndigits * sizeof(int32));
    memcpy(dst->neg_digits, src->neg_digits, src->ndigits * sizeof(int32));
    dst->num_uncarried = src->num_uncarried;
    dst->ndigits = src->ndigits;
    dst->weight = src->weight;
    dst->dscale = src->dscale;
}

References NumericSumAccum::dscale, NumericSumAccum::ndigits, NumericSumAccum::neg_digits, NumericSumAccum::num_uncarried, palloc(), NumericSumAccum::pos_digits, and NumericSumAccum::weight.

Referenced by numeric_avg_combine(), and numeric_combine().

accum_sum_final()

static void accum_sum_final ( NumericSumAccum *  accum, NumericVar *  result  )

static

Definition at line 12056 of file numeric.c.

{
    int         i;
    NumericVar  pos_var;
    NumericVar  neg_var;
 
    if (accum->ndigits == 0)
    {
        set_var_from_var(&const_zero, result);
        return;
    }
 
    /* Perform final carry */
    accum_sum_carry(accum);
 
    /* Create NumericVars representing the positive and negative sums */
    init_var(&pos_var);
    init_var(&neg_var);
 
    pos_var.ndigits = neg_var.ndigits = accum->ndigits;
    pos_var.weight = neg_var.weight = accum->weight;
    pos_var.dscale = neg_var.dscale = accum->dscale;
    pos_var.sign = NUMERIC_POS;
    neg_var.sign = NUMERIC_NEG;
 
    pos_var.buf = pos_var.digits = digitbuf_alloc(accum->ndigits);
    neg_var.buf = neg_var.digits = digitbuf_alloc(accum->ndigits);
 
    for (i = 0; i < accum->ndigits; i++)
    {
        Assert(accum->pos_digits[i] < NBASE);
        pos_var.digits[i] = (int16) accum->pos_digits[i];
 
        Assert(accum->neg_digits[i] < NBASE);
        neg_var.digits[i] = (int16) accum->neg_digits[i];
    }
 
    /* And add them together */
    add_var(&pos_var, &neg_var, result);
 
    /* Remove leading/trailing zeroes */
    strip_var(result);
}

References accum_sum_carry(), add_var(), Assert(), NumericVar::buf, const_zero, digitbuf_alloc, NumericVar::digits, NumericVar::dscale, NumericSumAccum::dscale, i, init_var, NBASE, NumericVar::ndigits, NumericSumAccum::ndigits, NumericSumAccum::neg_digits, NUMERIC_NEG, NUMERIC_POS, NumericSumAccum::pos_digits, set_var_from_var(), NumericVar::sign, strip_var(), NumericVar::weight, and NumericSumAccum::weight.

Referenced by accum_sum_combine(), numeric_avg(), numeric_avg_serialize(), numeric_serialize(), numeric_stddev_internal(), and numeric_sum().

accum_sum_rescale()

static void accum_sum_rescale ( NumericSumAccum *  accum, const NumericVar *  val  )

static

Definition at line 11967 of file numeric.c.

{
    int         old_weight = accum->weight;
    int         old_ndigits = accum->ndigits;
    int         accum_ndigits;
    int         accum_weight;
    int         accum_rscale;
    int         val_rscale;
 
    accum_weight = old_weight;
    accum_ndigits = old_ndigits;
 
    /*
     * Does the new value have a larger weight? If so, enlarge the buffers,
     * and shift the existing value to the new weight, by adding leading
     * zeros.
     *
     * We enforce that the accumulator always has a weight one larger than
     * needed for the inputs, so that we have space for an extra digit at the
     * final carry-propagation phase, if necessary.
     */
    if (val->weight >= accum_weight)
    {
        accum_weight = val->weight + 1;
        accum_ndigits = accum_ndigits + (accum_weight - old_weight);
    }
 
    /*
     * Even though the new value is small, we might've used up the space
     * reserved for the carry digit in the last call to accum_sum_carry().  If
     * so, enlarge to make room for another one.
     */
    else if (!accum->have_carry_space)
    {
        accum_weight++;
        accum_ndigits++;
    }
 
    /* Is the new value wider on the right side? */
    accum_rscale = accum_ndigits - accum_weight - 1;
    val_rscale = val->ndigits - val->weight - 1;
    if (val_rscale > accum_rscale)
        accum_ndigits = accum_ndigits + (val_rscale - accum_rscale);
 
    if (accum_ndigits != old_ndigits ||
        accum_weight != old_weight)
    {
        int32      *new_pos_digits;
        int32      *new_neg_digits;
        int         weightdiff;
 
        weightdiff = accum_weight - old_weight;
 
        new_pos_digits = palloc0(accum_ndigits * sizeof(int32));
        new_neg_digits = palloc0(accum_ndigits * sizeof(int32));
 
        if (accum->pos_digits)
        {
            memcpy(&new_pos_digits[weightdiff], accum->pos_digits,
                   old_ndigits * sizeof(int32));
            pfree(accum->pos_digits);
 
            memcpy(&new_neg_digits[weightdiff], accum->neg_digits,
                   old_ndigits * sizeof(int32));
            pfree(accum->neg_digits);
        }
 
        accum->pos_digits = new_pos_digits;
        accum->neg_digits = new_neg_digits;
 
        accum->weight = accum_weight;
        accum->ndigits = accum_ndigits;
 
        Assert(accum->pos_digits[0] == 0 && accum->neg_digits[0] == 0);
        accum->have_carry_space = true;
    }
 
    if (val->dscale > accum->dscale)
        accum->dscale = val->dscale;
}

References Assert(), NumericSumAccum::dscale, NumericSumAccum::have_carry_space, NumericSumAccum::ndigits, NumericSumAccum::neg_digits, palloc0(), pfree(), NumericSumAccum::pos_digits, val, and NumericSumAccum::weight.

Referenced by accum_sum_add().

accum_sum_reset()

static void accum_sum_reset ( NumericSumAccum *  accum )

static

Definition at line 11830 of file numeric.c.

{
    int         i;
 
    accum->dscale = 0;
    for (i = 0; i < accum->ndigits; i++)
    {
        accum->pos_digits[i] = 0;
        accum->neg_digits[i] = 0;
    }
}

References NumericSumAccum::dscale, i, NumericSumAccum::ndigits, NumericSumAccum::neg_digits, and NumericSumAccum::pos_digits.

Referenced by do_numeric_discard().

add_abs()

static void add_abs ( const NumericVar *  var1, const NumericVar *  var2, NumericVar *  result  )

static

Definition at line 11454 of file numeric.c.

{
    NumericDigit *res_buf;
    NumericDigit *res_digits;
    int         res_ndigits;
    int         res_weight;
    int         res_rscale,
                rscale1,
                rscale2;
    int         res_dscale;
    int         i,
                i1,
                i2;
    int         carry = 0;
 
    /* copy these values into local vars for speed in inner loop */
    int         var1ndigits = var1->ndigits;
    int         var2ndigits = var2->ndigits;
    NumericDigit *var1digits = var1->digits;
    NumericDigit *var2digits = var2->digits;
 
    res_weight = Max(var1->weight, var2->weight) + 1;
 
    res_dscale = Max(var1->dscale, var2->dscale);
 
    /* Note: here we are figuring rscale in base-NBASE digits */
    rscale1 = var1->ndigits - var1->weight - 1;
    rscale2 = var2->ndigits - var2->weight - 1;
    res_rscale = Max(rscale1, rscale2);
 
    res_ndigits = res_rscale + res_weight + 1;
    if (res_ndigits <= 0)
        res_ndigits = 1;
 
    res_buf = digitbuf_alloc(res_ndigits + 1);
    res_buf[0] = 0;             /* spare digit for later rounding */
    res_digits = res_buf + 1;
 
    i1 = res_rscale + var1->weight + 1;
    i2 = res_rscale + var2->weight + 1;
    for (i = res_ndigits - 1; i >= 0; i--)
    {
        i1--;
        i2--;
        if (i1 >= 0 && i1 < var1ndigits)
            carry += var1digits[i1];
        if (i2 >= 0 && i2 < var2ndigits)
            carry += var2digits[i2];
 
        if (carry >= NBASE)
        {
            res_digits[i] = carry - NBASE;
            carry = 1;
        }
        else
        {
            res_digits[i] = carry;
            carry = 0;
        }
    }
 
    Assert(carry == 0);         /* else we failed to allow for carry out */
 
    digitbuf_free(result->buf);
    result->ndigits = res_ndigits;
    result->buf = res_buf;
    result->digits = res_digits;
    result->weight = res_weight;
    result->dscale = res_dscale;
 
    /* Remove leading/trailing zeroes */
    strip_var(result);
}

References Assert(), NumericVar::buf, digitbuf_alloc, digitbuf_free, NumericVar::digits, NumericVar::dscale, i, Max, NBASE, NumericVar::ndigits, strip_var(), and NumericVar::weight.

Referenced by add_var(), and sub_var().

add_var()

static void add_var ( const NumericVar *  var1, const NumericVar *  var2, NumericVar *  result  )

static

Definition at line 8062 of file numeric.c.

{
    /*
     * Decide on the signs of the two variables what to do
     */
    if (var1->sign == NUMERIC_POS)
    {
        if (var2->sign == NUMERIC_POS)
        {
            /*
             * Both are positive result = +(ABS(var1) + ABS(var2))
             */
            add_abs(var1, var2, result);
            result->sign = NUMERIC_POS;
        }
        else
        {
            /*
             * var1 is positive, var2 is negative Must compare absolute values
             */
            switch (cmp_abs(var1, var2))
            {
                case 0:
                    /* ----------
                     * ABS(var1) == ABS(var2)
                     * result = ZERO
                     * ----------
                     */
                    zero_var(result);
                    result->dscale = Max(var1->dscale, var2->dscale);
                    break;
 
                case 1:
                    /* ----------
                     * ABS(var1) > ABS(var2)
                     * result = +(ABS(var1) - ABS(var2))
                     * ----------
                     */
                    sub_abs(var1, var2, result);
                    result->sign = NUMERIC_POS;
                    break;
 
                case -1:
                    /* ----------
                     * ABS(var1) < ABS(var2)
                     * result = -(ABS(var2) - ABS(var1))
                     * ----------
                     */
                    sub_abs(var2, var1, result);
                    result->sign = NUMERIC_NEG;
                    break;
            }
        }
    }
    else
    {
        if (var2->sign == NUMERIC_POS)
        {
            /* ----------
             * var1 is negative, var2 is positive
             * Must compare absolute values
             * ----------
             */
            switch (cmp_abs(var1, var2))
            {
                case 0:
                    /* ----------
                     * ABS(var1) == ABS(var2)
                     * result = ZERO
                     * ----------
                     */
                    zero_var(result);
                    result->dscale = Max(var1->dscale, var2->dscale);
                    break;
 
                case 1:
                    /* ----------
                     * ABS(var1) > ABS(var2)
                     * result = -(ABS(var1) - ABS(var2))
                     * ----------
                     */
                    sub_abs(var1, var2, result);
                    result->sign = NUMERIC_NEG;
                    break;
 
                case -1:
                    /* ----------
                     * ABS(var1) < ABS(var2)
                     * result = +(ABS(var2) - ABS(var1))
                     * ----------
                     */
                    sub_abs(var2, var1, result);
                    result->sign = NUMERIC_POS;
                    break;
            }
        }
        else
        {
            /* ----------
             * Both are negative
             * result = -(ABS(var1) + ABS(var2))
             * ----------
             */
            add_abs(var1, var2, result);
            result->sign = NUMERIC_NEG;
        }
    }
}

References add_abs(), cmp_abs(), NumericVar::dscale, Max, NUMERIC_NEG, NUMERIC_POS, NumericVar::sign, sub_abs(), and zero_var().

Referenced by accum_sum_final(), ceil_var(), compute_bucket(), div_mod_var(), exp_var(), generate_series_step_numeric(), in_range_numeric_numeric(), ln_var(), numeric_add_safe(), numeric_inc(), random_var(), set_var_from_non_decimal_integer_str(), sqrt_var(), and width_bucket_numeric().

alloc_var()

static void alloc_var ( NumericVar *  var, int  ndigits  )

static

Definition at line 6684 of file numeric.c.

{
    digitbuf_free(var->buf);
    var->buf = digitbuf_alloc(ndigits + 1);
    var->buf[0] = 0;            /* spare digit for rounding */
    var->digits = var->buf + 1;
    var->ndigits = ndigits;
}

References NumericVar::buf, digitbuf_alloc, digitbuf_free, NumericVar::digits, and NumericVar::ndigits.

Referenced by div_var(), int128_to_numericvar(), int64_to_numericvar(), mul_var(), numeric_recv(), numericvar_deserialize(), random_var(), set_var_from_num(), set_var_from_str(), and sqrt_var().

apply_typmod()

static bool apply_typmod ( NumericVar *  var, int32  typmod, Node *  escontext  )

static

Definition at line 7622 of file numeric.c.

{
    int         precision;
    int         scale;
    int         maxdigits;
    int         ddigits;
    int         i;
 
    /* Do nothing if we have an invalid typmod */
    if (!is_valid_numeric_typmod(typmod))
        return true;
 
    precision = numeric_typmod_precision(typmod);
    scale = numeric_typmod_scale(typmod);
    maxdigits = precision - scale;
 
    /* Round to target scale (and set var->dscale) */
    round_var(var, scale);
 
    /* but don't allow var->dscale to be negative */
    if (var->dscale < 0)
        var->dscale = 0;
 
    /*
     * Check for overflow - note we can't do this before rounding, because
     * rounding could raise the weight.  Also note that the var's weight could
     * be inflated by leading zeroes, which will be stripped before storage
     * but perhaps might not have been yet. In any case, we must recognize a
     * true zero, whose weight doesn't mean anything.
     */
    ddigits = (var->weight + 1) * DEC_DIGITS;
    if (ddigits > maxdigits)
    {
        /* Determine true weight; and check for all-zero result */
        for (i = 0; i < var->ndigits; i++)
        {
            NumericDigit dig = var->digits[i];
 
            if (dig)
            {
                /* Adjust for any high-order decimal zero digits */
#if DEC_DIGITS == 4
                if (dig < 10)
                    ddigits -= 3;
                else if (dig < 100)
                    ddigits -= 2;
                else if (dig < 1000)
                    ddigits -= 1;
#elif DEC_DIGITS == 2
                if (dig < 10)
                    ddigits -= 1;
#elif DEC_DIGITS == 1
                /* no adjustment */
#else
#error unsupported NBASE
#endif
                if (ddigits > maxdigits)
                    ereturn(escontext, false,
                            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                             errmsg("numeric field overflow"),
                             errdetail("A field with precision %d, scale %d must round to an absolute value less than %s%d.",
                                       precision, scale,
                    /* Display 10^0 as 1 */
                                       maxdigits ? "10^" : "",
                                       maxdigits ? maxdigits : 1
                                       )));
                break;
            }
            ddigits -= DEC_DIGITS;
        }
    }
 
    return true;
}

References DEC_DIGITS, NumericVar::digits, NumericVar::dscale, ereturn, errcode(), errdetail(), errmsg(), i, is_valid_numeric_typmod(), maxdigits, NumericVar::ndigits, numeric_typmod_precision(), numeric_typmod_scale(), round_var(), scale, and NumericVar::weight.

Referenced by numeric(), numeric_in(), and numeric_recv().

apply_typmod_special()

static bool apply_typmod_special ( Numeric  num, int32  typmod, Node *  escontext  )

static

Definition at line 7707 of file numeric.c.

{
    int         precision;
    int         scale;
 
    Assert(NUMERIC_IS_SPECIAL(num));    /* caller error if not */
 
    /*
     * NaN is allowed regardless of the typmod; that's rather dubious perhaps,
     * but it's a longstanding behavior.  Inf is rejected if we have any
     * typmod restriction, since an infinity shouldn't be claimed to fit in
     * any finite number of digits.
     */
    if (NUMERIC_IS_NAN(num))
        return true;
 
    /* Do nothing if we have a default typmod (-1) */
    if (!is_valid_numeric_typmod(typmod))
        return true;
 
    precision = numeric_typmod_precision(typmod);
    scale = numeric_typmod_scale(typmod);
 
    ereturn(escontext, false,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("numeric field overflow"),
             errdetail("A field with precision %d, scale %d cannot hold an infinite value.",
                       precision, scale)));
}

References Assert(), ereturn, errcode(), errdetail(), errmsg(), is_valid_numeric_typmod(), NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, numeric_typmod_precision(), numeric_typmod_scale(), and scale.

Referenced by numeric(), numeric_in(), and numeric_recv().

ceil_var()

static void ceil_var ( const NumericVar *  var, NumericVar *  result  )

static

Definition at line 9815 of file numeric.c.

{
    NumericVar  tmp;
 
    init_var(&tmp);
    set_var_from_var(var, &tmp);
 
    trunc_var(&tmp, 0);
 
    if (var->sign == NUMERIC_POS && cmp_var(var, &tmp) != 0)
        add_var(&tmp, &const_one, &tmp);
 
    set_var_from_var(&tmp, result);
    free_var(&tmp);
}

References add_var(), cmp_var(), const_one, free_var(), init_var, NUMERIC_POS, set_var_from_var(), NumericVar::sign, and trunc_var().

Referenced by numeric_ceil().

cmp_abs()

static int cmp_abs ( const NumericVar *  var1, const NumericVar *  var2  )

static

Definition at line 11376 of file numeric.c.

{
    return cmp_abs_common(var1->digits, var1->ndigits, var1->weight,
                          var2->digits, var2->ndigits, var2->weight);
}

References cmp_abs_common(), NumericVar::digits, NumericVar::ndigits, and NumericVar::weight.

Referenced by add_var(), div_mod_var(), gcd_var(), and sub_var().

cmp_abs_common()

static int cmp_abs_common ( const NumericDigit *  var1digits, int  var1ndigits, int  var1weight, const NumericDigit *  var2digits, int  var2ndigits, int  var2weight  )

static

Definition at line 11390 of file numeric.c.

{
    int         i1 = 0;
    int         i2 = 0;
 
    /* Check any digits before the first common digit */
 
    while (var1weight > var2weight && i1 < var1ndigits)
    {
        if (var1digits[i1++] != 0)
            return 1;
        var1weight--;
    }
    while (var2weight > var1weight && i2 < var2ndigits)
    {
        if (var2digits[i2++] != 0)
            return -1;
        var2weight--;
    }
 
    /* At this point, either w1 == w2 or we've run out of digits */
 
    if (var1weight == var2weight)
    {
        while (i1 < var1ndigits && i2 < var2ndigits)
        {
            int         stat = var1digits[i1++] - var2digits[i2++];
 
            if (stat)
            {
                if (stat > 0)
                    return 1;
                return -1;
            }
        }
    }
 
    /*
     * At this point, we've run out of digits on one side or the other; so any
     * remaining nonzero digits imply that side is larger
     */
    while (i1 < var1ndigits)
    {
        if (var1digits[i1++] != 0)
            return 1;
    }
    while (i2 < var2ndigits)
    {
        if (var2digits[i2++] != 0)
            return -1;
    }
 
    return 0;
}

Referenced by cmp_abs(), and cmp_var_common().

cmp_numerics()

static int cmp_numerics ( Numeric  num1, Numeric  num2  )

static

Definition at line 2522 of file numeric.c.

{
    int         result;
 
    /*
     * We consider all NANs to be equal and larger than any non-NAN (including
     * Infinity).  This is somewhat arbitrary; the important thing is to have
     * a consistent sort order.
     */
    if (NUMERIC_IS_SPECIAL(num1))
    {
        if (NUMERIC_IS_NAN(num1))
        {
            if (NUMERIC_IS_NAN(num2))
                result = 0;     /* NAN = NAN */
            else
                result = 1;     /* NAN > non-NAN */
        }
        else if (NUMERIC_IS_PINF(num1))
        {
            if (NUMERIC_IS_NAN(num2))
                result = -1;    /* PINF < NAN */
            else if (NUMERIC_IS_PINF(num2))
                result = 0;     /* PINF = PINF */
            else
                result = 1;     /* PINF > anything else */
        }
        else                    /* num1 must be NINF */
        {
            if (NUMERIC_IS_NINF(num2))
                result = 0;     /* NINF = NINF */
            else
                result = -1;    /* NINF < anything else */
        }
    }
    else if (NUMERIC_IS_SPECIAL(num2))
    {
        if (NUMERIC_IS_NINF(num2))
            result = 1;         /* normal > NINF */
        else
            result = -1;        /* normal < NAN or PINF */
    }
    else
    {
        result = cmp_var_common(NUMERIC_DIGITS(num1), NUMERIC_NDIGITS(num1),
                                NUMERIC_WEIGHT(num1), NUMERIC_SIGN(num1),
                                NUMERIC_DIGITS(num2), NUMERIC_NDIGITS(num2),
                                NUMERIC_WEIGHT(num2), NUMERIC_SIGN(num2));
    }
 
    return result;
}

References cmp_var_common(), NUMERIC_DIGITS, NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, NUMERIC_NDIGITS, NUMERIC_SIGN, and NUMERIC_WEIGHT.

Referenced by numeric_cmp(), numeric_eq(), numeric_fast_cmp(), numeric_ge(), numeric_gt(), numeric_larger(), numeric_le(), numeric_lt(), numeric_ne(), numeric_smaller(), and width_bucket_numeric().

cmp_var()

static int cmp_var ( const NumericVar *  var1, const NumericVar *  var2  )

static

Definition at line 8004 of file numeric.c.

{
    return cmp_var_common(var1->digits, var1->ndigits,
                          var1->weight, var1->sign,
                          var2->digits, var2->ndigits,
                          var2->weight, var2->sign);
}

References cmp_var_common(), NumericVar::digits, NumericVar::ndigits, NumericVar::sign, and NumericVar::weight.

Referenced by ceil_var(), estimate_ln_dweight(), floor_var(), generate_series_numeric_support(), generate_series_step_numeric(), in_range_numeric_numeric(), ln_var(), numeric_power(), numeric_stddev_internal(), power_var(), random_var(), and sqrt_var().

cmp_var_common()

static int cmp_var_common ( const NumericDigit *  var1digits, int  var1ndigits, int  var1weight, int  var1sign, const NumericDigit *  var2digits, int  var2ndigits, int  var2weight, int  var2sign  )

static

Definition at line 8019 of file numeric.c.

{
    if (var1ndigits == 0)
    {
        if (var2ndigits == 0)
            return 0;
        if (var2sign == NUMERIC_NEG)
            return 1;
        return -1;
    }
    if (var2ndigits == 0)
    {
        if (var1sign == NUMERIC_POS)
            return 1;
        return -1;
    }
 
    if (var1sign == NUMERIC_POS)
    {
        if (var2sign == NUMERIC_NEG)
            return 1;
        return cmp_abs_common(var1digits, var1ndigits, var1weight,
                              var2digits, var2ndigits, var2weight);
    }
 
    if (var2sign == NUMERIC_POS)
        return -1;
 
    return cmp_abs_common(var2digits, var2ndigits, var2weight,
                          var1digits, var1ndigits, var1weight);
}

References cmp_abs_common(), NUMERIC_NEG, and NUMERIC_POS.

Referenced by cmp_numerics(), and cmp_var().

compute_bucket()

static void compute_bucket ( Numeric  operand, Numeric  bound1, Numeric  bound2, const NumericVar *  count_var, NumericVar *  result_var  )

static

Definition at line 2035 of file numeric.c.

{
    NumericVar  bound1_var;
    NumericVar  bound2_var;
    NumericVar  operand_var;
 
    init_var_from_num(bound1, &bound1_var);
    init_var_from_num(bound2, &bound2_var);
    init_var_from_num(operand, &operand_var);
 
    /*
     * Per spec, bound1 is inclusive and bound2 is exclusive, and so we have
     * bound1 <= operand < bound2 or bound1 >= operand > bound2.  Either way,
     * the result is ((operand - bound1) * count) / (bound2 - bound1) + 1,
     * where the quotient is computed using floor division (i.e., division to
     * zero decimal places with truncation), which guarantees that the result
     * is in the range [1, count].  Reversing the bounds doesn't affect the
     * computation, because the signs cancel out when dividing.
     */
    sub_var(&operand_var, &bound1_var, &operand_var);
    sub_var(&bound2_var, &bound1_var, &bound2_var);
 
    mul_var(&operand_var, count_var, &operand_var,
            operand_var.dscale + count_var->dscale);
    div_var(&operand_var, &bound2_var, result_var, 0, false, true);
    add_var(result_var, &const_one, result_var);
 
    free_var(&bound1_var);
    free_var(&bound2_var);
    free_var(&operand_var);
}

References add_var(), const_one, div_var(), NumericVar::dscale, free_var(), init_var_from_num(), mul_var(), and sub_var().

Referenced by width_bucket_numeric().

div_mod_var()

static void div_mod_var ( const NumericVar *  var1, const NumericVar *  var2, NumericVar *  quot, NumericVar *  rem  )

static

Definition at line 9745 of file numeric.c.

{
    NumericVar  q;
    NumericVar  r;
 
    init_var(&q);
    init_var(&r);
 
    /*
     * Use div_var() with exact = false to get an initial estimate for the
     * integer quotient (truncated towards zero).  This might be slightly
     * inaccurate, but we correct it below.
     */
    div_var(var1, var2, &q, 0, false, false);
 
    /* Compute initial estimate of remainder using the quotient estimate. */
    mul_var(var2, &q, &r, var2->dscale);
    sub_var(var1, &r, &r);
 
    /*
     * Adjust the results if necessary --- the remainder should have the same
     * sign as var1, and its absolute value should be less than the absolute
     * value of var2.
     */
    while (r.ndigits != 0 && r.sign != var1->sign)
    {
        /* The absolute value of the quotient is too large */
        if (var1->sign == var2->sign)
        {
            sub_var(&q, &const_one, &q);
            add_var(&r, var2, &r);
        }
        else
        {
            add_var(&q, &const_one, &q);
            sub_var(&r, var2, &r);
        }
    }
 
    while (cmp_abs(&r, var2) >= 0)
    {
        /* The absolute value of the quotient is too small */
        if (var1->sign == var2->sign)
        {
            add_var(&q, &const_one, &q);
            sub_var(&r, var2, &r);
        }
        else
        {
            sub_var(&q, &const_one, &q);
            add_var(&r, var2, &r);
        }
    }
 
    set_var_from_var(&q, quot);
    set_var_from_var(&r, rem);
 
    free_var(&q);
    free_var(&r);
}

References add_var(), cmp_abs(), const_one, div_var(), NumericVar::dscale, free_var(), init_var, mul_var(), NumericVar::ndigits, set_var_from_var(), NumericVar::sign, and sub_var().

Referenced by sqrt_var().

div_var()

static void div_var ( const NumericVar *  var1, const NumericVar *  var2, NumericVar *  result, int  rscale, bool  round, bool  exact  )

static

Definition at line 8878 of file numeric.c.

{
    int         var1ndigits = var1->ndigits;
    int         var2ndigits = var2->ndigits;
    int         res_sign;
    int         res_weight;
    int         res_ndigits;
    int         var1ndigitpairs;
    int         var2ndigitpairs;
    int         res_ndigitpairs;
    int         div_ndigitpairs;
    int64      *dividend;
    int32      *divisor;
    double      fdivisor,
                fdivisorinverse,
                fdividend,
                fquotient;
    int64       maxdiv;
    int         qi;
    int32       qdigit;
    int64       carry;
    int64       newdig;
    int64      *remainder;
    NumericDigit *res_digits;
    int         i;
 
    /*
     * First of all division by zero check; we must not be handed an
     * unnormalized divisor.
     */
    if (var2ndigits == 0 || var2->digits[0] == 0)
        ereport(ERROR,
                (errcode(ERRCODE_DIVISION_BY_ZERO),
                 errmsg("division by zero")));
 
    /*
     * If the divisor has just one or two digits, delegate to div_var_int(),
     * which uses fast short division.
     *
     * Similarly, on platforms with 128-bit integer support, delegate to
     * div_var_int64() for divisors with three or four digits.
     */
    if (var2ndigits <= 2)
    {
        int         idivisor;
        int         idivisor_weight;
 
        idivisor = var2->digits[0];
        idivisor_weight = var2->weight;
        if (var2ndigits == 2)
        {
            idivisor = idivisor * NBASE + var2->digits[1];
            idivisor_weight--;
        }
        if (var2->sign == NUMERIC_NEG)
            idivisor = -idivisor;
 
        div_var_int(var1, idivisor, idivisor_weight, result, rscale, round);
        return;
    }
#ifdef HAVE_INT128
    if (var2ndigits <= 4)
    {
        int64       idivisor;
        int         idivisor_weight;
 
        idivisor = var2->digits[0];
        idivisor_weight = var2->weight;
        for (i = 1; i < var2ndigits; i++)
        {
            idivisor = idivisor * NBASE + var2->digits[i];
            idivisor_weight--;
        }
        if (var2->sign == NUMERIC_NEG)
            idivisor = -idivisor;
 
        div_var_int64(var1, idivisor, idivisor_weight, result, rscale, round);
        return;
    }
#endif
 
    /*
     * Otherwise, perform full long division.
     */
 
    /* Result zero check */
    if (var1ndigits == 0)
    {
        zero_var(result);
        result->dscale = rscale;
        return;
    }
 
    /*
     * The approximate computation can be significantly faster than the exact
     * one, since the working dividend is var2ndigitpairs base-NBASE^2 digits
     * shorter below.  However, that comes with the tradeoff of computing
     * DIV_GUARD_DIGITS extra base-NBASE result digits.  Ignoring all other
     * overheads, that suggests that, in theory, the approximate computation
     * will only be faster than the exact one when var2ndigits is greater than
     * 2 * (DIV_GUARD_DIGITS + 1), independent of the size of var1.
     *
     * Thus, we're better off doing an exact computation when var2 is shorter
     * than this.  Empirically, it has been found that the exact threshold is
     * a little higher, due to other overheads in the outer division loop.
     */
    if (var2ndigits <= 2 * (DIV_GUARD_DIGITS + 2))
        exact = true;
 
    /*
     * Determine the result sign, weight and number of digits to calculate.
     * The weight figured here is correct if the emitted quotient has no
     * leading zero digits; otherwise strip_var() will fix things up.
     */
    if (var1->sign == var2->sign)
        res_sign = NUMERIC_POS;
    else
        res_sign = NUMERIC_NEG;
    res_weight = var1->weight - var2->weight + 1;
    /* The number of accurate result digits we need to produce: */
    res_ndigits = res_weight + 1 + (rscale + DEC_DIGITS - 1) / DEC_DIGITS;
    /* ... but always at least 1 */
    res_ndigits = Max(res_ndigits, 1);
    /* If rounding needed, figure one more digit to ensure correct result */
    if (round)
        res_ndigits++;
    /* Add guard digits for roundoff error when producing approx result */
    if (!exact)
        res_ndigits += DIV_GUARD_DIGITS;
 
    /*
     * The computation itself is done using base-NBASE^2 arithmetic, so we
     * actually process the input digits in pairs, producing a base-NBASE^2
     * intermediate result.  This significantly improves performance, since
     * the computation is O(N^2) in the number of input digits, and working in
     * base NBASE^2 effectively halves "N".
     */
    var1ndigitpairs = (var1ndigits + 1) / 2;
    var2ndigitpairs = (var2ndigits + 1) / 2;
    res_ndigitpairs = (res_ndigits + 1) / 2;
    res_ndigits = 2 * res_ndigitpairs;
 
    /*
     * We do the arithmetic in an array "dividend[]" of signed 64-bit
     * integers.  Since PG_INT64_MAX is much larger than NBASE^4, this gives
     * us a lot of headroom to avoid normalizing carries immediately.
     *
     * When performing an exact computation, the working dividend requires
     * res_ndigitpairs + var2ndigitpairs digits.  If var1 is larger than that,
     * the extra digits do not contribute to the result, and are ignored.
     *
     * When performing an approximate computation, the working dividend only
     * requires res_ndigitpairs digits (which includes the extra guard
     * digits).  All input digits beyond that are ignored.
     */
    if (exact)
    {
        div_ndigitpairs = res_ndigitpairs + var2ndigitpairs;
        var1ndigitpairs = Min(var1ndigitpairs, div_ndigitpairs);
    }
    else
    {
        div_ndigitpairs = res_ndigitpairs;
        var1ndigitpairs = Min(var1ndigitpairs, div_ndigitpairs);
        var2ndigitpairs = Min(var2ndigitpairs, div_ndigitpairs);
    }
 
    /*
     * Allocate room for the working dividend (div_ndigitpairs 64-bit digits)
     * plus the divisor (var2ndigitpairs 32-bit base-NBASE^2 digits).
     *
     * For convenience, we allocate one extra dividend digit, which is set to
     * zero and not counted in div_ndigitpairs, so that the main loop below
     * can safely read and write the (qi+1)'th digit in the approximate case.
     */
    dividend = (int64 *) palloc((div_ndigitpairs + 1) * sizeof(int64) +
                                var2ndigitpairs * sizeof(int32));
    divisor = (int32 *) (dividend + div_ndigitpairs + 1);
 
    /* load var1 into dividend[0 .. var1ndigitpairs-1], zeroing the rest */
    for (i = 0; i < var1ndigitpairs - 1; i++)
        dividend[i] = var1->digits[2 * i] * NBASE + var1->digits[2 * i + 1];
 
    if (2 * i + 1 < var1ndigits)
        dividend[i] = var1->digits[2 * i] * NBASE + var1->digits[2 * i + 1];
    else
        dividend[i] = var1->digits[2 * i] * NBASE;
 
    memset(dividend + i + 1, 0, (div_ndigitpairs - i) * sizeof(int64));
 
    /* load var2 into divisor[0 .. var2ndigitpairs-1] */
    for (i = 0; i < var2ndigitpairs - 1; i++)
        divisor[i] = var2->digits[2 * i] * NBASE + var2->digits[2 * i + 1];
 
    if (2 * i + 1 < var2ndigits)
        divisor[i] = var2->digits[2 * i] * NBASE + var2->digits[2 * i + 1];
    else
        divisor[i] = var2->digits[2 * i] * NBASE;
 
    /*
     * We estimate each quotient digit using floating-point arithmetic, taking
     * the first 2 base-NBASE^2 digits of the (current) dividend and divisor.
     * This must be float to avoid overflow.
     *
     * Since the floating-point dividend and divisor use 4 base-NBASE input
     * digits, they include roughly 40-53 bits of information from their
     * respective inputs (assuming NBASE is 10000), which fits well in IEEE
     * double-precision variables.  The relative error in the floating-point
     * quotient digit will then be less than around 2/NBASE^3, so the
     * estimated base-NBASE^2 quotient digit will typically be correct, and
     * should not be off by more than one from the correct value.
     */
    fdivisor = (double) divisor[0] * NBASE_SQR;
    if (var2ndigitpairs > 1)
        fdivisor += (double) divisor[1];
    fdivisorinverse = 1.0 / fdivisor;
 
    /*
     * maxdiv tracks the maximum possible absolute value of any dividend[]
     * entry; when this threatens to exceed PG_INT64_MAX, we take the time to
     * propagate carries.  Furthermore, we need to ensure that overflow
     * doesn't occur during the carry propagation passes either.  The carry
     * values may have an absolute value as high as PG_INT64_MAX/NBASE^2 + 1,
     * so really we must normalize when digits threaten to exceed PG_INT64_MAX
     * - PG_INT64_MAX/NBASE^2 - 1.
     *
     * To avoid overflow in maxdiv itself, it represents the max absolute
     * value divided by NBASE^2-1, i.e., at the top of the loop it is known
     * that no dividend[] entry has an absolute value exceeding maxdiv *
     * (NBASE^2-1).
     *
     * Actually, though, that holds good only for dividend[] entries after
     * dividend[qi]; the adjustment done at the bottom of the loop may cause
     * dividend[qi + 1] to exceed the maxdiv limit, so that dividend[qi] in
     * the next iteration is beyond the limit.  This does not cause problems,
     * as explained below.
     */
    maxdiv = 1;
 
    /*
     * Outer loop computes next quotient digit, which goes in dividend[qi].
     */
    for (qi = 0; qi < res_ndigitpairs; qi++)
    {
        /* Approximate the current dividend value */
        fdividend = (double) dividend[qi] * NBASE_SQR;
        fdividend += (double) dividend[qi + 1];
 
        /* Compute the (approximate) quotient digit */
        fquotient = fdividend * fdivisorinverse;
        qdigit = (fquotient >= 0.0) ? ((int32) fquotient) :
            (((int32) fquotient) - 1);  /* truncate towards -infinity */
 
        if (qdigit != 0)
        {
            /* Do we need to normalize now? */
            maxdiv += i64abs(qdigit);
            if (maxdiv > (PG_INT64_MAX - PG_INT64_MAX / NBASE_SQR - 1) / (NBASE_SQR - 1))
            {
                /*
                 * Yes, do it.  Note that if var2ndigitpairs is much smaller
                 * than div_ndigitpairs, we can save a significant amount of
                 * effort here by noting that we only need to normalise those
                 * dividend[] entries touched where prior iterations
                 * subtracted multiples of the divisor.
                 */
                carry = 0;
                for (i = Min(qi + var2ndigitpairs - 2, div_ndigitpairs - 1); i > qi; i--)
                {
                    newdig = dividend[i] + carry;
                    if (newdig < 0)
                    {
                        carry = -((-newdig - 1) / NBASE_SQR) - 1;
                        newdig -= carry * NBASE_SQR;
                    }
                    else if (newdig >= NBASE_SQR)
                    {
                        carry = newdig / NBASE_SQR;
                        newdig -= carry * NBASE_SQR;
                    }
                    else
                        carry = 0;
                    dividend[i] = newdig;
                }
                dividend[qi] += carry;
 
                /*
                 * All the dividend[] digits except possibly dividend[qi] are
                 * now in the range 0..NBASE^2-1.  We do not need to consider
                 * dividend[qi] in the maxdiv value anymore, so we can reset
                 * maxdiv to 1.
                 */
                maxdiv = 1;
 
                /*
                 * Recompute the quotient digit since new info may have
                 * propagated into the top two dividend digits.
                 */
                fdividend = (double) dividend[qi] * NBASE_SQR;
                fdividend += (double) dividend[qi + 1];
                fquotient = fdividend * fdivisorinverse;
                qdigit = (fquotient >= 0.0) ? ((int32) fquotient) :
                    (((int32) fquotient) - 1);  /* truncate towards -infinity */
 
                maxdiv += i64abs(qdigit);
            }
 
            /*
             * Subtract off the appropriate multiple of the divisor.
             *
             * The digits beyond dividend[qi] cannot overflow, because we know
             * they will fall within the maxdiv limit.  As for dividend[qi]
             * itself, note that qdigit is approximately trunc(dividend[qi] /
             * divisor[0]), which would make the new value simply dividend[qi]
             * mod divisor[0].  The lower-order terms in qdigit can change
             * this result by not more than about twice PG_INT64_MAX/NBASE^2,
             * so overflow is impossible.
             *
             * This inner loop is the performance bottleneck for division, so
             * code it in the same way as the inner loop of mul_var() so that
             * it can be auto-vectorized.
             */
            if (qdigit != 0)
            {
                int         istop = Min(var2ndigitpairs, div_ndigitpairs - qi);
                int64      *dividend_qi = &dividend[qi];
 
                for (i = 0; i < istop; i++)
                    dividend_qi[i] -= (int64) qdigit * divisor[i];
            }
        }
 
        /*
         * The dividend digit we are about to replace might still be nonzero.
         * Fold it into the next digit position.
         *
         * There is no risk of overflow here, although proving that requires
         * some care.  Much as with the argument for dividend[qi] not
         * overflowing, if we consider the first two terms in the numerator
         * and denominator of qdigit, we can see that the final value of
         * dividend[qi + 1] will be approximately a remainder mod
         * (divisor[0]*NBASE^2 + divisor[1]).  Accounting for the lower-order
         * terms is a bit complicated but ends up adding not much more than
         * PG_INT64_MAX/NBASE^2 to the possible range.  Thus, dividend[qi + 1]
         * cannot overflow here, and in its role as dividend[qi] in the next
         * loop iteration, it can't be large enough to cause overflow in the
         * carry propagation step (if any), either.
         *
         * But having said that: dividend[qi] can be more than
         * PG_INT64_MAX/NBASE^2, as noted above, which means that the product
         * dividend[qi] * NBASE^2 *can* overflow.  When that happens, adding
         * it to dividend[qi + 1] will always cause a canceling overflow so
         * that the end result is correct.  We could avoid the intermediate
         * overflow by doing the multiplication and addition using unsigned
         * int64 arithmetic, which is modulo 2^64, but so far there appears no
         * need.
         */
        dividend[qi + 1] += dividend[qi] * NBASE_SQR;
 
        dividend[qi] = qdigit;
    }
 
    /*
     * If an exact result was requested, use the remainder to correct the
     * approximate quotient.  The remainder is in dividend[], immediately
     * after the quotient digits.  Note, however, that although the remainder
     * starts at dividend[qi = res_ndigitpairs], the first digit is the result
     * of folding two remainder digits into one above, and the remainder
     * currently only occupies var2ndigitpairs - 1 digits (the last digit of
     * the working dividend was untouched by the computation above).  Thus we
     * expand the remainder down by one base-NBASE^2 digit when we normalize
     * it, so that it completely fills the last var2ndigitpairs digits of the
     * dividend array.
     */
    if (exact)
    {
        /* Normalize the remainder, expanding it down by one digit */
        remainder = &dividend[qi];
        carry = 0;
        for (i = var2ndigitpairs - 2; i >= 0; i--)
        {
            newdig = remainder[i] + carry;
            if (newdig < 0)
            {
                carry = -((-newdig - 1) / NBASE_SQR) - 1;
                newdig -= carry * NBASE_SQR;
            }
            else if (newdig >= NBASE_SQR)
            {
                carry = newdig / NBASE_SQR;
                newdig -= carry * NBASE_SQR;
            }
            else
                carry = 0;
            remainder[i + 1] = newdig;
        }
        remainder[0] = carry;
 
        if (remainder[0] < 0)
        {
            /*
             * The remainder is negative, so the approximate quotient is too
             * large.  Correct by reducing the quotient by one and adding the
             * divisor to the remainder until the remainder is positive.  We
             * expect the quotient to be off by at most one, which has been
             * borne out in all testing, but not conclusively proven, so we
             * allow for larger corrections, just in case.
             */
            do
            {
                /* Add the divisor to the remainder */
                carry = 0;
                for (i = var2ndigitpairs - 1; i > 0; i--)
                {
                    newdig = remainder[i] + divisor[i] + carry;
                    if (newdig >= NBASE_SQR)
                    {
                        remainder[i] = newdig - NBASE_SQR;
                        carry = 1;
                    }
                    else
                    {
                        remainder[i] = newdig;
                        carry = 0;
                    }
                }
                remainder[0] += divisor[0] + carry;
 
                /* Subtract 1 from the quotient (propagating carries later) */
                dividend[qi - 1]--;
 
            } while (remainder[0] < 0);
        }
        else
        {
            /*
             * The remainder is nonnegative.  If it's greater than or equal to
             * the divisor, then the approximate quotient is too small and
             * must be corrected.  As above, we don't expect to have to apply
             * more than one correction, but allow for it just in case.
             */
            while (true)
            {
                bool        less = false;
 
                /* Is remainder < divisor? */
                for (i = 0; i < var2ndigitpairs; i++)
                {
                    if (remainder[i] < divisor[i])
                    {
                        less = true;
                        break;
                    }
                    if (remainder[i] > divisor[i])
                        break;  /* remainder > divisor */
                }
                if (less)
                    break;      /* quotient is correct */
 
                /* Subtract the divisor from the remainder */
                carry = 0;
                for (i = var2ndigitpairs - 1; i > 0; i--)
                {
                    newdig = remainder[i] - divisor[i] + carry;
                    if (newdig < 0)
                    {
                        remainder[i] = newdig + NBASE_SQR;
                        carry = -1;
                    }
                    else
                    {
                        remainder[i] = newdig;
                        carry = 0;
                    }
                }
                remainder[0] = remainder[0] - divisor[0] + carry;
 
                /* Add 1 to the quotient (propagating carries later) */
                dividend[qi - 1]++;
            }
        }
    }
 
    /*
     * Because the quotient digits were estimates that might have been off by
     * one (and we didn't bother propagating carries when adjusting the
     * quotient above), some quotient digits might be out of range, so do a
     * final carry propagation pass to normalize back to base NBASE^2, and
     * construct the base-NBASE result digits.  Note that this is still done
     * at full precision w/guard digits.
     */
    alloc_var(result, res_ndigits);
    res_digits = result->digits;
    carry = 0;
    for (i = res_ndigitpairs - 1; i >= 0; i--)
    {
        newdig = dividend[i] + carry;
        if (newdig < 0)
        {
            carry = -((-newdig - 1) / NBASE_SQR) - 1;
            newdig -= carry * NBASE_SQR;
        }
        else if (newdig >= NBASE_SQR)
        {
            carry = newdig / NBASE_SQR;
            newdig -= carry * NBASE_SQR;
        }
        else
            carry = 0;
        res_digits[2 * i + 1] = (NumericDigit) ((uint32) newdig % NBASE);
        res_digits[2 * i] = (NumericDigit) ((uint32) newdig / NBASE);
    }
    Assert(carry == 0);
 
    pfree(dividend);
 
    /*
     * Finally, round or truncate the result to the requested precision.
     */
    result->weight = res_weight;
    result->sign = res_sign;
 
    /* Round or truncate to target rscale (and set result->dscale) */
    if (round)
        round_var(result, rscale);
    else
        trunc_var(result, rscale);
 
    /* Strip leading and trailing zeroes */
    strip_var(result);
}

References alloc_var(), Assert(), DEC_DIGITS, NumericVar::digits, DIV_GUARD_DIGITS, div_var_int(), NumericVar::dscale, ereport, errcode(), errmsg(), ERROR, i, if(), Max, Min, NBASE, NBASE_SQR, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, palloc(), pfree(), PG_INT64_MAX, remainder, round_var(), NumericVar::sign, strip_var(), trunc_var(), NumericVar::weight, and zero_var().

Referenced by compute_bucket(), div_mod_var(), generate_series_numeric_support(), get_str_from_var_sci(), ln_var(), log_var(), mod_var(), numeric_div_safe(), numeric_div_trunc(), numeric_lcm(), numeric_stddev_internal(), and power_var_int().

div_var_int()

static void div_var_int ( const NumericVar *  var, int  ival, int  ival_weight, NumericVar *  result, int  rscale, bool  round  )

static

Definition at line 9419 of file numeric.c.

{
    NumericDigit *var_digits = var->digits;
    int         var_ndigits = var->ndigits;
    int         res_sign;
    int         res_weight;
    int         res_ndigits;
    NumericDigit *res_buf;
    NumericDigit *res_digits;
    uint32      divisor;
    int         i;
 
    /* Guard against division by zero */
    if (ival == 0)
        ereport(ERROR,
                errcode(ERRCODE_DIVISION_BY_ZERO),
                errmsg("division by zero"));
 
    /* Result zero check */
    if (var_ndigits == 0)
    {
        zero_var(result);
        result->dscale = rscale;
        return;
    }
 
    /*
     * Determine the result sign, weight and number of digits to calculate.
     * The weight figured here is correct if the emitted quotient has no
     * leading zero digits; otherwise strip_var() will fix things up.
     */
    if (var->sign == NUMERIC_POS)
        res_sign = ival > 0 ? NUMERIC_POS : NUMERIC_NEG;
    else
        res_sign = ival > 0 ? NUMERIC_NEG : NUMERIC_POS;
    res_weight = var->weight - ival_weight;
    /* The number of accurate result digits we need to produce: */
    res_ndigits = res_weight + 1 + (rscale + DEC_DIGITS - 1) / DEC_DIGITS;
    /* ... but always at least 1 */
    res_ndigits = Max(res_ndigits, 1);
    /* If rounding needed, figure one more digit to ensure correct result */
    if (round)
        res_ndigits++;
 
    res_buf = digitbuf_alloc(res_ndigits + 1);
    res_buf[0] = 0;             /* spare digit for later rounding */
    res_digits = res_buf + 1;
 
    /*
     * Now compute the quotient digits.  This is the short division algorithm
     * described in Knuth volume 2, section 4.3.1 exercise 16, except that we
     * allow the divisor to exceed the internal base.
     *
     * In this algorithm, the carry from one digit to the next is at most
     * divisor - 1.  Therefore, while processing the next digit, carry may
     * become as large as divisor * NBASE - 1, and so it requires a 64-bit
     * integer if this exceeds UINT_MAX.
     */
    divisor = abs(ival);
 
    if (divisor <= UINT_MAX / NBASE)
    {
        /* carry cannot overflow 32 bits */
        uint32      carry = 0;
 
        for (i = 0; i < res_ndigits; i++)
        {
            carry = carry * NBASE + (i < var_ndigits ? var_digits[i] : 0);
            res_digits[i] = (NumericDigit) (carry / divisor);
            carry = carry % divisor;
        }
    }
    else
    {
        /* carry may exceed 32 bits */
        uint64      carry = 0;
 
        for (i = 0; i < res_ndigits; i++)
        {
            carry = carry * NBASE + (i < var_ndigits ? var_digits[i] : 0);
            res_digits[i] = (NumericDigit) (carry / divisor);
            carry = carry % divisor;
        }
    }
 
    /* Store the quotient in result */
    digitbuf_free(result->buf);
    result->ndigits = res_ndigits;
    result->buf = res_buf;
    result->digits = res_digits;
    result->weight = res_weight;
    result->sign = res_sign;
 
    /* Round or truncate to target rscale (and set result->dscale) */
    if (round)
        round_var(result, rscale);
    else
        trunc_var(result, rscale);
 
    /* Strip leading/trailing zeroes */
    strip_var(result);
}

References NumericVar::buf, DEC_DIGITS, digitbuf_alloc, digitbuf_free, NumericVar::digits, NumericVar::dscale, ereport, errcode(), errmsg(), ERROR, i, Max, NBASE, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, round_var(), NumericVar::sign, strip_var(), trunc_var(), NumericVar::weight, and zero_var().

Referenced by div_var(), exp_var(), and ln_var().

do_int128_accum()

static void do_int128_accum ( Int128AggState *  state, int64  newval  )

static

Definition at line 5448 of file numeric.c.

{
    if (state->calcSumX2)
        int128_add_int64_mul_int64(&state->sumX2, newval, newval);
 
    int128_add_int64(&state->sumX, newval);
    state->N++;
}

References int128_add_int64(), int128_add_int64_mul_int64(), and newval.

Referenced by int2_accum(), int4_accum(), and int8_avg_accum().

do_int128_discard()

static void do_int128_discard ( Int128AggState *  state, int64  newval  )

static

Definition at line 5461 of file numeric.c.

{
    if (state->calcSumX2)
        int128_sub_int64_mul_int64(&state->sumX2, newval, newval);
 
    int128_sub_int64(&state->sumX, newval);
    state->N--;
}

References int128_sub_int64(), int128_sub_int64_mul_int64(), and newval.

Referenced by int2_accum_inv(), int4_accum_inv(), and int8_avg_accum_inv().

do_numeric_accum()

static void do_numeric_accum ( NumericAggState *  state, Numeric  newval  )

static

Definition at line 4786 of file numeric.c.

{
    NumericVar  X;
    NumericVar  X2;
    MemoryContext old_context;
 
    /* Count NaN/infinity inputs separately from all else */
    if (NUMERIC_IS_SPECIAL(newval))
    {
        if (NUMERIC_IS_PINF(newval))
            state->pInfcount++;
        else if (NUMERIC_IS_NINF(newval))
            state->nInfcount++;
        else
            state->NaNcount++;
        return;
    }
 
    /* load processed number in short-lived context */
    init_var_from_num(newval, &X);
 
    /*
     * Track the highest input dscale that we've seen, to support inverse
     * transitions (see do_numeric_discard).
     */
    if (X.dscale > state->maxScale)
    {
        state->maxScale = X.dscale;
        state->maxScaleCount = 1;
    }
    else if (X.dscale == state->maxScale)
        state->maxScaleCount++;
 
    /* if we need X^2, calculate that in short-lived context */
    if (state->calcSumX2)
    {
        init_var(&X2);
        mul_var(&X, &X, &X2, X.dscale * 2);
    }
 
    /* The rest of this needs to work in the aggregate context */
    old_context = MemoryContextSwitchTo(state->agg_context);
 
    state->N++;
 
    /* Accumulate sums */
    accum_sum_add(&(state->sumX), &X);
 
    if (state->calcSumX2)
        accum_sum_add(&(state->sumX2), &X2);
 
    MemoryContextSwitchTo(old_context);
}

References accum_sum_add(), NumericVar::dscale, init_var, init_var_from_num(), MemoryContextSwitchTo(), mul_var(), newval, NUMERIC_IS_NINF, NUMERIC_IS_PINF, and NUMERIC_IS_SPECIAL.

Referenced by int8_accum(), numeric_accum(), and numeric_avg_accum().

do_numeric_discard()

static bool do_numeric_discard ( NumericAggState *  state, Numeric  newval  )

static

Definition at line 4856 of file numeric.c.

{
    NumericVar  X;
    NumericVar  X2;
    MemoryContext old_context;
 
    /* Count NaN/infinity inputs separately from all else */
    if (NUMERIC_IS_SPECIAL(newval))
    {
        if (NUMERIC_IS_PINF(newval))
            state->pInfcount--;
        else if (NUMERIC_IS_NINF(newval))
            state->nInfcount--;
        else
            state->NaNcount--;
        return true;
    }
 
    /* load processed number in short-lived context */
    init_var_from_num(newval, &X);
 
    /*
     * state->sumX's dscale is the maximum dscale of any of the inputs.
     * Removing the last input with that dscale would require us to recompute
     * the maximum dscale of the *remaining* inputs, which we cannot do unless
     * no more non-NaN inputs remain at all.  So we report a failure instead,
     * and force the aggregation to be redone from scratch.
     */
    if (X.dscale == state->maxScale)
    {
        if (state->maxScaleCount > 1 || state->maxScale == 0)
        {
            /*
             * Some remaining inputs have same dscale, or dscale hasn't gotten
             * above zero anyway
             */
            state->maxScaleCount--;
        }
        else if (state->N == 1)
        {
            /* No remaining non-NaN inputs at all, so reset maxScale */
            state->maxScale = 0;
            state->maxScaleCount = 0;
        }
        else
        {
            /* Correct new maxScale is uncertain, must fail */
            return false;
        }
    }
 
    /* if we need X^2, calculate that in short-lived context */
    if (state->calcSumX2)
    {
        init_var(&X2);
        mul_var(&X, &X, &X2, X.dscale * 2);
    }
 
    /* The rest of this needs to work in the aggregate context */
    old_context = MemoryContextSwitchTo(state->agg_context);
 
    if (state->N-- > 1)
    {
        /* Negate X, to subtract it from the sum */
        X.sign = (X.sign == NUMERIC_POS ? NUMERIC_NEG : NUMERIC_POS);
        accum_sum_add(&(state->sumX), &X);
 
        if (state->calcSumX2)
        {
            /* Negate X^2. X^2 is always positive */
            X2.sign = NUMERIC_NEG;
            accum_sum_add(&(state->sumX2), &X2);
        }
    }
    else
    {
        /* Zero the sums */
        Assert(state->N == 0);
 
        accum_sum_reset(&state->sumX);
        if (state->calcSumX2)
            accum_sum_reset(&state->sumX2);
    }
 
    MemoryContextSwitchTo(old_context);
 
    return true;
}

References accum_sum_add(), accum_sum_reset(), Assert(), NumericVar::dscale, init_var, init_var_from_num(), MemoryContextSwitchTo(), mul_var(), newval, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, NUMERIC_NEG, NUMERIC_POS, and NumericVar::sign.

Referenced by int8_accum_inv(), and numeric_accum_inv().

duplicate_numeric()

static Numeric duplicate_numeric ( Numeric  num )

static

Definition at line 7494 of file numeric.c.

{
    Numeric     res;
 
    res = (Numeric) palloc(VARSIZE(num));
    memcpy(res, num, VARSIZE(num));
    return res;
}

References palloc(), and VARSIZE().

Referenced by numeric(), numeric_abs(), numeric_ceil(), numeric_exp(), numeric_floor(), numeric_inc(), numeric_ln(), numeric_mod_safe(), numeric_round(), numeric_sqrt(), numeric_trim_scale(), numeric_trunc(), numeric_uminus(), and numeric_uplus().

estimate_ln_dweight()

static int estimate_ln_dweight ( const NumericVar *  var )

static

Definition at line 10541 of file numeric.c.

{
    int         ln_dweight;
 
    /* Caller should fail on ln(negative), but for the moment return zero */
    if (var->sign != NUMERIC_POS)
        return 0;
 
    if (cmp_var(var, &const_zero_point_nine) >= 0 &&
        cmp_var(var, &const_one_point_one) <= 0)
    {
        /*
         * 0.9 <= var <= 1.1
         *
         * ln(var) has a negative weight (possibly very large).  To get a
         * reasonably accurate result, estimate it using ln(1+x) ~= x.
         */
        NumericVar  x;
 
        init_var(&x);
        sub_var(var, &const_one, &x);
 
        if (x.ndigits > 0)
        {
            /* Use weight of most significant decimal digit of x */
            ln_dweight = x.weight * DEC_DIGITS + (int) log10(x.digits[0]);
        }
        else
        {
            /* x = 0.  Since ln(1) = 0 exactly, we don't need extra digits */
            ln_dweight = 0;
        }
 
        free_var(&x);
    }
    else
    {
        /*
         * Estimate the logarithm using the first couple of digits from the
         * input number.  This will give an accurate result whenever the input
         * is not too close to 1.
         */
        if (var->ndigits > 0)
        {
            int         digits;
            int         dweight;
            double      ln_var;
 
            digits = var->digits[0];
            dweight = var->weight * DEC_DIGITS;
 
            if (var->ndigits > 1)
            {
                digits = digits * NBASE + var->digits[1];
                dweight -= DEC_DIGITS;
            }
 
            /*----------
             * We have var ~= digits * 10^dweight
             * so ln(var) ~= ln(digits) + dweight * ln(10)
             *----------
             */
            ln_var = log((double) digits) + dweight * 2.302585092994046;
            ln_dweight = (int) log10(fabs(ln_var));
        }
        else
        {
            /* Caller should fail on ln(0), but for the moment return zero */
            ln_dweight = 0;
        }
    }
 
    return ln_dweight;
}

References cmp_var(), const_one, const_one_point_one, const_zero_point_nine, DEC_DIGITS, NumericVar::digits, digits, free_var(), init_var, ln_var(), NBASE, NumericVar::ndigits, NUMERIC_POS, NumericVar::sign, sub_var(), NumericVar::weight, and x.

Referenced by log_var(), numeric_ln(), and power_var().

exp_var()

static void exp_var ( const NumericVar *  arg, NumericVar *  result, int  rscale  )

static

Definition at line 10412 of file numeric.c.

{
    NumericVar  x;
    NumericVar  elem;
    int         ni;
    double      val;
    int         dweight;
    int         ndiv2;
    int         sig_digits;
    int         local_rscale;
 
    init_var(&x);
    init_var(&elem);
 
    set_var_from_var(arg, &x);
 
    /*
     * Estimate the dweight of the result using floating point arithmetic, so
     * that we can choose an appropriate local rscale for the calculation.
     */
    val = numericvar_to_double_no_overflow(&x);
 
    /* Guard against overflow/underflow */
    /* If you change this limit, see also power_var()'s limit */
    if (fabs(val) >= NUMERIC_MAX_RESULT_SCALE * 3)
    {
        if (val > 0)
            ereport(ERROR,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("value overflows numeric format")));
        zero_var(result);
        result->dscale = rscale;
        return;
    }
 
    /* decimal weight = log10(e^x) = x * log10(e) */
    dweight = (int) (val * 0.434294481903252);
 
    /*
     * Reduce x to the range -0.01 <= x <= 0.01 (approximately) by dividing by
     * 2^ndiv2, to improve the convergence rate of the Taylor series.
     *
     * Note that the overflow check above ensures that fabs(x) < 6000, which
     * means that ndiv2 <= 20 here.
     */
    if (fabs(val) > 0.01)
    {
        ndiv2 = 1;
        val /= 2;
 
        while (fabs(val) > 0.01)
        {
            ndiv2++;
            val /= 2;
        }
 
        local_rscale = x.dscale + ndiv2;
        div_var_int(&x, 1 << ndiv2, 0, &x, local_rscale, true);
    }
    else
        ndiv2 = 0;
 
    /*
     * Set the scale for the Taylor series expansion.  The final result has
     * (dweight + rscale + 1) significant digits.  In addition, we have to
     * raise the Taylor series result to the power 2^ndiv2, which introduces
     * an error of up to around log10(2^ndiv2) digits, so work with this many
     * extra digits of precision (plus a few more for good measure).
     */
    sig_digits = 1 + dweight + rscale + (int) (ndiv2 * 0.301029995663981);
    sig_digits = Max(sig_digits, 0) + 8;
 
    local_rscale = sig_digits - 1;
 
    /*
     * Use the Taylor series
     *
     * exp(x) = 1 + x + x^2/2! + x^3/3! + ...
     *
     * Given the limited range of x, this should converge reasonably quickly.
     * We run the series until the terms fall below the local_rscale limit.
     */
    add_var(&const_one, &x, result);
 
    mul_var(&x, &x, &elem, local_rscale);
    ni = 2;
    div_var_int(&elem, ni, 0, &elem, local_rscale, true);
 
    while (elem.ndigits != 0)
    {
        add_var(result, &elem, result);
 
        mul_var(&elem, &x, &elem, local_rscale);
        ni++;
        div_var_int(&elem, ni, 0, &elem, local_rscale, true);
    }
 
    /*
     * Compensate for the argument range reduction.  Since the weight of the
     * result doubles with each multiplication, we can reduce the local rscale
     * as we proceed.
     */
    while (ndiv2-- > 0)
    {
        local_rscale = sig_digits - result->weight * 2 * DEC_DIGITS;
        local_rscale = Max(local_rscale, NUMERIC_MIN_DISPLAY_SCALE);
        mul_var(result, result, result, local_rscale);
    }
 
    /* Round to requested rscale */
    round_var(result, rscale);
 
    free_var(&x);
    free_var(&elem);
}

References add_var(), arg, const_one, DEC_DIGITS, div_var_int(), NumericVar::dscale, ereport, errcode(), errmsg(), ERROR, free_var(), init_var, Max, mul_var(), NumericVar::ndigits, NUMERIC_MAX_RESULT_SCALE, NUMERIC_MIN_DISPLAY_SCALE, numericvar_to_double_no_overflow(), round_var(), set_var_from_var(), val, NumericVar::weight, x, and zero_var().

Referenced by numeric_exp(), and power_var().

float4_numeric()

Datum float4_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 4616 of file numeric.c.

{
    float4      val = PG_GETARG_FLOAT4(0);
    Numeric     res;
    NumericVar  result;
    char        buf[FLT_DIG + 100];
    const char *endptr;
 
    if (isnan(val))
        PG_RETURN_NUMERIC(make_result(&const_nan));
 
    if (isinf(val))
    {
        if (val < 0)
            PG_RETURN_NUMERIC(make_result(&const_ninf));
        else
            PG_RETURN_NUMERIC(make_result(&const_pinf));
    }
 
    snprintf(buf, sizeof(buf), "%.*g", FLT_DIG, val);
 
    init_var(&result);
 
    /* Assume we need not worry about leading/trailing spaces */
    (void) set_var_from_str(buf, buf, &result, &endptr, NULL);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References buf, const_nan, const_ninf, const_pinf, free_var(), init_var, make_result(), PG_GETARG_FLOAT4, PG_RETURN_NUMERIC, set_var_from_str(), snprintf, and val.

Referenced by JsonItemFromDatum().

float8_numeric()

Datum float8_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 4522 of file numeric.c.

{
    float8      val = PG_GETARG_FLOAT8(0);
    Numeric     res;
    NumericVar  result;
    char        buf[DBL_DIG + 100];
    const char *endptr;
 
    if (isnan(val))
        PG_RETURN_NUMERIC(make_result(&const_nan));
 
    if (isinf(val))
    {
        if (val < 0)
            PG_RETURN_NUMERIC(make_result(&const_ninf));
        else
            PG_RETURN_NUMERIC(make_result(&const_pinf));
    }
 
    snprintf(buf, sizeof(buf), "%.*g", DBL_DIG, val);
 
    init_var(&result);
 
    /* Assume we need not worry about leading/trailing spaces */
    (void) set_var_from_str(buf, buf, &result, &endptr, NULL);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References buf, const_nan, const_ninf, const_pinf, free_var(), init_var, make_result(), PG_GETARG_FLOAT8, PG_RETURN_NUMERIC, set_var_from_str(), snprintf, and val.

Referenced by executeItemOptUnwrapTarget(), JsonItemFromDatum(), and SV_to_JsonbValue().

floor_var()

static void floor_var ( const NumericVar *  var, NumericVar *  result  )

static

Definition at line 9839 of file numeric.c.

{
    NumericVar  tmp;
 
    init_var(&tmp);
    set_var_from_var(var, &tmp);
 
    trunc_var(&tmp, 0);
 
    if (var->sign == NUMERIC_NEG && cmp_var(var, &tmp) != 0)
        sub_var(&tmp, &const_one, &tmp);
 
    set_var_from_var(&tmp, result);
    free_var(&tmp);
}

References cmp_var(), const_one, free_var(), init_var, NUMERIC_NEG, set_var_from_var(), NumericVar::sign, sub_var(), and trunc_var().

Referenced by numeric_floor().

free_var()

static void free_var ( NumericVar *  var )

static

Definition at line 6700 of file numeric.c.

{
    digitbuf_free(var->buf);
    var->buf = NULL;
    var->digits = NULL;
    var->sign = NUMERIC_NAN;
}

References NumericVar::buf, digitbuf_free, NumericVar::digits, NUMERIC_NAN, and NumericVar::sign.

Referenced by accum_sum_combine(), ceil_var(), compute_bucket(), div_mod_var(), estimate_ln_dweight(), exp_var(), float4_numeric(), float8_numeric(), floor_var(), gcd_var(), generate_series_numeric_support(), get_str_from_var_sci(), in_range_numeric_numeric(), int64_div_fast_to_numeric(), int64_to_numeric(), ln_var(), log_var(), mod_var(), numeric(), numeric_add_safe(), numeric_avg(), numeric_avg_deserialize(), numeric_avg_serialize(), numeric_ceil(), numeric_deserialize(), numeric_div_safe(), numeric_div_trunc(), numeric_exp(), numeric_fac(), numeric_floor(), numeric_gcd(), numeric_in(), numeric_inc(), numeric_lcm(), numeric_ln(), numeric_log(), numeric_min_scale(), numeric_mod_safe(), numeric_mul_safe(), numeric_poly_avg(), numeric_poly_stddev_internal(), numeric_poly_sum(), numeric_power(), numeric_recv(), numeric_round(), numeric_serialize(), numeric_sqrt(), numeric_stddev_internal(), numeric_sub_safe(), numeric_sum(), numeric_trim_scale(), numeric_trunc(), numericvar_to_int64(), numericvar_to_uint64(), power_var(), power_var_int(), random_numeric(), random_var(), set_var_from_non_decimal_integer_str(), sqrt_var(), and width_bucket_numeric().

gcd_var()

static void gcd_var ( const NumericVar *  var1, const NumericVar *  var2, NumericVar *  result  )

static

Definition at line 9862 of file numeric.c.

{
    int         res_dscale;
    int         cmp;
    NumericVar  tmp_arg;
    NumericVar  mod;
 
    res_dscale = Max(var1->dscale, var2->dscale);
 
    /*
     * Arrange for var1 to be the number with the greater absolute value.
     *
     * This would happen automatically in the loop below, but avoids an
     * expensive modulo operation.
     */
    cmp = cmp_abs(var1, var2);
    if (cmp < 0)
    {
        const NumericVar *tmp = var1;
 
        var1 = var2;
        var2 = tmp;
    }
 
    /*
     * Also avoid the taking the modulo if the inputs have the same absolute
     * value, or if the smaller input is zero.
     */
    if (cmp == 0 || var2->ndigits == 0)
    {
        set_var_from_var(var1, result);
        result->sign = NUMERIC_POS;
        result->dscale = res_dscale;
        return;
    }
 
    init_var(&tmp_arg);
    init_var(&mod);
 
    /* Use the Euclidean algorithm to find the GCD */
    set_var_from_var(var1, &tmp_arg);
    set_var_from_var(var2, result);
 
    for (;;)
    {
        /* this loop can take a while, so allow it to be interrupted */
        CHECK_FOR_INTERRUPTS();
 
        mod_var(&tmp_arg, result, &mod);
        if (mod.ndigits == 0)
            break;
        set_var_from_var(result, &tmp_arg);
        set_var_from_var(&mod, result);
    }
    result->sign = NUMERIC_POS;
    result->dscale = res_dscale;
 
    free_var(&tmp_arg);
    free_var(&mod);
}

References CHECK_FOR_INTERRUPTS, cmp(), cmp_abs(), NumericVar::dscale, free_var(), init_var, Max, mod_var(), NumericVar::ndigits, NUMERIC_POS, set_var_from_var(), and NumericVar::sign.

Referenced by numeric_gcd(), and numeric_lcm().

generate_series_numeric()

Datum generate_series_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 1686 of file numeric.c.

{
    return generate_series_step_numeric(fcinfo);
}

References generate_series_step_numeric().

generate_series_numeric_support()

Datum generate_series_numeric_support

(

PG_FUNCTION_ARGS

)

Definition at line 1818 of file numeric.c.

{
    Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
    Node       *ret = NULL;
 
    if (IsA(rawreq, SupportRequestRows))
    {
        /* Try to estimate the number of rows returned */
        SupportRequestRows *req = (SupportRequestRows *) rawreq;
 
        if (is_funcclause(req->node))   /* be paranoid */
        {
            List       *args = ((FuncExpr *) req->node)->args;
            Node       *arg1,
                       *arg2,
                       *arg3;
 
            /* We can use estimated argument values here */
            arg1 = estimate_expression_value(req->root, linitial(args));
            arg2 = estimate_expression_value(req->root, lsecond(args));
            if (list_length(args) >= 3)
                arg3 = estimate_expression_value(req->root, lthird(args));
            else
                arg3 = NULL;
 
            /*
             * If any argument is constant NULL, we can safely assume that
             * zero rows are returned.  Otherwise, if they're all non-NULL
             * constants, we can calculate the number of rows that will be
             * returned.
             */
            if ((IsA(arg1, Const) &&
                 ((Const *) arg1)->constisnull) ||
                (IsA(arg2, Const) &&
                 ((Const *) arg2)->constisnull) ||
                (arg3 != NULL && IsA(arg3, Const) &&
                 ((Const *) arg3)->constisnull))
            {
                req->rows = 0;
                ret = (Node *) req;
            }
            else if (IsA(arg1, Const) &&
                     IsA(arg2, Const) &&
                     (arg3 == NULL || IsA(arg3, Const)))
            {
                Numeric     start_num;
                Numeric     stop_num;
                NumericVar  step = const_one;
 
                /*
                 * If any argument is NaN or infinity, generate_series() will
                 * error out, so we needn't produce an estimate.
                 */
                start_num = DatumGetNumeric(((Const *) arg1)->constvalue);
                stop_num = DatumGetNumeric(((Const *) arg2)->constvalue);
 
                if (NUMERIC_IS_SPECIAL(start_num) ||
                    NUMERIC_IS_SPECIAL(stop_num))
                    PG_RETURN_POINTER(NULL);
 
                if (arg3)
                {
                    Numeric     step_num;
 
                    step_num = DatumGetNumeric(((Const *) arg3)->constvalue);
 
                    if (NUMERIC_IS_SPECIAL(step_num))
                        PG_RETURN_POINTER(NULL);
 
                    init_var_from_num(step_num, &step);
                }
 
                /*
                 * The number of rows that will be returned is given by
                 * floor((stop - start) / step) + 1, if the sign of step
                 * matches the sign of stop - start.  Otherwise, no rows will
                 * be returned.
                 */
                if (cmp_var(&step, &const_zero) != 0)
                {
                    NumericVar  start;
                    NumericVar  stop;
                    NumericVar  res;
 
                    init_var_from_num(start_num, &start);
                    init_var_from_num(stop_num, &stop);
 
                    init_var(&res);
                    sub_var(&stop, &start, &res);
 
                    if (step.sign != res.sign)
                    {
                        /* no rows will be returned */
                        req->rows = 0;
                        ret = (Node *) req;
                    }
                    else
                    {
                        if (arg3)
                            div_var(&res, &step, &res, 0, false, false);
                        else
                            trunc_var(&res, 0); /* step = 1 */
 
                        req->rows = numericvar_to_double_no_overflow(&res) + 1;
                        ret = (Node *) req;
                    }
 
                    free_var(&res);
                }
            }
        }
    }
 
    PG_RETURN_POINTER(ret);
}

References generate_unaccent_rules::args, cmp_var(), const_one, const_zero, DatumGetNumeric(), div_var(), estimate_expression_value(), free_var(), init_var, init_var_from_num(), is_funcclause(), IsA, linitial, list_length(), lsecond, lthird, SupportRequestRows::node, NUMERIC_IS_SPECIAL, numericvar_to_double_no_overflow(), PG_GETARG_POINTER, PG_RETURN_POINTER, SupportRequestRows::root, SupportRequestRows::rows, NumericVar::sign, start, sub_var(), and trunc_var().

generate_series_step_numeric()

Datum generate_series_step_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 1692 of file numeric.c.

{
    generate_series_numeric_fctx *fctx;
    FuncCallContext *funcctx;
    MemoryContext oldcontext;
 
    if (SRF_IS_FIRSTCALL())
    {
        Numeric     start_num = PG_GETARG_NUMERIC(0);
        Numeric     stop_num = PG_GETARG_NUMERIC(1);
        NumericVar  steploc = const_one;
 
        /* Reject NaN and infinities in start and stop values */
        if (NUMERIC_IS_SPECIAL(start_num))
        {
            if (NUMERIC_IS_NAN(start_num))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("start value cannot be NaN")));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("start value cannot be infinity")));
        }
        if (NUMERIC_IS_SPECIAL(stop_num))
        {
            if (NUMERIC_IS_NAN(stop_num))
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("stop value cannot be NaN")));
            else
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("stop value cannot be infinity")));
        }
 
        /* see if we were given an explicit step size */
        if (PG_NARGS() == 3)
        {
            Numeric     step_num = PG_GETARG_NUMERIC(2);
 
            if (NUMERIC_IS_SPECIAL(step_num))
            {
                if (NUMERIC_IS_NAN(step_num))
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("step size cannot be NaN")));
                else
                    ereport(ERROR,
                            (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                             errmsg("step size cannot be infinity")));
            }
 
            init_var_from_num(step_num, &steploc);
 
            if (cmp_var(&steploc, &const_zero) == 0)
                ereport(ERROR,
                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                         errmsg("step size cannot equal zero")));
        }
 
        /* create a function context for cross-call persistence */
        funcctx = SRF_FIRSTCALL_INIT();
 
        /*
         * Switch to memory context appropriate for multiple function calls.
         */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        /* allocate memory for user context */
        fctx = (generate_series_numeric_fctx *)
            palloc(sizeof(generate_series_numeric_fctx));
 
        /*
         * Use fctx to keep state from call to call. Seed current with the
         * original start value. We must copy the start_num and stop_num
         * values rather than pointing to them, since we may have detoasted
         * them in the per-call context.
         */
        init_var(&fctx->current);
        init_var(&fctx->stop);
        init_var(&fctx->step);
 
        set_var_from_num(start_num, &fctx->current);
        set_var_from_num(stop_num, &fctx->stop);
        set_var_from_var(&steploc, &fctx->step);
 
        funcctx->user_fctx = fctx;
        MemoryContextSwitchTo(oldcontext);
    }
 
    /* stuff done on every call of the function */
    funcctx = SRF_PERCALL_SETUP();
 
    /*
     * Get the saved state and use current state as the result of this
     * iteration.
     */
    fctx = funcctx->user_fctx;
 
    if ((fctx->step.sign == NUMERIC_POS &&
         cmp_var(&fctx->current, &fctx->stop) <= 0) ||
        (fctx->step.sign == NUMERIC_NEG &&
         cmp_var(&fctx->current, &fctx->stop) >= 0))
    {
        Numeric     result = make_result(&fctx->current);
 
        /* switch to memory context appropriate for iteration calculation */
        oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
 
        /* increment current in preparation for next iteration */
        add_var(&fctx->current, &fctx->step, &fctx->current);
        MemoryContextSwitchTo(oldcontext);
 
        /* do when there is more left to send */
        SRF_RETURN_NEXT(funcctx, NumericGetDatum(result));
    }
    else
        /* do when there is no more left */
        SRF_RETURN_DONE(funcctx);
}

References add_var(), cmp_var(), const_one, const_zero, generate_series_numeric_fctx::current, ereport, errcode(), errmsg(), ERROR, init_var, init_var_from_num(), make_result(), MemoryContextSwitchTo(), FuncCallContext::multi_call_memory_ctx, NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, NUMERIC_NEG, NUMERIC_POS, NumericGetDatum(), palloc(), PG_GETARG_NUMERIC, PG_NARGS, set_var_from_num(), set_var_from_var(), NumericVar::sign, SRF_FIRSTCALL_INIT, SRF_IS_FIRSTCALL, SRF_PERCALL_SETUP, SRF_RETURN_DONE, SRF_RETURN_NEXT, generate_series_numeric_fctx::step, generate_series_numeric_fctx::stop, and FuncCallContext::user_fctx.

Referenced by generate_series_numeric().

get_min_scale()

static int get_min_scale ( NumericVar *  var )

static

Definition at line 4113 of file numeric.c.

{
    int         min_scale;
    int         last_digit_pos;
 
    /*
     * Ordinarily, the input value will be "stripped" so that the last
     * NumericDigit is nonzero.  But we don't want to get into an infinite
     * loop if it isn't, so explicitly find the last nonzero digit.
     */
    last_digit_pos = var->ndigits - 1;
    while (last_digit_pos >= 0 &&
           var->digits[last_digit_pos] == 0)
        last_digit_pos--;
 
    if (last_digit_pos >= 0)
    {
        /* compute min_scale assuming that last ndigit has no zeroes */
        min_scale = (last_digit_pos - var->weight) * DEC_DIGITS;
 
        /*
         * We could get a negative result if there are no digits after the
         * decimal point.  In this case the min_scale must be zero.
         */
        if (min_scale > 0)
        {
            /*
             * Reduce min_scale if trailing digit(s) in last NumericDigit are
             * zero.
             */
            NumericDigit last_digit = var->digits[last_digit_pos];
 
            while (last_digit % 10 == 0)
            {
                min_scale--;
                last_digit /= 10;
            }
        }
        else
            min_scale = 0;
    }
    else
        min_scale = 0;          /* result if input is zero */
 
    return min_scale;
}

References DEC_DIGITS, NumericVar::digits, NumericVar::ndigits, and NumericVar::weight.

Referenced by numeric_min_scale(), and numeric_trim_scale().

get_str_from_var()

static char * get_str_from_var ( const NumericVar *  var )

static

Definition at line 7225 of file numeric.c.

{
    int         dscale;
    char       *str;
    char       *cp;
    char       *endcp;
    int         i;
    int         d;
    NumericDigit dig;
 
#if DEC_DIGITS > 1
    NumericDigit d1;
#endif
 
    dscale = var->dscale;
 
    /*
     * Allocate space for the result.
     *
     * i is set to the # of decimal digits before decimal point. dscale is the
     * # of decimal digits we will print after decimal point. We may generate
     * as many as DEC_DIGITS-1 excess digits at the end, and in addition we
     * need room for sign, decimal point, null terminator.
     */
    i = (var->weight + 1) * DEC_DIGITS;
    if (i <= 0)
        i = 1;
 
    str = palloc(i + dscale + DEC_DIGITS + 2);
    cp = str;
 
    /*
     * Output a dash for negative values
     */
    if (var->sign == NUMERIC_NEG)
        *cp++ = '-';
 
    /*
     * Output all digits before the decimal point
     */
    if (var->weight < 0)
    {
        d = var->weight + 1;
        *cp++ = '0';
    }
    else
    {
        for (d = 0; d <= var->weight; d++)
        {
            dig = (d < var->ndigits) ? var->digits[d] : 0;
            /* In the first digit, suppress extra leading decimal zeroes */
#if DEC_DIGITS == 4
            {
                bool        putit = (d > 0);
 
                d1 = dig / 1000;
                dig -= d1 * 1000;
                putit |= (d1 > 0);
                if (putit)
                    *cp++ = d1 + '0';
                d1 = dig / 100;
                dig -= d1 * 100;
                putit |= (d1 > 0);
                if (putit)
                    *cp++ = d1 + '0';
                d1 = dig / 10;
                dig -= d1 * 10;
                putit |= (d1 > 0);
                if (putit)
                    *cp++ = d1 + '0';
                *cp++ = dig + '0';
            }
#elif DEC_DIGITS == 2
            d1 = dig / 10;
            dig -= d1 * 10;
            if (d1 > 0 || d > 0)
                *cp++ = d1 + '0';
            *cp++ = dig + '0';
#elif DEC_DIGITS == 1
            *cp++ = dig + '0';
#else
#error unsupported NBASE
#endif
        }
    }
 
    /*
     * If requested, output a decimal point and all the digits that follow it.
     * We initially put out a multiple of DEC_DIGITS digits, then truncate if
     * needed.
     */
    if (dscale > 0)
    {
        *cp++ = '.';
        endcp = cp + dscale;
        for (i = 0; i < dscale; d++, i += DEC_DIGITS)
        {
            dig = (d >= 0 && d < var->ndigits) ? var->digits[d] : 0;
#if DEC_DIGITS == 4
            d1 = dig / 1000;
            dig -= d1 * 1000;
            *cp++ = d1 + '0';
            d1 = dig / 100;
            dig -= d1 * 100;
            *cp++ = d1 + '0';
            d1 = dig / 10;
            dig -= d1 * 10;
            *cp++ = d1 + '0';
            *cp++ = dig + '0';
#elif DEC_DIGITS == 2
            d1 = dig / 10;
            dig -= d1 * 10;
            *cp++ = d1 + '0';
            *cp++ = dig + '0';
#elif DEC_DIGITS == 1
            *cp++ = dig + '0';
#else
#error unsupported NBASE
#endif
        }
        cp = endcp;
    }
 
    /*
     * terminate the string and return it
     */
    *cp = '\0';
    return str;
}

References DEC_DIGITS, NumericVar::digits, NumericVar::dscale, i, NumericVar::ndigits, NUMERIC_NEG, palloc(), NumericVar::sign, str, and NumericVar::weight.

Referenced by get_str_from_var_sci(), numeric_normalize(), numeric_out(), and numericvar_to_double_no_overflow().

get_str_from_var_sci()

static char * get_str_from_var_sci ( const NumericVar *  var, int  rscale  )

static

Definition at line 7378 of file numeric.c.

{
    int32       exponent;
    NumericVar  tmp_var;
    size_t      len;
    char       *str;
    char       *sig_out;
 
    if (rscale < 0)
        rscale = 0;
 
    /*
     * Determine the exponent of this number in normalised form.
     *
     * This is the exponent required to represent the number with only one
     * significant digit before the decimal place.
     */
    if (var->ndigits > 0)
    {
        exponent = (var->weight + 1) * DEC_DIGITS;
 
        /*
         * Compensate for leading decimal zeroes in the first numeric digit by
         * decrementing the exponent.
         */
        exponent -= DEC_DIGITS - (int) log10(var->digits[0]);
    }
    else
    {
        /*
         * If var has no digits, then it must be zero.
         *
         * Zero doesn't technically have a meaningful exponent in normalised
         * notation, but we just display the exponent as zero for consistency
         * of output.
         */
        exponent = 0;
    }
 
    /*
     * Divide var by 10^exponent to get the significand, rounding to rscale
     * decimal digits in the process.
     */
    init_var(&tmp_var);
 
    power_ten_int(exponent, &tmp_var);
    div_var(var, &tmp_var, &tmp_var, rscale, true, true);
    sig_out = get_str_from_var(&tmp_var);
 
    free_var(&tmp_var);
 
    /*
     * Allocate space for the result.
     *
     * In addition to the significand, we need room for the exponent
     * decoration ("e"), the sign of the exponent, up to 10 digits for the
     * exponent itself, and of course the null terminator.
     */
    len = strlen(sig_out) + 13;
    str = palloc(len);
    snprintf(str, len, "%se%+03d", sig_out, exponent);
 
    pfree(sig_out);
 
    return str;
}

References DEC_DIGITS, NumericVar::digits, div_var(), free_var(), get_str_from_var(), init_var, len, NumericVar::ndigits, palloc(), pfree(), power_ten_int(), snprintf, str, and NumericVar::weight.

Referenced by numeric_out_sci().

hash_numeric()

Datum hash_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 2714 of file numeric.c.

{
    Numeric     key = PG_GETARG_NUMERIC(0);
    Datum       digit_hash;
    Datum       result;
    int         weight;
    int         start_offset;
    int         end_offset;
    int         i;
    int         hash_len;
    NumericDigit *digits;
 
    /* If it's NaN or infinity, don't try to hash the rest of the fields */
    if (NUMERIC_IS_SPECIAL(key))
        PG_RETURN_UINT32(0);
 
    weight = NUMERIC_WEIGHT(key);
    start_offset = 0;
    end_offset = 0;
 
    /*
     * Omit any leading or trailing zeros from the input to the hash. The
     * numeric implementation *should* guarantee that leading and trailing
     * zeros are suppressed, but we're paranoid. Note that we measure the
     * starting and ending offsets in units of NumericDigits, not bytes.
     */
    digits = NUMERIC_DIGITS(key);
    for (i = 0; i < NUMERIC_NDIGITS(key); i++)
    {
        if (digits[i] != (NumericDigit) 0)
            break;
 
        start_offset++;
 
        /*
         * The weight is effectively the # of digits before the decimal point,
         * so decrement it for each leading zero we skip.
         */
        weight--;
    }
 
    /*
     * If there are no non-zero digits, then the value of the number is zero,
     * regardless of any other fields.
     */
    if (NUMERIC_NDIGITS(key) == start_offset)
        PG_RETURN_UINT32(-1);
 
    for (i = NUMERIC_NDIGITS(key) - 1; i >= 0; i--)
    {
        if (digits[i] != (NumericDigit) 0)
            break;
 
        end_offset++;
    }
 
    /* If we get here, there should be at least one non-zero digit */
    Assert(start_offset + end_offset < NUMERIC_NDIGITS(key));
 
    /*
     * Note that we don't hash on the Numeric's scale, since two numerics can
     * compare equal but have different scales. We also don't hash on the
     * sign, although we could: since a sign difference implies inequality,
     * this shouldn't affect correctness.
     */
    hash_len = NUMERIC_NDIGITS(key) - start_offset - end_offset;
    digit_hash = hash_any((unsigned char *) (NUMERIC_DIGITS(key) + start_offset),
                          hash_len * sizeof(NumericDigit));
 
    /* Mix in the weight, via XOR */
    result = digit_hash ^ weight;
 
    PG_RETURN_DATUM(result);
}

References Assert(), digits, hash_any(), i, sort-test::key, NUMERIC_DIGITS, NUMERIC_IS_SPECIAL, NUMERIC_NDIGITS, NUMERIC_WEIGHT, PG_GETARG_NUMERIC, PG_RETURN_DATUM, and PG_RETURN_UINT32.

Referenced by JsonbHashScalarValue().

hash_numeric_extended()

Datum hash_numeric_extended

(

PG_FUNCTION_ARGS

)

Definition at line 2794 of file numeric.c.

{
    Numeric     key = PG_GETARG_NUMERIC(0);
    uint64      seed = PG_GETARG_INT64(1);
    Datum       digit_hash;
    Datum       result;
    int         weight;
    int         start_offset;
    int         end_offset;
    int         i;
    int         hash_len;
    NumericDigit *digits;
 
    /* If it's NaN or infinity, don't try to hash the rest of the fields */
    if (NUMERIC_IS_SPECIAL(key))
        PG_RETURN_UINT64(seed);
 
    weight = NUMERIC_WEIGHT(key);
    start_offset = 0;
    end_offset = 0;
 
    digits = NUMERIC_DIGITS(key);
    for (i = 0; i < NUMERIC_NDIGITS(key); i++)
    {
        if (digits[i] != (NumericDigit) 0)
            break;
 
        start_offset++;
 
        weight--;
    }
 
    if (NUMERIC_NDIGITS(key) == start_offset)
        PG_RETURN_UINT64(seed - 1);
 
    for (i = NUMERIC_NDIGITS(key) - 1; i >= 0; i--)
    {
        if (digits[i] != (NumericDigit) 0)
            break;
 
        end_offset++;
    }
 
    Assert(start_offset + end_offset < NUMERIC_NDIGITS(key));
 
    hash_len = NUMERIC_NDIGITS(key) - start_offset - end_offset;
    digit_hash = hash_any_extended((unsigned char *) (NUMERIC_DIGITS(key)
                                                      + start_offset),
                                   hash_len * sizeof(NumericDigit),
                                   seed);
 
    result = UInt64GetDatum(DatumGetUInt64(digit_hash) ^ weight);
 
    PG_RETURN_DATUM(result);
}

References Assert(), DatumGetUInt64(), digits, hash_any_extended(), i, sort-test::key, NUMERIC_DIGITS, NUMERIC_IS_SPECIAL, NUMERIC_NDIGITS, NUMERIC_WEIGHT, PG_GETARG_INT64, PG_GETARG_NUMERIC, PG_RETURN_DATUM, PG_RETURN_UINT64, and UInt64GetDatum().

Referenced by JsonbHashScalarValueExtended().

in_range_numeric_numeric()

Datum in_range_numeric_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 2579 of file numeric.c.

{
    Numeric     val = PG_GETARG_NUMERIC(0);
    Numeric     base = PG_GETARG_NUMERIC(1);
    Numeric     offset = PG_GETARG_NUMERIC(2);
    bool        sub = PG_GETARG_BOOL(3);
    bool        less = PG_GETARG_BOOL(4);
    bool        result;
 
    /*
     * Reject negative (including -Inf) or NaN offset.  Negative is per spec,
     * and NaN is because appropriate semantics for that seem non-obvious.
     */
    if (NUMERIC_IS_NAN(offset) ||
        NUMERIC_IS_NINF(offset) ||
        NUMERIC_SIGN(offset) == NUMERIC_NEG)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PRECEDING_OR_FOLLOWING_SIZE),
                 errmsg("invalid preceding or following size in window function")));
 
    /*
     * Deal with cases where val and/or base is NaN, following the rule that
     * NaN sorts after non-NaN (cf cmp_numerics).  The offset cannot affect
     * the conclusion.
     */
    if (NUMERIC_IS_NAN(val))
    {
        if (NUMERIC_IS_NAN(base))
            result = true;      /* NAN = NAN */
        else
            result = !less;     /* NAN > non-NAN */
    }
    else if (NUMERIC_IS_NAN(base))
    {
        result = less;          /* non-NAN < NAN */
    }
 
    /*
     * Deal with infinite offset (necessarily +Inf, at this point).
     */
    else if (NUMERIC_IS_SPECIAL(offset))
    {
        Assert(NUMERIC_IS_PINF(offset));
        if (sub ? NUMERIC_IS_PINF(base) : NUMERIC_IS_NINF(base))
        {
            /*
             * base +/- offset would produce NaN, so return true for any val
             * (see in_range_float8_float8() for reasoning).
             */
            result = true;
        }
        else if (sub)
        {
            /* base - offset must be -inf */
            if (less)
                result = NUMERIC_IS_NINF(val);  /* only -inf is <= sum */
            else
                result = true;  /* any val is >= sum */
        }
        else
        {
            /* base + offset must be +inf */
            if (less)
                result = true;  /* any val is <= sum */
            else
                result = NUMERIC_IS_PINF(val);  /* only +inf is >= sum */
        }
    }
 
    /*
     * Deal with cases where val and/or base is infinite.  The offset, being
     * now known finite, cannot affect the conclusion.
     */
    else if (NUMERIC_IS_SPECIAL(val))
    {
        if (NUMERIC_IS_PINF(val))
        {
            if (NUMERIC_IS_PINF(base))
                result = true;  /* PINF = PINF */
            else
                result = !less; /* PINF > any other non-NAN */
        }
        else                    /* val must be NINF */
        {
            if (NUMERIC_IS_NINF(base))
                result = true;  /* NINF = NINF */
            else
                result = less;  /* NINF < anything else */
        }
    }
    else if (NUMERIC_IS_SPECIAL(base))
    {
        if (NUMERIC_IS_NINF(base))
            result = !less;     /* normal > NINF */
        else
            result = less;      /* normal < PINF */
    }
    else
    {
        /*
         * Otherwise go ahead and compute base +/- offset.  While it's
         * possible for this to overflow the numeric format, it's unlikely
         * enough that we don't take measures to prevent it.
         */
        NumericVar  valv;
        NumericVar  basev;
        NumericVar  offsetv;
        NumericVar  sum;
 
        init_var_from_num(val, &valv);
        init_var_from_num(base, &basev);
        init_var_from_num(offset, &offsetv);
        init_var(&sum);
 
        if (sub)
            sub_var(&basev, &offsetv, &sum);
        else
            add_var(&basev, &offsetv, &sum);
 
        if (less)
            result = (cmp_var(&valv, &sum) <= 0);
        else
            result = (cmp_var(&valv, &sum) >= 0);
 
        free_var(&sum);
    }
 
    PG_FREE_IF_COPY(val, 0);
    PG_FREE_IF_COPY(base, 1);
    PG_FREE_IF_COPY(offset, 2);
 
    PG_RETURN_BOOL(result);
}

References add_var(), Assert(), cmp_var(), ereport, errcode(), errmsg(), ERROR, free_var(), init_var, init_var_from_num(), NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, NUMERIC_NEG, NUMERIC_SIGN, PG_FREE_IF_COPY, PG_GETARG_BOOL, PG_GETARG_NUMERIC, PG_RETURN_BOOL, sub_var(), and val.

init_var_from_num()

static void init_var_from_num ( Numeric  num, NumericVar *  dest  )

static

Definition at line 7182 of file numeric.c.

{
    dest->ndigits = NUMERIC_NDIGITS(num);
    dest->weight = NUMERIC_WEIGHT(num);
    dest->sign = NUMERIC_SIGN(num);
    dest->dscale = NUMERIC_DSCALE(num);
    dest->digits = NUMERIC_DIGITS(num);
    dest->buf = NULL;           /* digits array is not palloc'd */
}

References generate_unaccent_rules::dest, NUMERIC_DIGITS, NUMERIC_DSCALE, NUMERIC_NDIGITS, NUMERIC_SIGN, and NUMERIC_WEIGHT.

Referenced by compute_bucket(), do_numeric_accum(), do_numeric_discard(), generate_series_numeric_support(), generate_series_step_numeric(), in_range_numeric_numeric(), numeric_abbrev_convert(), numeric_add_safe(), numeric_ceil(), numeric_div_safe(), numeric_div_trunc(), numeric_exp(), numeric_float8_no_overflow(), numeric_floor(), numeric_gcd(), numeric_inc(), numeric_int2(), numeric_int4_safe(), numeric_int8_safe(), numeric_is_integral(), numeric_lcm(), numeric_ln(), numeric_log(), numeric_min_scale(), numeric_mod_safe(), numeric_mul_safe(), numeric_normalize(), numeric_out(), numeric_out_sci(), numeric_pg_lsn(), numeric_power(), numeric_send(), numeric_sqrt(), numeric_sub_safe(), numeric_trim_scale(), and random_numeric().

int128_deserialize()

static INT128 int128_deserialize ( StringInfo  buf )

inlinestatic

Definition at line 5579 of file numeric.c.

{
    int64       hi = pq_getmsgint64(buf);
    uint64      lo = pq_getmsgint64(buf);
 
    return make_int128(hi, lo);
}

References buf, make_int128(), and pq_getmsgint64().

Referenced by int8_avg_deserialize(), and numeric_poly_deserialize().

int128_serialize()

static void int128_serialize ( StringInfo  buf, INT128  val  )

inlinestatic

Definition at line 5569 of file numeric.c.

{
    pq_sendint64(buf, PG_INT128_HI_INT64(val));
    pq_sendint64(buf, PG_INT128_LO_UINT64(val));
}

References buf, PG_INT128_HI_INT64, PG_INT128_LO_UINT64, pq_sendint64(), and val.

Referenced by int8_avg_serialize(), and numeric_poly_serialize().

int128_to_numericvar()

static void int128_to_numericvar ( INT128  val, NumericVar *  var  )

static

Definition at line 7936 of file numeric.c.

{
    int         sign;
    NumericDigit *ptr;
    int         ndigits;
    int32       dig;
 
    /* int128 can require at most 39 decimal digits; add one for safety */
    alloc_var(var, 40 / DEC_DIGITS);
    sign = int128_sign(val);
    var->sign = sign < 0 ? NUMERIC_NEG : NUMERIC_POS;
    var->dscale = 0;
    if (sign == 0)
    {
        var->ndigits = 0;
        var->weight = 0;
        return;
    }
    ptr = var->digits + var->ndigits;
    ndigits = 0;
    do
    {
        ptr--;
        ndigits++;
        int128_div_mod_int32(&val, NBASE, &dig);
        *ptr = (NumericDigit) abs(dig);
    } while (!int128_is_zero(val));
    var->digits = ptr;
    var->ndigits = ndigits;
    var->weight = ndigits - 1;
}

References alloc_var(), DEC_DIGITS, NumericVar::digits, NumericVar::dscale, int128_div_mod_int32(), int128_is_zero(), int128_sign(), NBASE, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, NumericVar::sign, sign, val, and NumericVar::weight.

Referenced by int64_div_fast_to_numeric(), numeric_poly_avg(), numeric_poly_stddev_internal(), numeric_poly_sum(), and sqrt_var().

int2_accum()

Datum int2_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5471 of file numeric.c.

{
    Int128AggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    /* Create the state data on the first call */
    if (state == NULL)
        state = makeInt128AggState(fcinfo, true);
 
    if (!PG_ARGISNULL(1))
        do_int128_accum(state, PG_GETARG_INT16(1));
 
    PG_RETURN_POINTER(state);
}

References do_int128_accum(), makeInt128AggState(), PG_ARGISNULL, PG_GETARG_INT16, PG_GETARG_POINTER, and PG_RETURN_POINTER.

int2_accum_inv()

Datum int2_accum_inv

(

PG_FUNCTION_ARGS

)

Definition at line 5797 of file numeric.c.

{
    Int128AggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    /* Should not get here with no state */
    if (state == NULL)
        elog(ERROR, "int2_accum_inv called with NULL state");
 
    if (!PG_ARGISNULL(1))
        do_int128_discard(state, PG_GETARG_INT16(1));
 
    PG_RETURN_POINTER(state);
}

References do_int128_discard(), elog, ERROR, PG_ARGISNULL, PG_GETARG_INT16, PG_GETARG_POINTER, and PG_RETURN_POINTER.

int2_avg_accum()

Datum int2_avg_accum

(

PG_FUNCTION_ARGS

)

Definition at line 6388 of file numeric.c.

{
    ArrayType  *transarray;
    int16       newval = PG_GETARG_INT16(1);
    Int8TransTypeData *transdata;
 
    /*
     * If we're invoked as an aggregate, we can cheat and modify our first
     * parameter in-place to reduce palloc overhead. Otherwise we need to make
     * a copy of it before scribbling on it.
     */
    if (AggCheckCallContext(fcinfo, NULL))
        transarray = PG_GETARG_ARRAYTYPE_P(0);
    else
        transarray = PG_GETARG_ARRAYTYPE_P_COPY(0);
 
    if (ARR_HASNULL(transarray) ||
        ARR_SIZE(transarray) != ARR_OVERHEAD_NONULLS(1) + sizeof(Int8TransTypeData))
        elog(ERROR, "expected 2-element int8 array");
 
    transdata = (Int8TransTypeData *) ARR_DATA_PTR(transarray);
    transdata->count++;
    transdata->sum += newval;
 
    PG_RETURN_ARRAYTYPE_P(transarray);
}

References AggCheckCallContext(), ARR_DATA_PTR, ARR_HASNULL, ARR_OVERHEAD_NONULLS, ARR_SIZE, Int8TransTypeData::count, elog, ERROR, newval, PG_GETARG_ARRAYTYPE_P, PG_GETARG_ARRAYTYPE_P_COPY, PG_GETARG_INT16, PG_RETURN_ARRAYTYPE_P, and Int8TransTypeData::sum.

int2_avg_accum_inv()

Datum int2_avg_accum_inv

(

PG_FUNCTION_ARGS

)

Definition at line 6475 of file numeric.c.

{
    ArrayType  *transarray;
    int16       newval = PG_GETARG_INT16(1);
    Int8TransTypeData *transdata;
 
    /*
     * If we're invoked as an aggregate, we can cheat and modify our first
     * parameter in-place to reduce palloc overhead. Otherwise we need to make
     * a copy of it before scribbling on it.
     */
    if (AggCheckCallContext(fcinfo, NULL))
        transarray = PG_GETARG_ARRAYTYPE_P(0);
    else
        transarray = PG_GETARG_ARRAYTYPE_P_COPY(0);
 
    if (ARR_HASNULL(transarray) ||
        ARR_SIZE(transarray) != ARR_OVERHEAD_NONULLS(1) + sizeof(Int8TransTypeData))
        elog(ERROR, "expected 2-element int8 array");
 
    transdata = (Int8TransTypeData *) ARR_DATA_PTR(transarray);
    transdata->count--;
    transdata->sum -= newval;
 
    PG_RETURN_ARRAYTYPE_P(transarray);
}

References AggCheckCallContext(), ARR_DATA_PTR, ARR_HASNULL, ARR_OVERHEAD_NONULLS, ARR_SIZE, Int8TransTypeData::count, elog, ERROR, newval, PG_GETARG_ARRAYTYPE_P, PG_GETARG_ARRAYTYPE_P_COPY, PG_GETARG_INT16, PG_RETURN_ARRAYTYPE_P, and Int8TransTypeData::sum.

int2_numeric()

Datum int2_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 4473 of file numeric.c.

{
    int16       val = PG_GETARG_INT16(0);
 
    PG_RETURN_NUMERIC(int64_to_numeric(val));
}

References int64_to_numeric(), PG_GETARG_INT16, PG_RETURN_NUMERIC, and val.

Referenced by JsonItemFromDatum().

int2_sum()

Datum int2_sum

(

PG_FUNCTION_ARGS

)

Definition at line 6281 of file numeric.c.

{
    int64       oldsum;
    int64       newval;
 
    if (PG_ARGISNULL(0))
    {
        /* No non-null input seen so far... */
        if (PG_ARGISNULL(1))
            PG_RETURN_NULL();   /* still no non-null */
        /* This is the first non-null input. */
        newval = (int64) PG_GETARG_INT16(1);
        PG_RETURN_INT64(newval);
    }
 
    oldsum = PG_GETARG_INT64(0);
 
    /* Leave sum unchanged if new input is null. */
    if (PG_ARGISNULL(1))
        PG_RETURN_INT64(oldsum);
 
    /* OK to do the addition. */
    newval = oldsum + (int64) PG_GETARG_INT16(1);
 
    PG_RETURN_INT64(newval);
}

References newval, PG_ARGISNULL, PG_GETARG_INT16, PG_GETARG_INT64, PG_RETURN_INT64, and PG_RETURN_NULL.

int2int4_sum()

Datum int2int4_sum

(

PG_FUNCTION_ARGS

)

Definition at line 6558 of file numeric.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    Int8TransTypeData *transdata;
 
    if (ARR_HASNULL(transarray) ||
        ARR_SIZE(transarray) != ARR_OVERHEAD_NONULLS(1) + sizeof(Int8TransTypeData))
        elog(ERROR, "expected 2-element int8 array");
    transdata = (Int8TransTypeData *) ARR_DATA_PTR(transarray);
 
    /* SQL defines SUM of no values to be NULL */
    if (transdata->count == 0)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(Int64GetDatumFast(transdata->sum));
}

References ARR_DATA_PTR, ARR_HASNULL, ARR_OVERHEAD_NONULLS, ARR_SIZE, Int8TransTypeData::count, elog, ERROR, Int64GetDatumFast, PG_GETARG_ARRAYTYPE_P, PG_RETURN_DATUM, PG_RETURN_NULL, and Int8TransTypeData::sum.

int4_accum()

Datum int4_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5488 of file numeric.c.

{
    Int128AggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    /* Create the state data on the first call */
    if (state == NULL)
        state = makeInt128AggState(fcinfo, true);
 
    if (!PG_ARGISNULL(1))
        do_int128_accum(state, PG_GETARG_INT32(1));
 
    PG_RETURN_POINTER(state);
}

References do_int128_accum(), makeInt128AggState(), PG_ARGISNULL, PG_GETARG_INT32, PG_GETARG_POINTER, and PG_RETURN_POINTER.

int4_accum_inv()

Datum int4_accum_inv

(

PG_FUNCTION_ARGS

)

Definition at line 5814 of file numeric.c.

{
    Int128AggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    /* Should not get here with no state */
    if (state == NULL)
        elog(ERROR, "int4_accum_inv called with NULL state");
 
    if (!PG_ARGISNULL(1))
        do_int128_discard(state, PG_GETARG_INT32(1));
 
    PG_RETURN_POINTER(state);
}

References do_int128_discard(), elog, ERROR, PG_ARGISNULL, PG_GETARG_INT32, PG_GETARG_POINTER, and PG_RETURN_POINTER.

int4_avg_accum()

Datum int4_avg_accum

(

PG_FUNCTION_ARGS

)

Definition at line 6416 of file numeric.c.

{
    ArrayType  *transarray;
    int32       newval = PG_GETARG_INT32(1);
    Int8TransTypeData *transdata;
 
    /*
     * If we're invoked as an aggregate, we can cheat and modify our first
     * parameter in-place to reduce palloc overhead. Otherwise we need to make
     * a copy of it before scribbling on it.
     */
    if (AggCheckCallContext(fcinfo, NULL))
        transarray = PG_GETARG_ARRAYTYPE_P(0);
    else
        transarray = PG_GETARG_ARRAYTYPE_P_COPY(0);
 
    if (ARR_HASNULL(transarray) ||
        ARR_SIZE(transarray) != ARR_OVERHEAD_NONULLS(1) + sizeof(Int8TransTypeData))
        elog(ERROR, "expected 2-element int8 array");
 
    transdata = (Int8TransTypeData *) ARR_DATA_PTR(transarray);
    transdata->count++;
    transdata->sum += newval;
 
    PG_RETURN_ARRAYTYPE_P(transarray);
}

References AggCheckCallContext(), ARR_DATA_PTR, ARR_HASNULL, ARR_OVERHEAD_NONULLS, ARR_SIZE, Int8TransTypeData::count, elog, ERROR, newval, PG_GETARG_ARRAYTYPE_P, PG_GETARG_ARRAYTYPE_P_COPY, PG_GETARG_INT32, PG_RETURN_ARRAYTYPE_P, and Int8TransTypeData::sum.

int4_avg_accum_inv()

Datum int4_avg_accum_inv

(

PG_FUNCTION_ARGS

)

Definition at line 6503 of file numeric.c.

{
    ArrayType  *transarray;
    int32       newval = PG_GETARG_INT32(1);
    Int8TransTypeData *transdata;
 
    /*
     * If we're invoked as an aggregate, we can cheat and modify our first
     * parameter in-place to reduce palloc overhead. Otherwise we need to make
     * a copy of it before scribbling on it.
     */
    if (AggCheckCallContext(fcinfo, NULL))
        transarray = PG_GETARG_ARRAYTYPE_P(0);
    else
        transarray = PG_GETARG_ARRAYTYPE_P_COPY(0);
 
    if (ARR_HASNULL(transarray) ||
        ARR_SIZE(transarray) != ARR_OVERHEAD_NONULLS(1) + sizeof(Int8TransTypeData))
        elog(ERROR, "expected 2-element int8 array");
 
    transdata = (Int8TransTypeData *) ARR_DATA_PTR(transarray);
    transdata->count--;
    transdata->sum -= newval;
 
    PG_RETURN_ARRAYTYPE_P(transarray);
}

References AggCheckCallContext(), ARR_DATA_PTR, ARR_HASNULL, ARR_OVERHEAD_NONULLS, ARR_SIZE, Int8TransTypeData::count, elog, ERROR, newval, PG_GETARG_ARRAYTYPE_P, PG_GETARG_ARRAYTYPE_P_COPY, PG_GETARG_INT32, PG_RETURN_ARRAYTYPE_P, and Int8TransTypeData::sum.

int4_avg_combine()

Datum int4_avg_combine

(

PG_FUNCTION_ARGS

)

Definition at line 6444 of file numeric.c.

{
    ArrayType  *transarray1;
    ArrayType  *transarray2;
    Int8TransTypeData *state1;
    Int8TransTypeData *state2;
 
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    transarray1 = PG_GETARG_ARRAYTYPE_P(0);
    transarray2 = PG_GETARG_ARRAYTYPE_P(1);
 
    if (ARR_HASNULL(transarray1) ||
        ARR_SIZE(transarray1) != ARR_OVERHEAD_NONULLS(1) + sizeof(Int8TransTypeData))
        elog(ERROR, "expected 2-element int8 array");
 
    if (ARR_HASNULL(transarray2) ||
        ARR_SIZE(transarray2) != ARR_OVERHEAD_NONULLS(1) + sizeof(Int8TransTypeData))
        elog(ERROR, "expected 2-element int8 array");
 
    state1 = (Int8TransTypeData *) ARR_DATA_PTR(transarray1);
    state2 = (Int8TransTypeData *) ARR_DATA_PTR(transarray2);
 
    state1->count += state2->count;
    state1->sum += state2->sum;
 
    PG_RETURN_ARRAYTYPE_P(transarray1);
}

References AggCheckCallContext(), ARR_DATA_PTR, ARR_HASNULL, ARR_OVERHEAD_NONULLS, ARR_SIZE, Int8TransTypeData::count, elog, ERROR, PG_GETARG_ARRAYTYPE_P, PG_RETURN_ARRAYTYPE_P, and Int8TransTypeData::sum.

int4_numeric()

Datum int4_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 4354 of file numeric.c.

{
    int32       val = PG_GETARG_INT32(0);
 
    PG_RETURN_NUMERIC(int64_to_numeric(val));
}

References int64_to_numeric(), PG_GETARG_INT32, PG_RETURN_NUMERIC, and val.

Referenced by executeItemOptUnwrapTarget(), and JsonItemFromDatum().

int4_sum()

Datum int4_sum

(

PG_FUNCTION_ARGS

)

Definition at line 6309 of file numeric.c.

{
    int64       oldsum;
    int64       newval;
 
    if (PG_ARGISNULL(0))
    {
        /* No non-null input seen so far... */
        if (PG_ARGISNULL(1))
            PG_RETURN_NULL();   /* still no non-null */
        /* This is the first non-null input. */
        newval = (int64) PG_GETARG_INT32(1);
        PG_RETURN_INT64(newval);
    }
 
    oldsum = PG_GETARG_INT64(0);
 
    /* Leave sum unchanged if new input is null. */
    if (PG_ARGISNULL(1))
        PG_RETURN_INT64(oldsum);
 
    /* OK to do the addition. */
    newval = oldsum + (int64) PG_GETARG_INT32(1);
 
    PG_RETURN_INT64(newval);
}

References newval, PG_ARGISNULL, PG_GETARG_INT32, PG_GETARG_INT64, PG_RETURN_INT64, and PG_RETURN_NULL.

int64_div_fast_to_numeric()

Numeric int64_div_fast_to_numeric	(	int64	val1,
		int	log10val2
	)

Definition at line 4281 of file numeric.c.

{
    Numeric     res;
    NumericVar  result;
    int         rscale;
    int         w;
    int         m;
 
    init_var(&result);
 
    /* result scale */
    rscale = log10val2 < 0 ? 0 : log10val2;
 
    /* how much to decrease the weight by */
    w = log10val2 / DEC_DIGITS;
    /* how much is left to divide by */
    m = log10val2 % DEC_DIGITS;
    if (m < 0)
    {
        m += DEC_DIGITS;
        w--;
    }
 
    /*
     * If there is anything left to divide by (10^m with 0 < m < DEC_DIGITS),
     * multiply the dividend by 10^(DEC_DIGITS - m), and shift the weight by
     * one more.
     */
    if (m > 0)
    {
#if DEC_DIGITS == 4
        static const int pow10[] = {1, 10, 100, 1000};
#elif DEC_DIGITS == 2
        static const int pow10[] = {1, 10};
#elif DEC_DIGITS == 1
        static const int pow10[] = {1};
#else
#error unsupported NBASE
#endif
        int64       factor = pow10[DEC_DIGITS - m];
        int64       new_val1;
 
        StaticAssertDecl(lengthof(pow10) == DEC_DIGITS, "mismatch with DEC_DIGITS");
 
        if (unlikely(pg_mul_s64_overflow(val1, factor, &new_val1)))
        {
            /* do the multiplication using 128-bit integers */
            INT128      tmp;
 
            tmp = int64_to_int128(0);
            int128_add_int64_mul_int64(&tmp, val1, factor);
 
            int128_to_numericvar(tmp, &result);
        }
        else
            int64_to_numericvar(new_val1, &result);
 
        w++;
    }
    else
        int64_to_numericvar(val1, &result);
 
    result.weight -= w;
    result.dscale = rscale;
 
    res = make_result(&result);
 
    free_var(&result);
 
    return res;
}

References DEC_DIGITS, NumericVar::dscale, free_var(), init_var, int128_add_int64_mul_int64(), int128_to_numericvar(), int64_to_int128(), int64_to_numericvar(), lengthof, make_result(), pg_mul_s64_overflow(), StaticAssertDecl, unlikely, and NumericVar::weight.

Referenced by interval_part_common(), time_part_common(), timestamp_part_common(), timestamptz_part_common(), and timetz_part_common().

int64_to_numeric()

Numeric int64_to_numeric

(

int64

val

)

Definition at line 4260 of file numeric.c.

{
    Numeric     res;
    NumericVar  result;
 
    init_var(&result);
 
    int64_to_numericvar(val, &result);
 
    res = make_result(&result);
 
    free_var(&result);
 
    return res;
}

References free_var(), init_var, int64_to_numericvar(), make_result(), and val.

Referenced by cash_numeric(), executeItemOptUnwrapTarget(), executeKeyValueMethod(), extract_date(), gbt_numeric_penalty(), int2_numeric(), int4_numeric(), int8_accum(), int8_accum_inv(), int8_avg(), int8_numeric(), int8_sum(), int8_to_char(), interval_part_common(), numeric_avg(), numeric_cash(), numeric_half_rounded(), numeric_poly_avg(), numeric_to_char(), numeric_to_number(), numeric_truncated_divide(), pg_size_bytes(), pg_size_pretty_numeric(), SV_to_JsonbValue(), time_part_common(), timestamp_part_common(), timestamptz_part_common(), and timetz_part_common().

int64_to_numericvar()

static void int64_to_numericvar ( int64  val, NumericVar *  var  )

static

Definition at line 7819 of file numeric.c.

{
    uint64      uval,
                newuval;
    NumericDigit *ptr;
    int         ndigits;
 
    /* int64 can require at most 19 decimal digits; add one for safety */
    alloc_var(var, 20 / DEC_DIGITS);
    if (val < 0)
    {
        var->sign = NUMERIC_NEG;
        uval = pg_abs_s64(val);
    }
    else
    {
        var->sign = NUMERIC_POS;
        uval = val;
    }
    var->dscale = 0;
    if (val == 0)
    {
        var->ndigits = 0;
        var->weight = 0;
        return;
    }
    ptr = var->digits + var->ndigits;
    ndigits = 0;
    do
    {
        ptr--;
        ndigits++;
        newuval = uval / NBASE;
        *ptr = uval - newuval * NBASE;
        uval = newuval;
    } while (uval);
    var->digits = ptr;
    var->ndigits = ndigits;
    var->weight = ndigits - 1;
}

References alloc_var(), DEC_DIGITS, NumericVar::digits, NumericVar::dscale, NBASE, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, pg_abs_s64(), NumericVar::sign, val, and NumericVar::weight.

Referenced by int64_div_fast_to_numeric(), int64_to_numeric(), numeric_fac(), numeric_stddev_internal(), set_var_from_non_decimal_integer_str(), sqrt_var(), and width_bucket_numeric().

int8_accum()

Datum int8_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5505 of file numeric.c.

{
    NumericAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    /* Create the state data on the first call */
    if (state == NULL)
        state = makeNumericAggState(fcinfo, true);
 
    if (!PG_ARGISNULL(1))
        do_numeric_accum(state, int64_to_numeric(PG_GETARG_INT64(1)));
 
    PG_RETURN_POINTER(state);
}

References do_numeric_accum(), int64_to_numeric(), makeNumericAggState(), PG_ARGISNULL, PG_GETARG_INT64, PG_GETARG_POINTER, and PG_RETURN_POINTER.

int8_accum_inv()

Datum int8_accum_inv

(

PG_FUNCTION_ARGS

)

Definition at line 5831 of file numeric.c.

{
    NumericAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    /* Should not get here with no state */
    if (state == NULL)
        elog(ERROR, "int8_accum_inv called with NULL state");
 
    if (!PG_ARGISNULL(1))
    {
        /* Should never fail, all inputs have dscale 0 */
        if (!do_numeric_discard(state, int64_to_numeric(PG_GETARG_INT64(1))))
            elog(ERROR, "do_numeric_discard failed unexpectedly");
    }
 
    PG_RETURN_POINTER(state);
}

References do_numeric_discard(), elog, ERROR, int64_to_numeric(), PG_ARGISNULL, PG_GETARG_INT64, PG_GETARG_POINTER, and PG_RETURN_POINTER.

int8_avg()

Datum int8_avg

(

PG_FUNCTION_ARGS

)

Definition at line 6531 of file numeric.c.

{
    ArrayType  *transarray = PG_GETARG_ARRAYTYPE_P(0);
    Int8TransTypeData *transdata;
    Datum       countd,
                sumd;
 
    if (ARR_HASNULL(transarray) ||
        ARR_SIZE(transarray) != ARR_OVERHEAD_NONULLS(1) + sizeof(Int8TransTypeData))
        elog(ERROR, "expected 2-element int8 array");
    transdata = (Int8TransTypeData *) ARR_DATA_PTR(transarray);
 
    /* SQL defines AVG of no values to be NULL */
    if (transdata->count == 0)
        PG_RETURN_NULL();
 
    countd = NumericGetDatum(int64_to_numeric(transdata->count));
    sumd = NumericGetDatum(int64_to_numeric(transdata->sum));
 
    PG_RETURN_DATUM(DirectFunctionCall2(numeric_div, sumd, countd));
}

References ARR_DATA_PTR, ARR_HASNULL, ARR_OVERHEAD_NONULLS, ARR_SIZE, Int8TransTypeData::count, DirectFunctionCall2, elog, ERROR, int64_to_numeric(), numeric_div(), NumericGetDatum(), PG_GETARG_ARRAYTYPE_P, PG_RETURN_DATUM, PG_RETURN_NULL, and Int8TransTypeData::sum.

int8_avg_accum()

Datum int8_avg_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5665 of file numeric.c.

{
    Int128AggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    /* Create the state data on the first call */
    if (state == NULL)
        state = makeInt128AggState(fcinfo, false);
 
    if (!PG_ARGISNULL(1))
        do_int128_accum(state, PG_GETARG_INT64(1));
 
    PG_RETURN_POINTER(state);
}

References do_int128_accum(), makeInt128AggState(), PG_ARGISNULL, PG_GETARG_INT64, PG_GETARG_POINTER, and PG_RETURN_POINTER.

int8_avg_accum_inv()

Datum int8_avg_accum_inv

(

PG_FUNCTION_ARGS

)

Definition at line 5852 of file numeric.c.

{
    Int128AggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    /* Should not get here with no state */
    if (state == NULL)
        elog(ERROR, "int8_avg_accum_inv called with NULL state");
 
    if (!PG_ARGISNULL(1))
        do_int128_discard(state, PG_GETARG_INT64(1));
 
    PG_RETURN_POINTER(state);
}

References do_int128_discard(), elog, ERROR, PG_ARGISNULL, PG_GETARG_INT64, PG_GETARG_POINTER, and PG_RETURN_POINTER.

int8_avg_combine()

Datum int8_avg_combine

(

PG_FUNCTION_ARGS

)

Definition at line 5686 of file numeric.c.

{
    Int128AggState *state1;
    Int128AggState *state2;
    MemoryContext agg_context;
    MemoryContext old_context;
 
    if (!AggCheckCallContext(fcinfo, &agg_context))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state1 = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
    state2 = PG_ARGISNULL(1) ? NULL : (Int128AggState *) PG_GETARG_POINTER(1);
 
    if (state2 == NULL)
        PG_RETURN_POINTER(state1);
 
    /* manually copy all fields from state2 to state1 */
    if (state1 == NULL)
    {
        old_context = MemoryContextSwitchTo(agg_context);
 
        state1 = makeInt128AggState(fcinfo, false);
        state1->N = state2->N;
        state1->sumX = state2->sumX;
 
        MemoryContextSwitchTo(old_context);
 
        PG_RETURN_POINTER(state1);
    }
 
    if (state2->N > 0)
    {
        state1->N += state2->N;
        int128_add_int128(&state1->sumX, state2->sumX);
    }
    PG_RETURN_POINTER(state1);
}

References AggCheckCallContext(), elog, ERROR, int128_add_int128(), makeInt128AggState(), MemoryContextSwitchTo(), Int128AggState::N, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_POINTER, and Int128AggState::sumX.

int8_avg_deserialize()

Datum int8_avg_deserialize

(

PG_FUNCTION_ARGS

)

Definition at line 5761 of file numeric.c.

{
    bytea      *sstate;
    Int128AggState *result;
    StringInfoData buf;
 
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    sstate = PG_GETARG_BYTEA_PP(0);
 
    /*
     * Initialize a StringInfo so that we can "receive" it using the standard
     * recv-function infrastructure.
     */
    initReadOnlyStringInfo(&buf, VARDATA_ANY(sstate),
                           VARSIZE_ANY_EXHDR(sstate));
 
    result = makeInt128AggStateCurrentContext(false);
 
    /* N */
    result->N = pq_getmsgint64(&buf);
 
    /* sumX */
    result->sumX = int128_deserialize(&buf);
 
    pq_getmsgend(&buf);
 
    PG_RETURN_POINTER(result);
}

References AggCheckCallContext(), buf, elog, ERROR, initReadOnlyStringInfo(), int128_deserialize(), makeInt128AggStateCurrentContext(), Int128AggState::N, PG_GETARG_BYTEA_PP, PG_RETURN_POINTER, pq_getmsgend(), pq_getmsgint64(), Int128AggState::sumX, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

int8_avg_serialize()

Datum int8_avg_serialize

(

PG_FUNCTION_ARGS

)

Definition at line 5730 of file numeric.c.

{
    Int128AggState *state;
    StringInfoData buf;
    bytea      *result;
 
    /* Ensure we disallow calling when not in aggregate context */
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state = (Int128AggState *) PG_GETARG_POINTER(0);
 
    pq_begintypsend(&buf);
 
    /* N */
    pq_sendint64(&buf, state->N);
 
    /* sumX */
    int128_serialize(&buf, state->sumX);
 
    result = pq_endtypsend(&buf);
 
    PG_RETURN_BYTEA_P(result);
}

References AggCheckCallContext(), buf, elog, ERROR, int128_serialize(), PG_GETARG_POINTER, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendint64().

int8_numeric()

Datum int8_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 4424 of file numeric.c.

{
    int64       val = PG_GETARG_INT64(0);
 
    PG_RETURN_NUMERIC(int64_to_numeric(val));
}

References int64_to_numeric(), PG_GETARG_INT64, PG_RETURN_NUMERIC, and val.

Referenced by executeItemOptUnwrapTarget(), and JsonItemFromDatum().

int8_sum()

Datum int8_sum

(

PG_FUNCTION_ARGS

)

Definition at line 6340 of file numeric.c.

{
    Numeric     oldsum;
 
    if (PG_ARGISNULL(0))
    {
        /* No non-null input seen so far... */
        if (PG_ARGISNULL(1))
            PG_RETURN_NULL();   /* still no non-null */
        /* This is the first non-null input. */
        PG_RETURN_NUMERIC(int64_to_numeric(PG_GETARG_INT64(1)));
    }
 
    /*
     * Note that we cannot special-case the aggregate case here, as we do for
     * int2_sum and int4_sum: numeric is of variable size, so we cannot modify
     * our first parameter in-place.
     */
 
    oldsum = PG_GETARG_NUMERIC(0);
 
    /* Leave sum unchanged if new input is null. */
    if (PG_ARGISNULL(1))
        PG_RETURN_NUMERIC(oldsum);
 
    /* OK to do the addition. */
    PG_RETURN_DATUM(DirectFunctionCall2(numeric_add,
                                        NumericGetDatum(oldsum),
                                        NumericGetDatum(int64_to_numeric(PG_GETARG_INT64(1)))));
}

References DirectFunctionCall2, int64_to_numeric(), numeric_add(), NumericGetDatum(), PG_ARGISNULL, PG_GETARG_INT64, PG_GETARG_NUMERIC, PG_RETURN_DATUM, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

is_valid_numeric_typmod()

static bool is_valid_numeric_typmod ( int32  typmod )

inlinestatic

Definition at line 899 of file numeric.c.

{
    return typmod >= (int32) VARHDRSZ;
}

References VARHDRSZ.

Referenced by apply_typmod(), apply_typmod_special(), numeric(), numeric_maximum_size(), numeric_support(), and numerictypmodout().

ln_var()

static void ln_var ( const NumericVar *  arg, NumericVar *  result, int  rscale  )

static

Definition at line 10623 of file numeric.c.

{
    NumericVar  x;
    NumericVar  xx;
    int         ni;
    NumericVar  elem;
    NumericVar  fact;
    int         nsqrt;
    int         local_rscale;
    int         cmp;
 
    cmp = cmp_var(arg, &const_zero);
    if (cmp == 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
                 errmsg("cannot take logarithm of zero")));
    else if (cmp < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
                 errmsg("cannot take logarithm of a negative number")));
 
    init_var(&x);
    init_var(&xx);
    init_var(&elem);
    init_var(&fact);
 
    set_var_from_var(arg, &x);
    set_var_from_var(&const_two, &fact);
 
    /*
     * Reduce input into range 0.9 < x < 1.1 with repeated sqrt() operations.
     *
     * The final logarithm will have up to around rscale+6 significant digits.
     * Each sqrt() will roughly halve the weight of x, so adjust the local
     * rscale as we work so that we keep this many significant digits at each
     * step (plus a few more for good measure).
     *
     * Note that we allow local_rscale < 0 during this input reduction
     * process, which implies rounding before the decimal point.  sqrt_var()
     * explicitly supports this, and it significantly reduces the work
     * required to reduce very large inputs to the required range.  Once the
     * input reduction is complete, x.weight will be 0 and its display scale
     * will be non-negative again.
     */
    nsqrt = 0;
    while (cmp_var(&x, &const_zero_point_nine) <= 0)
    {
        local_rscale = rscale - x.weight * DEC_DIGITS / 2 + 8;
        sqrt_var(&x, &x, local_rscale);
        mul_var(&fact, &const_two, &fact, 0);
        nsqrt++;
    }
    while (cmp_var(&x, &const_one_point_one) >= 0)
    {
        local_rscale = rscale - x.weight * DEC_DIGITS / 2 + 8;
        sqrt_var(&x, &x, local_rscale);
        mul_var(&fact, &const_two, &fact, 0);
        nsqrt++;
    }
 
    /*
     * We use the Taylor series for 0.5 * ln((1+z)/(1-z)),
     *
     * z + z^3/3 + z^5/5 + ...
     *
     * where z = (x-1)/(x+1) is in the range (approximately) -0.053 .. 0.048
     * due to the above range-reduction of x.
     *
     * The convergence of this is not as fast as one would like, but is
     * tolerable given that z is small.
     *
     * The Taylor series result will be multiplied by 2^(nsqrt+1), which has a
     * decimal weight of (nsqrt+1) * log10(2), so work with this many extra
     * digits of precision (plus a few more for good measure).
     */
    local_rscale = rscale + (int) ((nsqrt + 1) * 0.301029995663981) + 8;
 
    sub_var(&x, &const_one, result);
    add_var(&x, &const_one, &elem);
    div_var(result, &elem, result, local_rscale, true, false);
    set_var_from_var(result, &xx);
    mul_var(result, result, &x, local_rscale);
 
    ni = 1;
 
    for (;;)
    {
        ni += 2;
        mul_var(&xx, &x, &xx, local_rscale);
        div_var_int(&xx, ni, 0, &elem, local_rscale, true);
 
        if (elem.ndigits == 0)
            break;
 
        add_var(result, &elem, result);
 
        if (elem.weight < (result->weight - local_rscale * 2 / DEC_DIGITS))
            break;
    }
 
    /* Compensate for argument range reduction, round to requested rscale */
    mul_var(result, &fact, result, rscale);
 
    free_var(&x);
    free_var(&xx);
    free_var(&elem);
    free_var(&fact);
}

References add_var(), arg, cmp(), cmp_var(), const_one, const_one_point_one, const_two, const_zero, const_zero_point_nine, DEC_DIGITS, div_var(), div_var_int(), ereport, errcode(), errmsg(), ERROR, free_var(), init_var, mul_var(), NumericVar::ndigits, set_var_from_var(), sqrt_var(), sub_var(), NumericVar::weight, and x.

Referenced by estimate_ln_dweight(), log_var(), numeric_ln(), and power_var().

log_var()

static void log_var ( const NumericVar *  base, const NumericVar *  num, NumericVar *  result  )

static

Definition at line 10741 of file numeric.c.

{
    NumericVar  ln_base;
    NumericVar  ln_num;
    int         ln_base_dweight;
    int         ln_num_dweight;
    int         result_dweight;
    int         rscale;
    int         ln_base_rscale;
    int         ln_num_rscale;
 
    init_var(&ln_base);
    init_var(&ln_num);
 
    /* Estimated dweights of ln(base), ln(num) and the final result */
    ln_base_dweight = estimate_ln_dweight(base);
    ln_num_dweight = estimate_ln_dweight(num);
    result_dweight = ln_num_dweight - ln_base_dweight;
 
    /*
     * Select the scale of the result so that it will have at least
     * NUMERIC_MIN_SIG_DIGITS significant digits and is not less than either
     * input's display scale.
     */
    rscale = NUMERIC_MIN_SIG_DIGITS - result_dweight;
    rscale = Max(rscale, base->dscale);
    rscale = Max(rscale, num->dscale);
    rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
    rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);
 
    /*
     * Set the scales for ln(base) and ln(num) so that they each have more
     * significant digits than the final result.
     */
    ln_base_rscale = rscale + result_dweight - ln_base_dweight + 8;
    ln_base_rscale = Max(ln_base_rscale, NUMERIC_MIN_DISPLAY_SCALE);
 
    ln_num_rscale = rscale + result_dweight - ln_num_dweight + 8;
    ln_num_rscale = Max(ln_num_rscale, NUMERIC_MIN_DISPLAY_SCALE);
 
    /* Form natural logarithms */
    ln_var(base, &ln_base, ln_base_rscale);
    ln_var(num, &ln_num, ln_num_rscale);
 
    /* Divide and round to the required scale */
    div_var(&ln_num, &ln_base, result, rscale, true, false);
 
    free_var(&ln_num);
    free_var(&ln_base);
}

References div_var(), NumericVar::dscale, estimate_ln_dweight(), free_var(), init_var, ln_var(), Max, Min, NUMERIC_MAX_DISPLAY_SCALE, NUMERIC_MIN_DISPLAY_SCALE, and NUMERIC_MIN_SIG_DIGITS.

Referenced by numeric_log().

make_numeric_typmod()

static int32 make_numeric_typmod ( int  precision, int  scale  )

inlinestatic

Definition at line 890 of file numeric.c.

{
    return ((precision << 16) | (scale & 0x7ff)) + VARHDRSZ;
}

References scale, and VARHDRSZ.

Referenced by numerictypmodin().

make_result()

static Numeric make_result ( const NumericVar *  var )

static

Definition at line 7606 of file numeric.c.

{
    return make_result_safe(var, NULL);
}

References make_result_safe().

Referenced by float4_numeric(), float8_numeric(), generate_series_step_numeric(), int64_div_fast_to_numeric(), int64_to_numeric(), numeric(), numeric_add_safe(), numeric_avg(), numeric_ceil(), numeric_div_safe(), numeric_div_trunc(), numeric_exp(), numeric_fac(), numeric_floor(), numeric_gcd(), numeric_in(), numeric_inc(), numeric_lcm(), numeric_ln(), numeric_log(), numeric_mod_safe(), numeric_mul_safe(), numeric_poly_avg(), numeric_poly_sum(), numeric_power(), numeric_recv(), numeric_round(), numeric_sign(), numeric_sqrt(), numeric_stddev_internal(), numeric_sub_safe(), numeric_sum(), numeric_trim_scale(), numeric_trunc(), and random_numeric().

make_result_safe()

static Numeric make_result_safe ( const NumericVar *  var, Node *  escontext  )

static

Definition at line 7510 of file numeric.c.

{
    Numeric     result;
    NumericDigit *digits = var->digits;
    int         weight = var->weight;
    int         sign = var->sign;
    int         n;
    Size        len;
 
    if ((sign & NUMERIC_SIGN_MASK) == NUMERIC_SPECIAL)
    {
        /*
         * Verify valid special value.  This could be just an Assert, perhaps,
         * but it seems worthwhile to expend a few cycles to ensure that we
         * never write any nonzero reserved bits to disk.
         */
        if (!(sign == NUMERIC_NAN ||
              sign == NUMERIC_PINF ||
              sign == NUMERIC_NINF))
            elog(ERROR, "invalid numeric sign value 0x%x", sign);
 
        result = (Numeric) palloc(NUMERIC_HDRSZ_SHORT);
 
        SET_VARSIZE(result, NUMERIC_HDRSZ_SHORT);
        result->choice.n_header = sign;
        /* the header word is all we need */
 
        dump_numeric("make_result()", result);
        return result;
    }
 
    n = var->ndigits;
 
    /* truncate leading zeroes */
    while (n > 0 && *digits == 0)
    {
        digits++;
        weight--;
        n--;
    }
    /* truncate trailing zeroes */
    while (n > 0 && digits[n - 1] == 0)
        n--;
 
    /* If zero result, force to weight=0 and positive sign */
    if (n == 0)
    {
        weight = 0;
        sign = NUMERIC_POS;
    }
 
    /* Build the result */
    if (NUMERIC_CAN_BE_SHORT(var->dscale, weight))
    {
        len = NUMERIC_HDRSZ_SHORT + n * sizeof(NumericDigit);
        result = (Numeric) palloc(len);
        SET_VARSIZE(result, len);
        result->choice.n_short.n_header =
            (sign == NUMERIC_NEG ? (NUMERIC_SHORT | NUMERIC_SHORT_SIGN_MASK)
             : NUMERIC_SHORT)
            | (var->dscale << NUMERIC_SHORT_DSCALE_SHIFT)
            | (weight < 0 ? NUMERIC_SHORT_WEIGHT_SIGN_MASK : 0)
            | (weight & NUMERIC_SHORT_WEIGHT_MASK);
    }
    else
    {
        len = NUMERIC_HDRSZ + n * sizeof(NumericDigit);
        result = (Numeric) palloc(len);
        SET_VARSIZE(result, len);
        result->choice.n_long.n_sign_dscale =
            sign | (var->dscale & NUMERIC_DSCALE_MASK);
        result->choice.n_long.n_weight = weight;
    }
 
    Assert(NUMERIC_NDIGITS(result) == n);
    if (n > 0)
        memcpy(NUMERIC_DIGITS(result), digits, n * sizeof(NumericDigit));
 
    /* Check for overflow of int16 fields */
    if (NUMERIC_WEIGHT(result) != weight ||
        NUMERIC_DSCALE(result) != var->dscale)
        ereturn(escontext, NULL,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value overflows numeric format")));
 
    dump_numeric("make_result()", result);
    return result;
}

References Assert(), NumericData::choice, NumericVar::digits, digits, NumericVar::dscale, dump_numeric, elog, ereturn, errcode(), errmsg(), ERROR, len, NumericChoice::n_header, NumericVar::ndigits, NUMERIC_CAN_BE_SHORT, NUMERIC_DIGITS, NUMERIC_DSCALE, NUMERIC_DSCALE_MASK, NUMERIC_HDRSZ, NUMERIC_HDRSZ_SHORT, NUMERIC_NAN, NUMERIC_NDIGITS, NUMERIC_NEG, NUMERIC_NINF, NUMERIC_PINF, NUMERIC_POS, NUMERIC_SHORT, NUMERIC_SHORT_DSCALE_SHIFT, NUMERIC_SHORT_SIGN_MASK, NUMERIC_SHORT_WEIGHT_MASK, NUMERIC_SHORT_WEIGHT_SIGN_MASK, NUMERIC_SIGN_MASK, NUMERIC_SPECIAL, NUMERIC_WEIGHT, palloc(), SET_VARSIZE(), NumericVar::sign, sign, and NumericVar::weight.

Referenced by make_result(), numeric_add_safe(), numeric_div_safe(), numeric_in(), numeric_mod_safe(), numeric_mul_safe(), and numeric_sub_safe().

makeInt128AggState()

static Int128AggState * makeInt128AggState ( FunctionCallInfo  fcinfo, bool  calcSumX2  )

static

Definition at line 5410 of file numeric.c.

{
    Int128AggState *state;
    MemoryContext agg_context;
    MemoryContext old_context;
 
    if (!AggCheckCallContext(fcinfo, &agg_context))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    old_context = MemoryContextSwitchTo(agg_context);
 
    state = (Int128AggState *) palloc0(sizeof(Int128AggState));
    state->calcSumX2 = calcSumX2;
 
    MemoryContextSwitchTo(old_context);
 
    return state;
}

References AggCheckCallContext(), elog, ERROR, MemoryContextSwitchTo(), and palloc0().

Referenced by int2_accum(), int4_accum(), int8_avg_accum(), int8_avg_combine(), and numeric_poly_combine().

makeInt128AggStateCurrentContext()

static Int128AggState * makeInt128AggStateCurrentContext ( bool  calcSumX2 )

static

Definition at line 5434 of file numeric.c.

{
    Int128AggState *state;
 
    state = (Int128AggState *) palloc0(sizeof(Int128AggState));
    state->calcSumX2 = calcSumX2;
 
    return state;
}

References palloc0().

Referenced by int8_avg_deserialize(), and numeric_poly_deserialize().

makeNumericAggState()

static NumericAggState * makeNumericAggState ( FunctionCallInfo  fcinfo, bool  calcSumX2  )

static

Definition at line 4746 of file numeric.c.

{
    NumericAggState *state;
    MemoryContext agg_context;
    MemoryContext old_context;
 
    if (!AggCheckCallContext(fcinfo, &agg_context))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    old_context = MemoryContextSwitchTo(agg_context);
 
    state = (NumericAggState *) palloc0(sizeof(NumericAggState));
    state->calcSumX2 = calcSumX2;
    state->agg_context = agg_context;
 
    MemoryContextSwitchTo(old_context);
 
    return state;
}

References AggCheckCallContext(), elog, ERROR, MemoryContextSwitchTo(), and palloc0().

Referenced by int8_accum(), numeric_accum(), and numeric_avg_accum().

makeNumericAggStateCurrentContext()

static NumericAggState * makeNumericAggStateCurrentContext ( bool  calcSumX2 )

static

Definition at line 4771 of file numeric.c.

{
    NumericAggState *state;
 
    state = (NumericAggState *) palloc0(sizeof(NumericAggState));
    state->calcSumX2 = calcSumX2;
    state->agg_context = CurrentMemoryContext;
 
    return state;
}

References CurrentMemoryContext, and palloc0().

Referenced by numeric_avg_combine(), numeric_avg_deserialize(), numeric_combine(), and numeric_deserialize().

mod_var()

static void mod_var ( const NumericVar *  var1, const NumericVar *  var2, NumericVar *  result  )

static

Definition at line 9716 of file numeric.c.

{
    NumericVar  tmp;
 
    init_var(&tmp);
 
    /* ---------
     * We do this using the equation
     *      mod(x,y) = x - trunc(x/y)*y
     * div_var can be persuaded to give us trunc(x/y) directly.
     * ----------
     */
    div_var(var1, var2, &tmp, 0, false, true);
 
    mul_var(var2, &tmp, &tmp, var2->dscale);
 
    sub_var(var1, &tmp, result);
 
    free_var(&tmp);
}

References div_var(), NumericVar::dscale, free_var(), init_var, mul_var(), and sub_var().

Referenced by gcd_var(), and numeric_mod_safe().

mul_var()

static void mul_var ( const NumericVar *  var1, const NumericVar *  var2, NumericVar *  result, int  rscale  )

static

Definition at line 8300 of file numeric.c.

{
    int         res_ndigits;
    int         res_ndigitpairs;
    int         res_sign;
    int         res_weight;
    int         pair_offset;
    int         maxdigits;
    int         maxdigitpairs;
    uint64     *dig,
               *dig_i1_off;
    uint64      maxdig;
    uint64      carry;
    uint64      newdig;
    int         var1ndigits;
    int         var2ndigits;
    int         var1ndigitpairs;
    int         var2ndigitpairs;
    NumericDigit *var1digits;
    NumericDigit *var2digits;
    uint32      var1digitpair;
    uint32     *var2digitpairs;
    NumericDigit *res_digits;
    int         i,
                i1,
                i2,
                i2limit;
 
    /*
     * Arrange for var1 to be the shorter of the two numbers.  This improves
     * performance because the inner multiplication loop is much simpler than
     * the outer loop, so it's better to have a smaller number of iterations
     * of the outer loop.  This also reduces the number of times that the
     * accumulator array needs to be normalized.
     */
    if (var1->ndigits > var2->ndigits)
    {
        const NumericVar *tmp = var1;
 
        var1 = var2;
        var2 = tmp;
    }
 
    /* copy these values into local vars for speed in inner loop */
    var1ndigits = var1->ndigits;
    var2ndigits = var2->ndigits;
    var1digits = var1->digits;
    var2digits = var2->digits;
 
    if (var1ndigits == 0)
    {
        /* one or both inputs is zero; so is result */
        zero_var(result);
        result->dscale = rscale;
        return;
    }
 
    /*
     * If var1 has 1-6 digits and the exact result was requested, delegate to
     * mul_var_short() which uses a faster direct multiplication algorithm.
     */
    if (var1ndigits <= 6 && rscale == var1->dscale + var2->dscale)
    {
        mul_var_short(var1, var2, result);
        return;
    }
 
    /* Determine result sign */
    if (var1->sign == var2->sign)
        res_sign = NUMERIC_POS;
    else
        res_sign = NUMERIC_NEG;
 
    /*
     * Determine the number of result digits to compute and the (maximum
     * possible) result weight.  If the exact result would have more than
     * rscale fractional digits, truncate the computation with
     * MUL_GUARD_DIGITS guard digits, i.e., ignore input digits that would
     * only contribute to the right of that.  (This will give the exact
     * rounded-to-rscale answer unless carries out of the ignored positions
     * would have propagated through more than MUL_GUARD_DIGITS digits.)
     *
     * Note: an exact computation could not produce more than var1ndigits +
     * var2ndigits digits, but we allocate at least one extra output digit in
     * case rscale-driven rounding produces a carry out of the highest exact
     * digit.
     *
     * The computation itself is done using base-NBASE^2 arithmetic, so we
     * actually process the input digits in pairs, producing a base-NBASE^2
     * intermediate result.  This significantly improves performance, since
     * schoolbook multiplication is O(N^2) in the number of input digits, and
     * working in base NBASE^2 effectively halves "N".
     *
     * Note: in a truncated computation, we must compute at least one extra
     * output digit to ensure that all the guard digits are fully computed.
     */
    /* digit pairs in each input */
    var1ndigitpairs = (var1ndigits + 1) / 2;
    var2ndigitpairs = (var2ndigits + 1) / 2;
 
    /* digits in exact result */
    res_ndigits = var1ndigits + var2ndigits;
 
    /* digit pairs in exact result with at least one extra output digit */
    res_ndigitpairs = res_ndigits / 2 + 1;
 
    /* pair offset to align result to end of dig[] */
    pair_offset = res_ndigitpairs - var1ndigitpairs - var2ndigitpairs + 1;
 
    /* maximum possible result weight (odd-length inputs shifted up below) */
    res_weight = var1->weight + var2->weight + 1 + 2 * res_ndigitpairs -
        res_ndigits - (var1ndigits & 1) - (var2ndigits & 1);
 
    /* rscale-based truncation with at least one extra output digit */
    maxdigits = res_weight + 1 + (rscale + DEC_DIGITS - 1) / DEC_DIGITS +
        MUL_GUARD_DIGITS;
    maxdigitpairs = maxdigits / 2 + 1;
 
    res_ndigitpairs = Min(res_ndigitpairs, maxdigitpairs);
    res_ndigits = 2 * res_ndigitpairs;
 
    /*
     * In the computation below, digit pair i1 of var1 and digit pair i2 of
     * var2 are multiplied and added to digit i1+i2+pair_offset of dig[]. Thus
     * input digit pairs with index >= res_ndigitpairs - pair_offset don't
     * contribute to the result, and can be ignored.
     */
    if (res_ndigitpairs <= pair_offset)
    {
        /* All input digits will be ignored; so result is zero */
        zero_var(result);
        result->dscale = rscale;
        return;
    }
    var1ndigitpairs = Min(var1ndigitpairs, res_ndigitpairs - pair_offset);
    var2ndigitpairs = Min(var2ndigitpairs, res_ndigitpairs - pair_offset);
 
    /*
     * We do the arithmetic in an array "dig[]" of unsigned 64-bit integers.
     * Since PG_UINT64_MAX is much larger than NBASE^4, this gives us a lot of
     * headroom to avoid normalizing carries immediately.
     *
     * maxdig tracks the maximum possible value of any dig[] entry; when this
     * threatens to exceed PG_UINT64_MAX, we take the time to propagate
     * carries.  Furthermore, we need to ensure that overflow doesn't occur
     * during the carry propagation passes either.  The carry values could be
     * as much as PG_UINT64_MAX / NBASE^2, so really we must normalize when
     * digits threaten to exceed PG_UINT64_MAX - PG_UINT64_MAX / NBASE^2.
     *
     * To avoid overflow in maxdig itself, it actually represents the maximum
     * possible value divided by NBASE^2-1, i.e., at the top of the loop it is
     * known that no dig[] entry exceeds maxdig * (NBASE^2-1).
     *
     * The conversion of var1 to base NBASE^2 is done on the fly, as each new
     * digit is required.  The digits of var2 are converted upfront, and
     * stored at the end of dig[].  To avoid loss of precision, the input
     * digits are aligned with the start of digit pair array, effectively
     * shifting them up (multiplying by NBASE) if the inputs have an odd
     * number of NBASE digits.
     */
    dig = (uint64 *) palloc(res_ndigitpairs * sizeof(uint64) +
                            var2ndigitpairs * sizeof(uint32));
 
    /* convert var2 to base NBASE^2, shifting up if its length is odd */
    var2digitpairs = (uint32 *) (dig + res_ndigitpairs);
 
    for (i2 = 0; i2 < var2ndigitpairs - 1; i2++)
        var2digitpairs[i2] = var2digits[2 * i2] * NBASE + var2digits[2 * i2 + 1];
 
    if (2 * i2 + 1 < var2ndigits)
        var2digitpairs[i2] = var2digits[2 * i2] * NBASE + var2digits[2 * i2 + 1];
    else
        var2digitpairs[i2] = var2digits[2 * i2] * NBASE;
 
    /*
     * Start by multiplying var2 by the least significant contributing digit
     * pair from var1, storing the results at the end of dig[], and filling
     * the leading digits with zeros.
     *
     * The loop here is the same as the inner loop below, except that we set
     * the results in dig[], rather than adding to them.  This is the
     * performance bottleneck for multiplication, so we want to keep it simple
     * enough so that it can be auto-vectorized.  Accordingly, process the
     * digits left-to-right even though schoolbook multiplication would
     * suggest right-to-left.  Since we aren't propagating carries in this
     * loop, the order does not matter.
     */
    i1 = var1ndigitpairs - 1;
    if (2 * i1 + 1 < var1ndigits)
        var1digitpair = var1digits[2 * i1] * NBASE + var1digits[2 * i1 + 1];
    else
        var1digitpair = var1digits[2 * i1] * NBASE;
    maxdig = var1digitpair;
 
    i2limit = Min(var2ndigitpairs, res_ndigitpairs - i1 - pair_offset);
    dig_i1_off = &dig[i1 + pair_offset];
 
    memset(dig, 0, (i1 + pair_offset) * sizeof(uint64));
    for (i2 = 0; i2 < i2limit; i2++)
        dig_i1_off[i2] = (uint64) var1digitpair * var2digitpairs[i2];
 
    /*
     * Next, multiply var2 by the remaining digit pairs from var1, adding the
     * results to dig[] at the appropriate offsets, and normalizing whenever
     * there is a risk of any dig[] entry overflowing.
     */
    for (i1 = i1 - 1; i1 >= 0; i1--)
    {
        var1digitpair = var1digits[2 * i1] * NBASE + var1digits[2 * i1 + 1];
        if (var1digitpair == 0)
            continue;
 
        /* Time to normalize? */
        maxdig += var1digitpair;
        if (maxdig > (PG_UINT64_MAX - PG_UINT64_MAX / NBASE_SQR) / (NBASE_SQR - 1))
        {
            /* Yes, do it (to base NBASE^2) */
            carry = 0;
            for (i = res_ndigitpairs - 1; i >= 0; i--)
            {
                newdig = dig[i] + carry;
                if (newdig >= NBASE_SQR)
                {
                    carry = newdig / NBASE_SQR;
                    newdig -= carry * NBASE_SQR;
                }
                else
                    carry = 0;
                dig[i] = newdig;
            }
            Assert(carry == 0);
            /* Reset maxdig to indicate new worst-case */
            maxdig = 1 + var1digitpair;
        }
 
        /* Multiply and add */
        i2limit = Min(var2ndigitpairs, res_ndigitpairs - i1 - pair_offset);
        dig_i1_off = &dig[i1 + pair_offset];
 
        for (i2 = 0; i2 < i2limit; i2++)
            dig_i1_off[i2] += (uint64) var1digitpair * var2digitpairs[i2];
    }
 
    /*
     * Now we do a final carry propagation pass to normalize back to base
     * NBASE^2, and construct the base-NBASE result digits.  Note that this is
     * still done at full precision w/guard digits.
     */
    alloc_var(result, res_ndigits);
    res_digits = result->digits;
    carry = 0;
    for (i = res_ndigitpairs - 1; i >= 0; i--)
    {
        newdig = dig[i] + carry;
        if (newdig >= NBASE_SQR)
        {
            carry = newdig / NBASE_SQR;
            newdig -= carry * NBASE_SQR;
        }
        else
            carry = 0;
        res_digits[2 * i + 1] = (NumericDigit) ((uint32) newdig % NBASE);
        res_digits[2 * i] = (NumericDigit) ((uint32) newdig / NBASE);
    }
    Assert(carry == 0);
 
    pfree(dig);
 
    /*
     * Finally, round the result to the requested precision.
     */
    result->weight = res_weight;
    result->sign = res_sign;
 
    /* Round to target rscale (and set result->dscale) */
    round_var(result, rscale);
 
    /* Strip leading and trailing zeroes */
    strip_var(result);
}

References alloc_var(), Assert(), DEC_DIGITS, NumericVar::digits, NumericVar::dscale, i, maxdigits, Min, MUL_GUARD_DIGITS, mul_var_short(), NBASE, NBASE_SQR, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, palloc(), pfree(), PG_UINT64_MAX, round_var(), NumericVar::sign, strip_var(), NumericVar::weight, and zero_var().

Referenced by compute_bucket(), div_mod_var(), do_numeric_accum(), do_numeric_discard(), exp_var(), ln_var(), mod_var(), numeric_fac(), numeric_lcm(), numeric_mul_safe(), numeric_stddev_internal(), power_var(), power_var_int(), set_var_from_non_decimal_integer_str(), and sqrt_var().

mul_var_short()

static void mul_var_short ( const NumericVar *  var1, const NumericVar *  var2, NumericVar *  result  )

static

Definition at line 8591 of file numeric.c.

{
    int         var1ndigits = var1->ndigits;
    int         var2ndigits = var2->ndigits;
    NumericDigit *var1digits = var1->digits;
    NumericDigit *var2digits = var2->digits;
    int         res_sign;
    int         res_weight;
    int         res_ndigits;
    NumericDigit *res_buf;
    NumericDigit *res_digits;
    uint32      carry = 0;
    uint32      term;
 
    /* Check preconditions */
    Assert(var1ndigits >= 1);
    Assert(var1ndigits <= 6);
    Assert(var2ndigits >= var1ndigits);
 
    /*
     * Determine the result sign, weight, and number of digits to calculate.
     * The weight figured here is correct if the product has no leading zero
     * digits; otherwise strip_var() will fix things up.  Note that, unlike
     * mul_var(), we do not need to allocate an extra output digit, because we
     * are not rounding here.
     */
    if (var1->sign == var2->sign)
        res_sign = NUMERIC_POS;
    else
        res_sign = NUMERIC_NEG;
    res_weight = var1->weight + var2->weight + 1;
    res_ndigits = var1ndigits + var2ndigits;
 
    /* Allocate result digit array */
    res_buf = digitbuf_alloc(res_ndigits + 1);
    res_buf[0] = 0;             /* spare digit for later rounding */
    res_digits = res_buf + 1;
 
    /*
     * Compute the result digits in reverse, in one pass, propagating the
     * carry up as we go.  The i'th result digit consists of the sum of the
     * products var1digits[i1] * var2digits[i2] for which i = i1 + i2 + 1.
     */
#define PRODSUM1(v1,i1,v2,i2) ((v1)[(i1)] * (v2)[(i2)])
#define PRODSUM2(v1,i1,v2,i2) (PRODSUM1(v1,i1,v2,i2) + (v1)[(i1)+1] * (v2)[(i2)-1])
#define PRODSUM3(v1,i1,v2,i2) (PRODSUM2(v1,i1,v2,i2) + (v1)[(i1)+2] * (v2)[(i2)-2])
#define PRODSUM4(v1,i1,v2,i2) (PRODSUM3(v1,i1,v2,i2) + (v1)[(i1)+3] * (v2)[(i2)-3])
#define PRODSUM5(v1,i1,v2,i2) (PRODSUM4(v1,i1,v2,i2) + (v1)[(i1)+4] * (v2)[(i2)-4])
#define PRODSUM6(v1,i1,v2,i2) (PRODSUM5(v1,i1,v2,i2) + (v1)[(i1)+5] * (v2)[(i2)-5])
 
    switch (var1ndigits)
    {
        case 1:
            /* ---------
             * 1-digit case:
             *      var1ndigits = 1
             *      var2ndigits >= 1
             *      res_ndigits = var2ndigits + 1
             * ----------
             */
            for (int i = var2ndigits - 1; i >= 0; i--)
            {
                term = PRODSUM1(var1digits, 0, var2digits, i) + carry;
                res_digits[i + 1] = (NumericDigit) (term % NBASE);
                carry = term / NBASE;
            }
            res_digits[0] = (NumericDigit) carry;
            break;
 
        case 2:
            /* ---------
             * 2-digit case:
             *      var1ndigits = 2
             *      var2ndigits >= 2
             *      res_ndigits = var2ndigits + 2
             * ----------
             */
            /* last result digit and carry */
            term = PRODSUM1(var1digits, 1, var2digits, var2ndigits - 1);
            res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            /* remaining digits, except for the first two */
            for (int i = var2ndigits - 1; i >= 1; i--)
            {
                term = PRODSUM2(var1digits, 0, var2digits, i) + carry;
                res_digits[i + 1] = (NumericDigit) (term % NBASE);
                carry = term / NBASE;
            }
            break;
 
        case 3:
            /* ---------
             * 3-digit case:
             *      var1ndigits = 3
             *      var2ndigits >= 3
             *      res_ndigits = var2ndigits + 3
             * ----------
             */
            /* last two result digits */
            term = PRODSUM1(var1digits, 2, var2digits, var2ndigits - 1);
            res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = PRODSUM2(var1digits, 1, var2digits, var2ndigits - 1) + carry;
            res_digits[res_ndigits - 2] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            /* remaining digits, except for the first three */
            for (int i = var2ndigits - 1; i >= 2; i--)
            {
                term = PRODSUM3(var1digits, 0, var2digits, i) + carry;
                res_digits[i + 1] = (NumericDigit) (term % NBASE);
                carry = term / NBASE;
            }
            break;
 
        case 4:
            /* ---------
             * 4-digit case:
             *      var1ndigits = 4
             *      var2ndigits >= 4
             *      res_ndigits = var2ndigits + 4
             * ----------
             */
            /* last three result digits */
            term = PRODSUM1(var1digits, 3, var2digits, var2ndigits - 1);
            res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = PRODSUM2(var1digits, 2, var2digits, var2ndigits - 1) + carry;
            res_digits[res_ndigits - 2] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = PRODSUM3(var1digits, 1, var2digits, var2ndigits - 1) + carry;
            res_digits[res_ndigits - 3] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            /* remaining digits, except for the first four */
            for (int i = var2ndigits - 1; i >= 3; i--)
            {
                term = PRODSUM4(var1digits, 0, var2digits, i) + carry;
                res_digits[i + 1] = (NumericDigit) (term % NBASE);
                carry = term / NBASE;
            }
            break;
 
        case 5:
            /* ---------
             * 5-digit case:
             *      var1ndigits = 5
             *      var2ndigits >= 5
             *      res_ndigits = var2ndigits + 5
             * ----------
             */
            /* last four result digits */
            term = PRODSUM1(var1digits, 4, var2digits, var2ndigits - 1);
            res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = PRODSUM2(var1digits, 3, var2digits, var2ndigits - 1) + carry;
            res_digits[res_ndigits - 2] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = PRODSUM3(var1digits, 2, var2digits, var2ndigits - 1) + carry;
            res_digits[res_ndigits - 3] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = PRODSUM4(var1digits, 1, var2digits, var2ndigits - 1) + carry;
            res_digits[res_ndigits - 4] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            /* remaining digits, except for the first five */
            for (int i = var2ndigits - 1; i >= 4; i--)
            {
                term = PRODSUM5(var1digits, 0, var2digits, i) + carry;
                res_digits[i + 1] = (NumericDigit) (term % NBASE);
                carry = term / NBASE;
            }
            break;
 
        case 6:
            /* ---------
             * 6-digit case:
             *      var1ndigits = 6
             *      var2ndigits >= 6
             *      res_ndigits = var2ndigits + 6
             * ----------
             */
            /* last five result digits */
            term = PRODSUM1(var1digits, 5, var2digits, var2ndigits - 1);
            res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = PRODSUM2(var1digits, 4, var2digits, var2ndigits - 1) + carry;
            res_digits[res_ndigits - 2] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = PRODSUM3(var1digits, 3, var2digits, var2ndigits - 1) + carry;
            res_digits[res_ndigits - 3] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = PRODSUM4(var1digits, 2, var2digits, var2ndigits - 1) + carry;
            res_digits[res_ndigits - 4] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = PRODSUM5(var1digits, 1, var2digits, var2ndigits - 1) + carry;
            res_digits[res_ndigits - 5] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            /* remaining digits, except for the first six */
            for (int i = var2ndigits - 1; i >= 5; i--)
            {
                term = PRODSUM6(var1digits, 0, var2digits, i) + carry;
                res_digits[i + 1] = (NumericDigit) (term % NBASE);
                carry = term / NBASE;
            }
            break;
    }
 
    /*
     * Finally, for var1ndigits > 1, compute the remaining var1ndigits most
     * significant result digits.
     */
    switch (var1ndigits)
    {
        case 6:
            term = PRODSUM5(var1digits, 0, var2digits, 4) + carry;
            res_digits[5] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
            /* FALLTHROUGH */
        case 5:
            term = PRODSUM4(var1digits, 0, var2digits, 3) + carry;
            res_digits[4] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
            /* FALLTHROUGH */
        case 4:
            term = PRODSUM3(var1digits, 0, var2digits, 2) + carry;
            res_digits[3] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
            /* FALLTHROUGH */
        case 3:
            term = PRODSUM2(var1digits, 0, var2digits, 1) + carry;
            res_digits[2] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
            /* FALLTHROUGH */
        case 2:
            term = PRODSUM1(var1digits, 0, var2digits, 0) + carry;
            res_digits[1] = (NumericDigit) (term % NBASE);
            res_digits[0] = (NumericDigit) (term / NBASE);
            break;
    }
 
    /* Store the product in result */
    digitbuf_free(result->buf);
    result->ndigits = res_ndigits;
    result->buf = res_buf;
    result->digits = res_digits;
    result->weight = res_weight;
    result->sign = res_sign;
    result->dscale = var1->dscale + var2->dscale;
 
    /* Strip leading and trailing zeroes */
    strip_var(result);
}

References Assert(), NumericVar::buf, digitbuf_alloc, digitbuf_free, NumericVar::digits, NumericVar::dscale, i, NBASE, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, PRODSUM1, PRODSUM2, PRODSUM3, PRODSUM4, PRODSUM5, PRODSUM6, NumericVar::sign, strip_var(), and NumericVar::weight.

Referenced by mul_var().

numeric()

Datum numeric

(

PG_FUNCTION_ARGS

)

Definition at line 1229 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    int32       typmod = PG_GETARG_INT32(1);
    Numeric     new;
    int         precision;
    int         scale;
    int         ddigits;
    int         maxdigits;
    int         dscale;
    NumericVar  var;
 
    /*
     * Handle NaN and infinities: if apply_typmod_special doesn't complain,
     * just return a copy of the input.
     */
    if (NUMERIC_IS_SPECIAL(num))
    {
        (void) apply_typmod_special(num, typmod, NULL);
        PG_RETURN_NUMERIC(duplicate_numeric(num));
    }
 
    /*
     * If the value isn't a valid type modifier, simply return a copy of the
     * input value
     */
    if (!is_valid_numeric_typmod(typmod))
        PG_RETURN_NUMERIC(duplicate_numeric(num));
 
    /*
     * Get the precision and scale out of the typmod value
     */
    precision = numeric_typmod_precision(typmod);
    scale = numeric_typmod_scale(typmod);
    maxdigits = precision - scale;
 
    /* The target display scale is non-negative */
    dscale = Max(scale, 0);
 
    /*
     * If the number is certainly in bounds and due to the target scale no
     * rounding could be necessary, just make a copy of the input and modify
     * its scale fields, unless the larger scale forces us to abandon the
     * short representation.  (Note we assume the existing dscale is
     * honest...)
     */
    ddigits = (NUMERIC_WEIGHT(num) + 1) * DEC_DIGITS;
    if (ddigits <= maxdigits && scale >= NUMERIC_DSCALE(num)
        && (NUMERIC_CAN_BE_SHORT(dscale, NUMERIC_WEIGHT(num))
            || !NUMERIC_IS_SHORT(num)))
    {
        new = duplicate_numeric(num);
        if (NUMERIC_IS_SHORT(num))
            new->choice.n_short.n_header =
                (num->choice.n_short.n_header & ~NUMERIC_SHORT_DSCALE_MASK)
                | (dscale << NUMERIC_SHORT_DSCALE_SHIFT);
        else
            new->choice.n_long.n_sign_dscale = NUMERIC_SIGN(new) |
                ((uint16) dscale & NUMERIC_DSCALE_MASK);
        PG_RETURN_NUMERIC(new);
    }
 
    /*
     * We really need to fiddle with things - unpack the number into a
     * variable and let apply_typmod() do it.
     */
    init_var(&var);
 
    set_var_from_num(num, &var);
    (void) apply_typmod(&var, typmod, NULL);
    new = make_result(&var);
 
    free_var(&var);
 
    PG_RETURN_NUMERIC(new);
}

References apply_typmod(), apply_typmod_special(), NumericData::choice, DEC_DIGITS, duplicate_numeric(), free_var(), init_var, is_valid_numeric_typmod(), make_result(), Max, maxdigits, NumericShort::n_header, NumericChoice::n_short, NUMERIC_CAN_BE_SHORT, NUMERIC_DSCALE, NUMERIC_DSCALE_MASK, NUMERIC_IS_SHORT, NUMERIC_IS_SPECIAL, NUMERIC_SHORT_DSCALE_SHIFT, NUMERIC_SIGN, numeric_typmod_precision(), numeric_typmod_scale(), NUMERIC_WEIGHT, PG_GETARG_INT32, PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, scale, and set_var_from_num().

Referenced by ecpg_set_compat_sqlda(), and ecpg_set_native_sqlda().

numeric_abbrev_abort()

static bool numeric_abbrev_abort ( int  memtupcount, SortSupport  ssup  )

static

Definition at line 2212 of file numeric.c.

{
    NumericSortSupport *nss = ssup->ssup_extra;
    double      abbr_card;
 
    if (memtupcount < 10000 || nss->input_count < 10000 || !nss->estimating)
        return false;
 
    abbr_card = estimateHyperLogLog(&nss->abbr_card);
 
    /*
     * If we have >100k distinct values, then even if we were sorting many
     * billion rows we'd likely still break even, and the penalty of undoing
     * that many rows of abbrevs would probably not be worth it. Stop even
     * counting at that point.
     */
    if (abbr_card > 100000.0)
    {
        if (trace_sort)
            elog(LOG,
                 "numeric_abbrev: estimation ends at cardinality %f"
                 " after " INT64_FORMAT " values (%d rows)",
                 abbr_card, nss->input_count, memtupcount);
        nss->estimating = false;
        return false;
    }
 
    /*
     * Target minimum cardinality is 1 per ~10k of non-null inputs.  (The
     * break even point is somewhere between one per 100k rows, where
     * abbreviation has a very slight penalty, and 1 per 10k where it wins by
     * a measurable percentage.)  We use the relatively pessimistic 10k
     * threshold, and add a 0.5 row fudge factor, because it allows us to
     * abort earlier on genuinely pathological data where we've had exactly
     * one abbreviated value in the first 10k (non-null) rows.
     */
    if (abbr_card < nss->input_count / 10000.0 + 0.5)
    {
        if (trace_sort)
            elog(LOG,
                 "numeric_abbrev: aborting abbreviation at cardinality %f"
                 " below threshold %f after " INT64_FORMAT " values (%d rows)",
                 abbr_card, nss->input_count / 10000.0 + 0.5,
                 nss->input_count, memtupcount);
        return true;
    }
 
    if (trace_sort)
        elog(LOG,
             "numeric_abbrev: cardinality %f"
             " after " INT64_FORMAT " values (%d rows)",
             abbr_card, nss->input_count, memtupcount);
 
    return false;
}

References NumericSortSupport::abbr_card, elog, estimateHyperLogLog(), NumericSortSupport::estimating, NumericSortSupport::input_count, INT64_FORMAT, LOG, SortSupportData::ssup_extra, and trace_sort.

Referenced by numeric_sortsupport().

numeric_abbrev_convert()

static Datum numeric_abbrev_convert ( Datum  original_datum, SortSupport  ssup  )

static

Definition at line 2150 of file numeric.c.

{
    NumericSortSupport *nss = ssup->ssup_extra;
    void       *original_varatt = PG_DETOAST_DATUM_PACKED(original_datum);
    Numeric     value;
    Datum       result;
 
    nss->input_count += 1;
 
    /*
     * This is to handle packed datums without needing a palloc/pfree cycle;
     * we keep and reuse a buffer large enough to handle any short datum.
     */
    if (VARATT_IS_SHORT(original_varatt))
    {
        void       *buf = nss->buf;
        Size        sz = VARSIZE_SHORT(original_varatt) - VARHDRSZ_SHORT;
 
        Assert(sz <= VARATT_SHORT_MAX - VARHDRSZ_SHORT);
 
        SET_VARSIZE(buf, VARHDRSZ + sz);
        memcpy(VARDATA(buf), VARDATA_SHORT(original_varatt), sz);
 
        value = (Numeric) buf;
    }
    else
        value = (Numeric) original_varatt;
 
    if (NUMERIC_IS_SPECIAL(value))
    {
        if (NUMERIC_IS_PINF(value))
            result = NUMERIC_ABBREV_PINF;
        else if (NUMERIC_IS_NINF(value))
            result = NUMERIC_ABBREV_NINF;
        else
            result = NUMERIC_ABBREV_NAN;
    }
    else
    {
        NumericVar  var;
 
        init_var_from_num(value, &var);
 
        result = numeric_abbrev_convert_var(&var, nss);
    }
 
    /* should happen only for external/compressed toasts */
    if (original_varatt != DatumGetPointer(original_datum))
        pfree(original_varatt);
 
    return result;
}

References Assert(), NumericSortSupport::buf, buf, DatumGetPointer(), init_var_from_num(), NumericSortSupport::input_count, numeric_abbrev_convert_var(), NUMERIC_ABBREV_NAN, NUMERIC_ABBREV_NINF, NUMERIC_ABBREV_PINF, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, pfree(), PG_DETOAST_DATUM_PACKED, SET_VARSIZE(), SortSupportData::ssup_extra, value, VARATT_IS_SHORT(), VARATT_SHORT_MAX, VARDATA(), VARDATA_SHORT(), VARHDRSZ, VARHDRSZ_SHORT, and VARSIZE_SHORT().

Referenced by numeric_sortsupport().

numeric_abbrev_convert_var()

static Datum numeric_abbrev_convert_var ( const NumericVar *  var, NumericSortSupport *  nss  )

static

Definition at line 2360 of file numeric.c.

{
    int         ndigits = var->ndigits;
    int         weight = var->weight;
    int64       result;
 
    if (ndigits == 0 || weight < -44)
    {
        result = 0;
    }
    else if (weight > 83)
    {
        result = PG_INT64_MAX;
    }
    else
    {
        result = ((int64) (weight + 44) << 56);
 
        switch (ndigits)
        {
            default:
                result |= ((int64) var->digits[3]);
                /* FALLTHROUGH */
            case 3:
                result |= ((int64) var->digits[2]) << 14;
                /* FALLTHROUGH */
            case 2:
                result |= ((int64) var->digits[1]) << 28;
                /* FALLTHROUGH */
            case 1:
                result |= ((int64) var->digits[0]) << 42;
                break;
        }
    }
 
    /* the abbrev is negated relative to the original */
    if (var->sign == NUMERIC_POS)
        result = -result;
 
    if (nss->estimating)
    {
        uint32      tmp = ((uint32) result
                           ^ (uint32) ((uint64) result >> 32));
 
        addHyperLogLog(&nss->abbr_card, DatumGetUInt32(hash_uint32(tmp)));
    }
 
    return NumericAbbrevGetDatum(result);
}

References NumericSortSupport::abbr_card, addHyperLogLog(), DatumGetUInt32(), NumericVar::digits, NumericSortSupport::estimating, hash_uint32(), NumericVar::ndigits, NUMERIC_POS, NumericAbbrevGetDatum, PG_INT64_MAX, NumericVar::sign, and NumericVar::weight.

Referenced by numeric_abbrev_convert().

numeric_abs()

Datum numeric_abs

(

PG_FUNCTION_ARGS

)

Definition at line 1376 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    Numeric     res;
 
    /*
     * Do it the easy way directly on the packed format
     */
    res = duplicate_numeric(num);
 
    if (NUMERIC_IS_SHORT(num))
        res->choice.n_short.n_header =
            num->choice.n_short.n_header & ~NUMERIC_SHORT_SIGN_MASK;
    else if (NUMERIC_IS_SPECIAL(num))
    {
        /* This changes -Inf to Inf, and doesn't affect NaN */
        res->choice.n_short.n_header =
            num->choice.n_short.n_header & ~NUMERIC_INF_SIGN_MASK;
    }
    else
        res->choice.n_long.n_sign_dscale = NUMERIC_POS | NUMERIC_DSCALE(num);
 
    PG_RETURN_NUMERIC(res);
}

References NumericData::choice, duplicate_numeric(), NumericShort::n_header, NumericChoice::n_long, NumericChoice::n_short, NumericLong::n_sign_dscale, NUMERIC_DSCALE, NUMERIC_IS_SHORT, NUMERIC_IS_SPECIAL, NUMERIC_POS, PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

Referenced by executeItemOptUnwrapTarget(), and numeric_absolute().

numeric_accum()

Datum numeric_accum

(

PG_FUNCTION_ARGS

)

Definition at line 4949 of file numeric.c.

{
    NumericAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    /* Create the state data on the first call */
    if (state == NULL)
        state = makeNumericAggState(fcinfo, true);
 
    if (!PG_ARGISNULL(1))
        do_numeric_accum(state, PG_GETARG_NUMERIC(1));
 
    PG_RETURN_POINTER(state);
}

References do_numeric_accum(), makeNumericAggState(), PG_ARGISNULL, PG_GETARG_NUMERIC, PG_GETARG_POINTER, and PG_RETURN_POINTER.

numeric_accum_inv()

Datum numeric_accum_inv

(

PG_FUNCTION_ARGS

)

Definition at line 5360 of file numeric.c.

{
    NumericAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    /* Should not get here with no state */
    if (state == NULL)
        elog(ERROR, "numeric_accum_inv called with NULL state");
 
    if (!PG_ARGISNULL(1))
    {
        /* If we fail to perform the inverse transition, return NULL */
        if (!do_numeric_discard(state, PG_GETARG_NUMERIC(1)))
            PG_RETURN_NULL();
    }
 
    PG_RETURN_POINTER(state);
}

References do_numeric_discard(), elog, ERROR, PG_ARGISNULL, PG_GETARG_NUMERIC, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_POINTER.

numeric_add()

Datum numeric_add

(

PG_FUNCTION_ARGS

)

Definition at line 2865 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    Numeric     res;
 
    res = numeric_add_safe(num1, num2, NULL);
 
    PG_RETURN_NUMERIC(res);
}

References numeric_add_safe(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

Referenced by int8_sum(), numeric_half_rounded(), and pg_lsn_pli().

numeric_add_safe()

Numeric numeric_add_safe	(	Numeric	num1,
		Numeric	num2,
		Node *	escontext
	)

Definition at line 2882 of file numeric.c.

{
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
    Numeric     res;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
    {
        if (NUMERIC_IS_NAN(num1) || NUMERIC_IS_NAN(num2))
            return make_result(&const_nan);
        if (NUMERIC_IS_PINF(num1))
        {
            if (NUMERIC_IS_NINF(num2))
                return make_result(&const_nan); /* Inf + -Inf */
            else
                return make_result(&const_pinf);
        }
        if (NUMERIC_IS_NINF(num1))
        {
            if (NUMERIC_IS_PINF(num2))
                return make_result(&const_nan); /* -Inf + Inf */
            else
                return make_result(&const_ninf);
        }
        /* by here, num1 must be finite, so num2 is not */
        if (NUMERIC_IS_PINF(num2))
            return make_result(&const_pinf);
        Assert(NUMERIC_IS_NINF(num2));
        return make_result(&const_ninf);
    }
 
    /*
     * Unpack the values, let add_var() compute the result and return it.
     */
    init_var_from_num(num1, &arg1);
    init_var_from_num(num2, &arg2);
 
    init_var(&result);
    add_var(&arg1, &arg2, &result);
 
    res = make_result_safe(&result, escontext);
 
    free_var(&result);
 
    return res;
}

References add_var(), Assert(), const_nan, const_ninf, const_pinf, free_var(), init_var, init_var_from_num(), make_result(), make_result_safe(), NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, and NUMERIC_IS_SPECIAL.

Referenced by executeItemOptUnwrapTarget(), interval_part_common(), numeric_add(), timestamp_part_common(), and timestamptz_part_common().

numeric_avg()

Datum numeric_avg

(

PG_FUNCTION_ARGS

)

Definition at line 5919 of file numeric.c.

{
    NumericAggState *state;
    Datum       N_datum;
    Datum       sumX_datum;
    NumericVar  sumX_var;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    /* If there were no non-null inputs, return NULL */
    if (state == NULL || NA_TOTAL_COUNT(state) == 0)
        PG_RETURN_NULL();
 
    if (state->NaNcount > 0)    /* there was at least one NaN input */
        PG_RETURN_NUMERIC(make_result(&const_nan));
 
    /* adding plus and minus infinities gives NaN */
    if (state->pInfcount > 0 && state->nInfcount > 0)
        PG_RETURN_NUMERIC(make_result(&const_nan));
    if (state->pInfcount > 0)
        PG_RETURN_NUMERIC(make_result(&const_pinf));
    if (state->nInfcount > 0)
        PG_RETURN_NUMERIC(make_result(&const_ninf));
 
    N_datum = NumericGetDatum(int64_to_numeric(state->N));
 
    init_var(&sumX_var);
    accum_sum_final(&state->sumX, &sumX_var);
    sumX_datum = NumericGetDatum(make_result(&sumX_var));
    free_var(&sumX_var);
 
    PG_RETURN_DATUM(DirectFunctionCall2(numeric_div, sumX_datum, N_datum));
}

References accum_sum_final(), const_nan, const_ninf, const_pinf, DirectFunctionCall2, free_var(), init_var, int64_to_numeric(), make_result(), NA_TOTAL_COUNT, numeric_div(), NumericGetDatum(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_DATUM, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numeric_avg_accum()

Datum numeric_avg_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5041 of file numeric.c.

{
    NumericAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    /* Create the state data on the first call */
    if (state == NULL)
        state = makeNumericAggState(fcinfo, false);
 
    if (!PG_ARGISNULL(1))
        do_numeric_accum(state, PG_GETARG_NUMERIC(1));
 
    PG_RETURN_POINTER(state);
}

References do_numeric_accum(), makeNumericAggState(), PG_ARGISNULL, PG_GETARG_NUMERIC, PG_GETARG_POINTER, and PG_RETURN_POINTER.

numeric_avg_combine()

Datum numeric_avg_combine

(

PG_FUNCTION_ARGS

)

Definition at line 5061 of file numeric.c.

{
    NumericAggState *state1;
    NumericAggState *state2;
    MemoryContext agg_context;
    MemoryContext old_context;
 
    if (!AggCheckCallContext(fcinfo, &agg_context))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state1 = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
    state2 = PG_ARGISNULL(1) ? NULL : (NumericAggState *) PG_GETARG_POINTER(1);
 
    if (state2 == NULL)
        PG_RETURN_POINTER(state1);
 
    /* manually copy all fields from state2 to state1 */
    if (state1 == NULL)
    {
        old_context = MemoryContextSwitchTo(agg_context);
 
        state1 = makeNumericAggStateCurrentContext(false);
        state1->N = state2->N;
        state1->NaNcount = state2->NaNcount;
        state1->pInfcount = state2->pInfcount;
        state1->nInfcount = state2->nInfcount;
        state1->maxScale = state2->maxScale;
        state1->maxScaleCount = state2->maxScaleCount;
 
        accum_sum_copy(&state1->sumX, &state2->sumX);
 
        MemoryContextSwitchTo(old_context);
 
        PG_RETURN_POINTER(state1);
    }
 
    state1->N += state2->N;
    state1->NaNcount += state2->NaNcount;
    state1->pInfcount += state2->pInfcount;
    state1->nInfcount += state2->nInfcount;
 
    if (state2->N > 0)
    {
        /*
         * These are currently only needed for moving aggregates, but let's do
         * the right thing anyway...
         */
        if (state2->maxScale > state1->maxScale)
        {
            state1->maxScale = state2->maxScale;
            state1->maxScaleCount = state2->maxScaleCount;
        }
        else if (state2->maxScale == state1->maxScale)
            state1->maxScaleCount += state2->maxScaleCount;
 
        /* The rest of this needs to work in the aggregate context */
        old_context = MemoryContextSwitchTo(agg_context);
 
        /* Accumulate sums */
        accum_sum_combine(&state1->sumX, &state2->sumX);
 
        MemoryContextSwitchTo(old_context);
    }
    PG_RETURN_POINTER(state1);
}

References accum_sum_combine(), accum_sum_copy(), AggCheckCallContext(), elog, ERROR, makeNumericAggStateCurrentContext(), NumericAggState::maxScale, NumericAggState::maxScaleCount, MemoryContextSwitchTo(), NumericAggState::N, NumericAggState::NaNcount, NumericAggState::nInfcount, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_POINTER, NumericAggState::pInfcount, and NumericAggState::sumX.

numeric_avg_deserialize()

Datum numeric_avg_deserialize

(

PG_FUNCTION_ARGS

)

Definition at line 5185 of file numeric.c.

{
    bytea      *sstate;
    NumericAggState *result;
    StringInfoData buf;
    NumericVar  tmp_var;
 
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    sstate = PG_GETARG_BYTEA_PP(0);
 
    init_var(&tmp_var);
 
    /*
     * Initialize a StringInfo so that we can "receive" it using the standard
     * recv-function infrastructure.
     */
    initReadOnlyStringInfo(&buf, VARDATA_ANY(sstate),
                           VARSIZE_ANY_EXHDR(sstate));
 
    result = makeNumericAggStateCurrentContext(false);
 
    /* N */
    result->N = pq_getmsgint64(&buf);
 
    /* sumX */
    numericvar_deserialize(&buf, &tmp_var);
    accum_sum_add(&(result->sumX), &tmp_var);
 
    /* maxScale */
    result->maxScale = pq_getmsgint(&buf, 4);
 
    /* maxScaleCount */
    result->maxScaleCount = pq_getmsgint64(&buf);
 
    /* NaNcount */
    result->NaNcount = pq_getmsgint64(&buf);
 
    /* pInfcount */
    result->pInfcount = pq_getmsgint64(&buf);
 
    /* nInfcount */
    result->nInfcount = pq_getmsgint64(&buf);
 
    pq_getmsgend(&buf);
 
    free_var(&tmp_var);
 
    PG_RETURN_POINTER(result);
}

References accum_sum_add(), AggCheckCallContext(), buf, elog, ERROR, free_var(), init_var, initReadOnlyStringInfo(), makeNumericAggStateCurrentContext(), NumericAggState::maxScale, NumericAggState::maxScaleCount, NumericAggState::N, NumericAggState::NaNcount, NumericAggState::nInfcount, numericvar_deserialize(), PG_GETARG_BYTEA_PP, PG_RETURN_POINTER, NumericAggState::pInfcount, pq_getmsgend(), pq_getmsgint(), pq_getmsgint64(), NumericAggState::sumX, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

numeric_avg_serialize()

Datum numeric_avg_serialize

(

PG_FUNCTION_ARGS

)

Definition at line 5133 of file numeric.c.

{
    NumericAggState *state;
    StringInfoData buf;
    bytea      *result;
    NumericVar  tmp_var;
 
    /* Ensure we disallow calling when not in aggregate context */
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state = (NumericAggState *) PG_GETARG_POINTER(0);
 
    init_var(&tmp_var);
 
    pq_begintypsend(&buf);
 
    /* N */
    pq_sendint64(&buf, state->N);
 
    /* sumX */
    accum_sum_final(&state->sumX, &tmp_var);
    numericvar_serialize(&buf, &tmp_var);
 
    /* maxScale */
    pq_sendint32(&buf, state->maxScale);
 
    /* maxScaleCount */
    pq_sendint64(&buf, state->maxScaleCount);
 
    /* NaNcount */
    pq_sendint64(&buf, state->NaNcount);
 
    /* pInfcount */
    pq_sendint64(&buf, state->pInfcount);
 
    /* nInfcount */
    pq_sendint64(&buf, state->nInfcount);
 
    result = pq_endtypsend(&buf);
 
    free_var(&tmp_var);
 
    PG_RETURN_BYTEA_P(result);
}

References accum_sum_final(), AggCheckCallContext(), buf, elog, ERROR, free_var(), init_var, numericvar_serialize(), PG_GETARG_POINTER, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint32(), and pq_sendint64().

numeric_ceil()

Datum numeric_ceil

(

PG_FUNCTION_ARGS

)

Definition at line 1630 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    Numeric     res;
    NumericVar  result;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
        PG_RETURN_NUMERIC(duplicate_numeric(num));
 
    init_var_from_num(num, &result);
    ceil_var(&result, &result);
 
    res = make_result(&result);
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References ceil_var(), duplicate_numeric(), free_var(), init_var_from_num(), make_result(), NUMERIC_IS_SPECIAL, PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

Referenced by executeItemOptUnwrapTarget().

numeric_cmp()

Datum numeric_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 2416 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    int         result;
 
    result = cmp_numerics(num1, num2);
 
    PG_FREE_IF_COPY(num1, 0);
    PG_FREE_IF_COPY(num2, 1);
 
    PG_RETURN_INT32(result);
}

References cmp_numerics(), PG_FREE_IF_COPY, PG_GETARG_NUMERIC, and PG_RETURN_INT32.

Referenced by compareJsonbScalarValue(), compareNumeric(), gbt_numeric_cmp(), gbt_numeric_ssup_cmp(), and gin_numeric_cmp().

numeric_cmp_abbrev()

static int numeric_cmp_abbrev ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 2301 of file numeric.c.

{
    /*
     * NOTE WELL: this is intentionally backwards, because the abbreviation is
     * negated relative to the original value, to handle NaN/infinity cases.
     */
    if (DatumGetNumericAbbrev(x) < DatumGetNumericAbbrev(y))
        return 1;
    if (DatumGetNumericAbbrev(x) > DatumGetNumericAbbrev(y))
        return -1;
    return 0;
}

References DatumGetNumericAbbrev, x, and y.

Referenced by numeric_sortsupport().

numeric_combine()

Datum numeric_combine

(

PG_FUNCTION_ARGS

)

Definition at line 4969 of file numeric.c.

{
    NumericAggState *state1;
    NumericAggState *state2;
    MemoryContext agg_context;
    MemoryContext old_context;
 
    if (!AggCheckCallContext(fcinfo, &agg_context))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state1 = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
    state2 = PG_ARGISNULL(1) ? NULL : (NumericAggState *) PG_GETARG_POINTER(1);
 
    if (state2 == NULL)
        PG_RETURN_POINTER(state1);
 
    /* manually copy all fields from state2 to state1 */
    if (state1 == NULL)
    {
        old_context = MemoryContextSwitchTo(agg_context);
 
        state1 = makeNumericAggStateCurrentContext(true);
        state1->N = state2->N;
        state1->NaNcount = state2->NaNcount;
        state1->pInfcount = state2->pInfcount;
        state1->nInfcount = state2->nInfcount;
        state1->maxScale = state2->maxScale;
        state1->maxScaleCount = state2->maxScaleCount;
 
        accum_sum_copy(&state1->sumX, &state2->sumX);
        accum_sum_copy(&state1->sumX2, &state2->sumX2);
 
        MemoryContextSwitchTo(old_context);
 
        PG_RETURN_POINTER(state1);
    }
 
    state1->N += state2->N;
    state1->NaNcount += state2->NaNcount;
    state1->pInfcount += state2->pInfcount;
    state1->nInfcount += state2->nInfcount;
 
    if (state2->N > 0)
    {
        /*
         * These are currently only needed for moving aggregates, but let's do
         * the right thing anyway...
         */
        if (state2->maxScale > state1->maxScale)
        {
            state1->maxScale = state2->maxScale;
            state1->maxScaleCount = state2->maxScaleCount;
        }
        else if (state2->maxScale == state1->maxScale)
            state1->maxScaleCount += state2->maxScaleCount;
 
        /* The rest of this needs to work in the aggregate context */
        old_context = MemoryContextSwitchTo(agg_context);
 
        /* Accumulate sums */
        accum_sum_combine(&state1->sumX, &state2->sumX);
        accum_sum_combine(&state1->sumX2, &state2->sumX2);
 
        MemoryContextSwitchTo(old_context);
    }
    PG_RETURN_POINTER(state1);
}

References accum_sum_combine(), accum_sum_copy(), AggCheckCallContext(), elog, ERROR, makeNumericAggStateCurrentContext(), NumericAggState::maxScale, NumericAggState::maxScaleCount, MemoryContextSwitchTo(), NumericAggState::N, NumericAggState::NaNcount, NumericAggState::nInfcount, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_POINTER, NumericAggState::pInfcount, NumericAggState::sumX, and NumericAggState::sumX2.

numeric_deserialize()

Datum numeric_deserialize

(

PG_FUNCTION_ARGS

)

Definition at line 5299 of file numeric.c.

{
    bytea      *sstate;
    NumericAggState *result;
    StringInfoData buf;
    NumericVar  tmp_var;
 
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    sstate = PG_GETARG_BYTEA_PP(0);
 
    init_var(&tmp_var);
 
    /*
     * Initialize a StringInfo so that we can "receive" it using the standard
     * recv-function infrastructure.
     */
    initReadOnlyStringInfo(&buf, VARDATA_ANY(sstate),
                           VARSIZE_ANY_EXHDR(sstate));
 
    result = makeNumericAggStateCurrentContext(false);
 
    /* N */
    result->N = pq_getmsgint64(&buf);
 
    /* sumX */
    numericvar_deserialize(&buf, &tmp_var);
    accum_sum_add(&(result->sumX), &tmp_var);
 
    /* sumX2 */
    numericvar_deserialize(&buf, &tmp_var);
    accum_sum_add(&(result->sumX2), &tmp_var);
 
    /* maxScale */
    result->maxScale = pq_getmsgint(&buf, 4);
 
    /* maxScaleCount */
    result->maxScaleCount = pq_getmsgint64(&buf);
 
    /* NaNcount */
    result->NaNcount = pq_getmsgint64(&buf);
 
    /* pInfcount */
    result->pInfcount = pq_getmsgint64(&buf);
 
    /* nInfcount */
    result->nInfcount = pq_getmsgint64(&buf);
 
    pq_getmsgend(&buf);
 
    free_var(&tmp_var);
 
    PG_RETURN_POINTER(result);
}

References accum_sum_add(), AggCheckCallContext(), buf, elog, ERROR, free_var(), init_var, initReadOnlyStringInfo(), makeNumericAggStateCurrentContext(), NumericAggState::maxScale, NumericAggState::maxScaleCount, NumericAggState::N, NumericAggState::NaNcount, NumericAggState::nInfcount, numericvar_deserialize(), PG_GETARG_BYTEA_PP, PG_RETURN_POINTER, NumericAggState::pInfcount, pq_getmsgend(), pq_getmsgint(), pq_getmsgint64(), NumericAggState::sumX, NumericAggState::sumX2, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

numeric_div()

Datum numeric_div

(

PG_FUNCTION_ARGS

)

Definition at line 3135 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    Numeric     res;
 
    res = numeric_div_safe(num1, num2, NULL);
 
    PG_RETURN_NUMERIC(res);
}

References numeric_div_safe(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

Referenced by cash_numeric(), gbt_numeric_penalty(), int8_avg(), numeric_avg(), and numeric_poly_avg().

numeric_div_safe()

Numeric numeric_div_safe	(	Numeric	num1,
		Numeric	num2,
		Node *	escontext
	)

Definition at line 3153 of file numeric.c.

{
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
    Numeric     res;
    int         rscale;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
    {
        if (NUMERIC_IS_NAN(num1) || NUMERIC_IS_NAN(num2))
            return make_result(&const_nan);
        if (NUMERIC_IS_PINF(num1))
        {
            if (NUMERIC_IS_SPECIAL(num2))
                return make_result(&const_nan); /* Inf / [-]Inf */
            switch (numeric_sign_internal(num2))
            {
                case 0:
                    goto division_by_zero;
                case 1:
                    return make_result(&const_pinf);
                case -1:
                    return make_result(&const_ninf);
            }
            Assert(false);
        }
        if (NUMERIC_IS_NINF(num1))
        {
            if (NUMERIC_IS_SPECIAL(num2))
                return make_result(&const_nan); /* -Inf / [-]Inf */
            switch (numeric_sign_internal(num2))
            {
                case 0:
                    goto division_by_zero;
                case 1:
                    return make_result(&const_ninf);
                case -1:
                    return make_result(&const_pinf);
            }
            Assert(false);
        }
        /* by here, num1 must be finite, so num2 is not */
 
        /*
         * POSIX would have us return zero or minus zero if num1 is zero, and
         * otherwise throw an underflow error.  But the numeric type doesn't
         * really do underflow, so let's just return zero.
         */
        return make_result(&const_zero);
    }
 
    /*
     * Unpack the arguments
     */
    init_var_from_num(num1, &arg1);
    init_var_from_num(num2, &arg2);
 
    init_var(&result);
 
    /*
     * Select scale for division result
     */
    rscale = select_div_scale(&arg1, &arg2);
 
    /* Check for division by zero */
    if (arg2.ndigits == 0 || arg2.digits[0] == 0)
        goto division_by_zero;
 
    /*
     * Do the divide and return the result
     */
    div_var(&arg1, &arg2, &result, rscale, true, true);
 
    res = make_result_safe(&result, escontext);
 
    free_var(&result);
 
    return res;
 
division_by_zero:
    ereturn(escontext, NULL,
            errcode(ERRCODE_DIVISION_BY_ZERO),
            errmsg("division by zero"));
}

References Assert(), const_nan, const_ninf, const_pinf, const_zero, NumericVar::digits, div_var(), ereturn, errcode(), errmsg(), free_var(), init_var, init_var_from_num(), make_result(), make_result_safe(), NumericVar::ndigits, NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numeric_sign_internal(), and select_div_scale().

Referenced by executeItemOptUnwrapTarget(), numeric_div(), timestamp_part_common(), and timestamptz_part_common().

numeric_div_trunc()

Datum numeric_div_trunc

(

PG_FUNCTION_ARGS

)

Definition at line 3249 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
    Numeric     res;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
    {
        if (NUMERIC_IS_NAN(num1) || NUMERIC_IS_NAN(num2))
            PG_RETURN_NUMERIC(make_result(&const_nan));
        if (NUMERIC_IS_PINF(num1))
        {
            if (NUMERIC_IS_SPECIAL(num2))
                PG_RETURN_NUMERIC(make_result(&const_nan)); /* Inf / [-]Inf */
            switch (numeric_sign_internal(num2))
            {
                case 0:
                    ereport(ERROR,
                            (errcode(ERRCODE_DIVISION_BY_ZERO),
                             errmsg("division by zero")));
                    break;
                case 1:
                    PG_RETURN_NUMERIC(make_result(&const_pinf));
                case -1:
                    PG_RETURN_NUMERIC(make_result(&const_ninf));
            }
            Assert(false);
        }
        if (NUMERIC_IS_NINF(num1))
        {
            if (NUMERIC_IS_SPECIAL(num2))
                PG_RETURN_NUMERIC(make_result(&const_nan)); /* -Inf / [-]Inf */
            switch (numeric_sign_internal(num2))
            {
                case 0:
                    ereport(ERROR,
                            (errcode(ERRCODE_DIVISION_BY_ZERO),
                             errmsg("division by zero")));
                    break;
                case 1:
                    PG_RETURN_NUMERIC(make_result(&const_ninf));
                case -1:
                    PG_RETURN_NUMERIC(make_result(&const_pinf));
            }
            Assert(false);
        }
        /* by here, num1 must be finite, so num2 is not */
 
        /*
         * POSIX would have us return zero or minus zero if num1 is zero, and
         * otherwise throw an underflow error.  But the numeric type doesn't
         * really do underflow, so let's just return zero.
         */
        PG_RETURN_NUMERIC(make_result(&const_zero));
    }
 
    /*
     * Unpack the arguments
     */
    init_var_from_num(num1, &arg1);
    init_var_from_num(num2, &arg2);
 
    init_var(&result);
 
    /*
     * Do the divide and return the result
     */
    div_var(&arg1, &arg2, &result, 0, false, true);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References Assert(), const_nan, const_ninf, const_pinf, const_zero, div_var(), ereport, errcode(), errmsg(), ERROR, free_var(), init_var, init_var_from_num(), make_result(), NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numeric_sign_internal(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

Referenced by numeric_half_rounded(), and numeric_truncated_divide().

numeric_eq()

Datum numeric_eq

(

PG_FUNCTION_ARGS

)

Definition at line 2432 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    bool        result;
 
    result = cmp_numerics(num1, num2) == 0;
 
    PG_FREE_IF_COPY(num1, 0);
    PG_FREE_IF_COPY(num2, 1);
 
    PG_RETURN_BOOL(result);
}

References cmp_numerics(), PG_FREE_IF_COPY, PG_GETARG_NUMERIC, and PG_RETURN_BOOL.

Referenced by equalsJsonbScalarValue(), and gbt_numeric_eq().

numeric_exp()

Datum numeric_exp

(

PG_FUNCTION_ARGS

)

Definition at line 3725 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    Numeric     res;
    NumericVar  arg;
    NumericVar  result;
    int         rscale;
    double      val;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
    {
        /* Per POSIX, exp(-Inf) is zero */
        if (NUMERIC_IS_NINF(num))
            PG_RETURN_NUMERIC(make_result(&const_zero));
        /* For NAN or PINF, just duplicate the input */
        PG_RETURN_NUMERIC(duplicate_numeric(num));
    }
 
    /*
     * Unpack the argument and determine the result scale.  We choose a scale
     * to give at least NUMERIC_MIN_SIG_DIGITS significant digits; but in any
     * case not less than the input's dscale.
     */
    init_var_from_num(num, &arg);
 
    init_var(&result);
 
    /* convert input to float8, ignoring overflow */
    val = numericvar_to_double_no_overflow(&arg);
 
    /*
     * log10(result) = num * log10(e), so this is approximately the decimal
     * weight of the result:
     */
    val *= 0.434294481903252;
 
    /* limit to something that won't cause integer overflow */
    val = Max(val, -NUMERIC_MAX_RESULT_SCALE);
    val = Min(val, NUMERIC_MAX_RESULT_SCALE);
 
    rscale = NUMERIC_MIN_SIG_DIGITS - (int) val;
    rscale = Max(rscale, arg.dscale);
    rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
    rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);
 
    /*
     * Let exp_var() do the calculation and return the result.
     */
    exp_var(&arg, &result, rscale);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References arg, const_zero, duplicate_numeric(), exp_var(), free_var(), init_var, init_var_from_num(), make_result(), Max, Min, NUMERIC_IS_NINF, NUMERIC_IS_SPECIAL, NUMERIC_MAX_DISPLAY_SCALE, NUMERIC_MAX_RESULT_SCALE, NUMERIC_MIN_DISPLAY_SCALE, NUMERIC_MIN_SIG_DIGITS, numericvar_to_double_no_overflow(), PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, and val.

numeric_fac()

Datum numeric_fac

(

PG_FUNCTION_ARGS

)

Definition at line 3601 of file numeric.c.

{
    int64       num = PG_GETARG_INT64(0);
    Numeric     res;
    NumericVar  fact;
    NumericVar  result;
 
    if (num < 0)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("factorial of a negative number is undefined")));
    if (num <= 1)
    {
        res = make_result(&const_one);
        PG_RETURN_NUMERIC(res);
    }
    /* Fail immediately if the result would overflow */
    if (num > 32177)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value overflows numeric format")));
 
    init_var(&fact);
    init_var(&result);
 
    int64_to_numericvar(num, &result);
 
    for (num = num - 1; num > 1; num--)
    {
        /* this loop can take awhile, so allow it to be interrupted */
        CHECK_FOR_INTERRUPTS();
 
        int64_to_numericvar(num, &fact);
 
        mul_var(&result, &fact, &result, 0);
    }
 
    res = make_result(&result);
 
    free_var(&fact);
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References CHECK_FOR_INTERRUPTS, const_one, ereport, errcode(), errmsg(), ERROR, free_var(), init_var, int64_to_numericvar(), make_result(), mul_var(), PG_GETARG_INT64, and PG_RETURN_NUMERIC.

numeric_fast_cmp()

static int numeric_fast_cmp ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 2279 of file numeric.c.

{
    Numeric     nx = DatumGetNumeric(x);
    Numeric     ny = DatumGetNumeric(y);
    int         result;
 
    result = cmp_numerics(nx, ny);
 
    if (nx != DatumGetPointer(x))
        pfree(nx);
    if (ny != DatumGetPointer(y))
        pfree(ny);
 
    return result;
}

References cmp_numerics(), DatumGetNumeric(), DatumGetPointer(), pfree(), x, and y.

Referenced by numeric_sortsupport().

numeric_float4()

Datum numeric_float4

(

PG_FUNCTION_ARGS

)

Definition at line 4651 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    char       *tmp;
    Datum       result;
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_PINF(num))
            PG_RETURN_FLOAT4(get_float4_infinity());
        else if (NUMERIC_IS_NINF(num))
            PG_RETURN_FLOAT4(-get_float4_infinity());
        else
            PG_RETURN_FLOAT4(get_float4_nan());
    }
 
    tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
                                              NumericGetDatum(num)));
 
    result = DirectFunctionCall1(float4in, CStringGetDatum(tmp));
 
    pfree(tmp);
 
    PG_RETURN_DATUM(result);
}

References CStringGetDatum(), DatumGetCString(), DirectFunctionCall1, float4in(), get_float4_infinity(), get_float4_nan(), NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numeric_out(), NumericGetDatum(), pfree(), PG_GETARG_NUMERIC, PG_RETURN_DATUM, and PG_RETURN_FLOAT4.

Referenced by jsonb_float4().

numeric_float8()

Datum numeric_float8

(

PG_FUNCTION_ARGS

)

Definition at line 4557 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    char       *tmp;
    Datum       result;
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_PINF(num))
            PG_RETURN_FLOAT8(get_float8_infinity());
        else if (NUMERIC_IS_NINF(num))
            PG_RETURN_FLOAT8(-get_float8_infinity());
        else
            PG_RETURN_FLOAT8(get_float8_nan());
    }
 
    tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
                                              NumericGetDatum(num)));
 
    result = DirectFunctionCall1(float8in, CStringGetDatum(tmp));
 
    pfree(tmp);
 
    PG_RETURN_DATUM(result);
}

References CStringGetDatum(), DatumGetCString(), DirectFunctionCall1, float8in(), get_float8_infinity(), get_float8_nan(), NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numeric_out(), NumericGetDatum(), pfree(), PG_GETARG_NUMERIC, PG_RETURN_DATUM, and PG_RETURN_FLOAT8.

Referenced by brin_minmax_multi_distance_numeric(), jsonb_float8(), and numrange_subdiff().

numeric_float8_no_overflow()

Datum numeric_float8_no_overflow

(

PG_FUNCTION_ARGS

)

Definition at line 4590 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    double      val;
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_PINF(num))
            val = HUGE_VAL;
        else if (NUMERIC_IS_NINF(num))
            val = -HUGE_VAL;
        else
            val = get_float8_nan();
    }
    else
    {
        NumericVar  x;
 
        init_var_from_num(num, &x);
        val = numericvar_to_double_no_overflow(&x);
    }
 
    PG_RETURN_FLOAT8(val);
}

References get_float8_nan(), init_var_from_num(), NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numericvar_to_double_no_overflow(), PG_GETARG_NUMERIC, PG_RETURN_FLOAT8, val, and x.

Referenced by convert_numeric_to_scalar(), and gbt_numeric_penalty().

numeric_floor()

Datum numeric_floor

(

PG_FUNCTION_ARGS

)

Definition at line 1658 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    Numeric     res;
    NumericVar  result;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
        PG_RETURN_NUMERIC(duplicate_numeric(num));
 
    init_var_from_num(num, &result);
    floor_var(&result, &result);
 
    res = make_result(&result);
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References duplicate_numeric(), floor_var(), free_var(), init_var_from_num(), make_result(), NUMERIC_IS_SPECIAL, PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

Referenced by executeItemOptUnwrapTarget().

numeric_gcd()

Datum numeric_gcd

(

PG_FUNCTION_ARGS

)

Definition at line 3498 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
    Numeric     res;
 
    /*
     * Handle NaN and infinities: we consider the result to be NaN in all such
     * cases.
     */
    if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
        PG_RETURN_NUMERIC(make_result(&const_nan));
 
    /*
     * Unpack the arguments
     */
    init_var_from_num(num1, &arg1);
    init_var_from_num(num2, &arg2);
 
    init_var(&result);
 
    /*
     * Find the GCD and return the result
     */
    gcd_var(&arg1, &arg2, &result);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References const_nan, free_var(), gcd_var(), init_var, init_var_from_num(), make_result(), NUMERIC_IS_SPECIAL, PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

numeric_ge()

Datum numeric_ge

(

PG_FUNCTION_ARGS

)

Definition at line 2477 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    bool        result;
 
    result = cmp_numerics(num1, num2) >= 0;
 
    PG_FREE_IF_COPY(num1, 0);
    PG_FREE_IF_COPY(num2, 1);
 
    PG_RETURN_BOOL(result);
}

References cmp_numerics(), PG_FREE_IF_COPY, PG_GETARG_NUMERIC, and PG_RETURN_BOOL.

Referenced by gbt_numeric_ge(), and numeric_half_rounded().

numeric_gt()

Datum numeric_gt

(

PG_FUNCTION_ARGS

)

Definition at line 2462 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    bool        result;
 
    result = cmp_numerics(num1, num2) > 0;
 
    PG_FREE_IF_COPY(num1, 0);
    PG_FREE_IF_COPY(num2, 1);
 
    PG_RETURN_BOOL(result);
}

References cmp_numerics(), PG_FREE_IF_COPY, PG_GETARG_NUMERIC, and PG_RETURN_BOOL.

Referenced by gbt_numeric_gt(), and gbt_numeric_penalty().

numeric_in()

Datum numeric_in

(

PG_FUNCTION_ARGS

)

Definition at line 626 of file numeric.c.

{
    char       *str = PG_GETARG_CSTRING(0);
#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    Node       *escontext = fcinfo->context;
    Numeric     res;
    const char *cp;
    const char *numstart;
    int         sign;
 
    /* Skip leading spaces */
    cp = str;
    while (*cp)
    {
        if (!isspace((unsigned char) *cp))
            break;
        cp++;
    }
 
    /*
     * Process the number's sign. This duplicates logic in set_var_from_str(),
     * but it's worth doing here, since it simplifies the handling of
     * infinities and non-decimal integers.
     */
    numstart = cp;
    sign = NUMERIC_POS;
 
    if (*cp == '+')
        cp++;
    else if (*cp == '-')
    {
        sign = NUMERIC_NEG;
        cp++;
    }
 
    /*
     * Check for NaN and infinities.  We recognize the same strings allowed by
     * float8in().
     *
     * Since all other legal inputs have a digit or a decimal point after the
     * sign, we need only check for NaN/infinity if that's not the case.
     */
    if (!isdigit((unsigned char) *cp) && *cp != '.')
    {
        /*
         * The number must be NaN or infinity; anything else can only be a
         * syntax error. Note that NaN mustn't have a sign.
         */
        if (pg_strncasecmp(numstart, "NaN", 3) == 0)
        {
            res = make_result(&const_nan);
            cp = numstart + 3;
        }
        else if (pg_strncasecmp(cp, "Infinity", 8) == 0)
        {
            res = make_result(sign == NUMERIC_POS ? &const_pinf : &const_ninf);
            cp += 8;
        }
        else if (pg_strncasecmp(cp, "inf", 3) == 0)
        {
            res = make_result(sign == NUMERIC_POS ? &const_pinf : &const_ninf);
            cp += 3;
        }
        else
            goto invalid_syntax;
 
        /*
         * Check for trailing junk; there should be nothing left but spaces.
         *
         * We intentionally do this check before applying the typmod because
         * we would like to throw any trailing-junk syntax error before any
         * semantic error resulting from apply_typmod_special().
         */
        while (*cp)
        {
            if (!isspace((unsigned char) *cp))
                goto invalid_syntax;
            cp++;
        }
 
        if (!apply_typmod_special(res, typmod, escontext))
            PG_RETURN_NULL();
    }
    else
    {
        /*
         * We have a normal numeric value, which may be a non-decimal integer
         * or a regular decimal number.
         */
        NumericVar  value;
        int         base;
 
        init_var(&value);
 
        /*
         * Determine the number's base by looking for a non-decimal prefix
         * indicator ("0x", "0o", or "0b").
         */
        if (cp[0] == '0')
        {
            switch (cp[1])
            {
                case 'x':
                case 'X':
                    base = 16;
                    break;
                case 'o':
                case 'O':
                    base = 8;
                    break;
                case 'b':
                case 'B':
                    base = 2;
                    break;
                default:
                    base = 10;
            }
        }
        else
            base = 10;
 
        /* Parse the rest of the number and apply the sign */
        if (base == 10)
        {
            if (!set_var_from_str(str, cp, &value, &cp, escontext))
                PG_RETURN_NULL();
            value.sign = sign;
        }
        else
        {
            if (!set_var_from_non_decimal_integer_str(str, cp + 2, sign, base,
                                                      &value, &cp, escontext))
                PG_RETURN_NULL();
        }
 
        /*
         * Should be nothing left but spaces. As above, throw any typmod error
         * after finishing syntax check.
         */
        while (*cp)
        {
            if (!isspace((unsigned char) *cp))
                goto invalid_syntax;
            cp++;
        }
 
        if (!apply_typmod(&value, typmod, escontext))
            PG_RETURN_NULL();
 
        res = make_result_safe(&value, escontext);
 
        free_var(&value);
    }
 
    PG_RETURN_NUMERIC(res);
 
invalid_syntax:
    ereturn(escontext, (Datum) 0,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "numeric", str)));
}

References apply_typmod(), apply_typmod_special(), const_nan, const_ninf, const_pinf, ereturn, errcode(), errmsg(), free_var(), init_var, make_result(), make_result_safe(), NUMERIC_NEG, NUMERIC_POS, PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_NUMERIC, pg_strncasecmp(), set_var_from_non_decimal_integer_str(), set_var_from_str(), sign, str, and value.

Referenced by datum_to_jsonb_internal(), executeItemOptUnwrapTarget(), extract_date(), hstore_to_jsonb_loose(), interval_part_common(), jsonb_in_scalar(), make_const(), numeric_to_number(), pg_lsn_mi(), pg_lsn_mii(), pg_lsn_pli(), pg_size_bytes(), pg_split_walfile_name(), pg_stat_get_activity(), pg_stat_io_build_tuples(), pg_stat_statements_internal(), pg_stat_wal_build_tuple(), PLyNumber_ToJsonbValue(), ssl_client_serial(), SV_to_JsonbValue(), timestamp_part_common(), and timestamptz_part_common().

numeric_inc()

Datum numeric_inc

(

PG_FUNCTION_ARGS

)

Definition at line 3414 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    NumericVar  arg;
    Numeric     res;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
        PG_RETURN_NUMERIC(duplicate_numeric(num));
 
    /*
     * Compute the result and return it
     */
    init_var_from_num(num, &arg);
 
    add_var(&arg, &const_one, &arg);
 
    res = make_result(&arg);
 
    free_var(&arg);
 
    PG_RETURN_NUMERIC(res);
}

References add_var(), arg, const_one, duplicate_numeric(), free_var(), init_var_from_num(), make_result(), NUMERIC_IS_SPECIAL, PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

numeric_int2()

Datum numeric_int2

(

PG_FUNCTION_ARGS

)

Definition at line 4482 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    NumericVar  x;
    int64       val;
    int16       result;
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_NAN(num))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot convert NaN to %s", "smallint")));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot convert infinity to %s", "smallint")));
    }
 
    /* Convert to variable format and thence to int8 */
    init_var_from_num(num, &x);
 
    if (!numericvar_to_int64(&x, &val))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("smallint out of range")));
 
    if (unlikely(val < PG_INT16_MIN) || unlikely(val > PG_INT16_MAX))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("smallint out of range")));
 
    /* Down-convert to int2 */
    result = (int16) val;
 
    PG_RETURN_INT16(result);
}

References ereport, errcode(), errmsg(), ERROR, init_var_from_num(), NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, numericvar_to_int64(), PG_GETARG_NUMERIC, PG_INT16_MAX, PG_INT16_MIN, PG_RETURN_INT16, unlikely, val, and x.

Referenced by jsonb_int2().

numeric_int4()

Datum numeric_int4

(

PG_FUNCTION_ARGS

)

Definition at line 4394 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
 
    PG_RETURN_INT32(numeric_int4_safe(num, NULL));
}

References numeric_int4_safe(), PG_GETARG_NUMERIC, and PG_RETURN_INT32.

Referenced by jsonb_int4().

numeric_int4_safe()

int32 numeric_int4_safe	(	Numeric	num,
		Node *	escontext
	)

Definition at line 4365 of file numeric.c.

{
    NumericVar  x;
    int32       result;
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_NAN(num))
            ereturn(escontext, 0,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot convert NaN to %s", "integer")));
        else
            ereturn(escontext, 0,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot convert infinity to %s", "integer")));
    }
 
    /* Convert to variable format, then convert to int4 */
    init_var_from_num(num, &x);
 
    if (!numericvar_to_int32(&x, &result))
        ereturn(escontext, 0,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("integer out of range")));
 
    return result;
}

References ereturn, errcode(), errmsg(), init_var_from_num(), NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, numericvar_to_int32(), and x.

Referenced by executeDateTimeMethod(), executeItemOptUnwrapTarget(), getArrayIndex(), numeric_int4(), and numeric_to_char().

numeric_int8()

Datum numeric_int8

(

PG_FUNCTION_ARGS

)

Definition at line 4464 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
 
    PG_RETURN_INT64(numeric_int8_safe(num, NULL));
}

References numeric_int8_safe(), PG_GETARG_NUMERIC, and PG_RETURN_INT64.

Referenced by jsonb_int8(), numeric_cash(), and pg_size_bytes().

numeric_int8_safe()

int64 numeric_int8_safe	(	Numeric	num,
		Node *	escontext
	)

Definition at line 4435 of file numeric.c.

{
    NumericVar  x;
    int64       result;
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_NAN(num))
            ereturn(escontext, 0,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot convert NaN to %s", "bigint")));
        else
            ereturn(escontext, 0,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot convert infinity to %s", "bigint")));
    }
 
    /* Convert to variable format, then convert to int8 */
    init_var_from_num(num, &x);
 
    if (!numericvar_to_int64(&x, &result))
        ereturn(escontext, 0,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("bigint out of range")));
 
    return result;
}

References ereturn, errcode(), errmsg(), init_var_from_num(), NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, numericvar_to_int64(), and x.

Referenced by executeItemOptUnwrapTarget(), and numeric_int8().

numeric_is_inf()

bool numeric_is_inf

(

Numeric

num

)

Definition at line 845 of file numeric.c.

{
    return NUMERIC_IS_INF(num);
}

References NUMERIC_IS_INF.

Referenced by executeItemOptUnwrapTarget(), and PLyNumber_ToJsonbValue().

numeric_is_integral()

static bool numeric_is_integral ( Numeric  num )

static

Definition at line 856 of file numeric.c.

{
    NumericVar  arg;
 
    /* Reject NaN, but infinities are considered integral */
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_NAN(num))
            return false;
        return true;
    }
 
    /* Integral if there are no digits to the right of the decimal point */
    init_var_from_num(num, &arg);
 
    return (arg.ndigits == 0 || arg.ndigits <= arg.weight + 1);
}

References arg, init_var_from_num(), NUMERIC_IS_NAN, and NUMERIC_IS_SPECIAL.

Referenced by numeric_power().

numeric_is_nan()

bool numeric_is_nan

(

Numeric

num

)

Definition at line 834 of file numeric.c.

{
    return NUMERIC_IS_NAN(num);
}

References NUMERIC_IS_NAN.

Referenced by executeItemOptUnwrapTarget(), gbt_numeric_penalty(), pg_lsn_mii(), pg_lsn_pli(), and PLyNumber_ToJsonbValue().

numeric_larger()

Datum numeric_larger

(

PG_FUNCTION_ARGS

)

Definition at line 3469 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
 
    /*
     * Use cmp_numerics so that this will agree with the comparison operators,
     * particularly as regards comparisons involving NaN.
     */
    if (cmp_numerics(num1, num2) > 0)
        PG_RETURN_NUMERIC(num1);
    else
        PG_RETURN_NUMERIC(num2);
}

References cmp_numerics(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

numeric_lcm()

Datum numeric_lcm

(

PG_FUNCTION_ARGS

)

Definition at line 3541 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
    Numeric     res;
 
    /*
     * Handle NaN and infinities: we consider the result to be NaN in all such
     * cases.
     */
    if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
        PG_RETURN_NUMERIC(make_result(&const_nan));
 
    /*
     * Unpack the arguments
     */
    init_var_from_num(num1, &arg1);
    init_var_from_num(num2, &arg2);
 
    init_var(&result);
 
    /*
     * Compute the result using lcm(x, y) = abs(x / gcd(x, y) * y), returning
     * zero if either input is zero.
     *
     * Note that the division is guaranteed to be exact, returning an integer
     * result, so the LCM is an integral multiple of both x and y.  A display
     * scale of Min(x.dscale, y.dscale) would be sufficient to represent it,
     * but as with other numeric functions, we choose to return a result whose
     * display scale is no smaller than either input.
     */
    if (arg1.ndigits == 0 || arg2.ndigits == 0)
        set_var_from_var(&const_zero, &result);
    else
    {
        gcd_var(&arg1, &arg2, &result);
        div_var(&arg1, &result, &result, 0, false, true);
        mul_var(&arg2, &result, &result, arg2.dscale);
        result.sign = NUMERIC_POS;
    }
 
    result.dscale = Max(arg1.dscale, arg2.dscale);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References const_nan, const_zero, div_var(), NumericVar::dscale, free_var(), gcd_var(), init_var, init_var_from_num(), make_result(), Max, mul_var(), NumericVar::ndigits, NUMERIC_IS_SPECIAL, NUMERIC_POS, PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, set_var_from_var(), and NumericVar::sign.

numeric_le()

Datum numeric_le

(

PG_FUNCTION_ARGS

)

Definition at line 2507 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    bool        result;
 
    result = cmp_numerics(num1, num2) <= 0;
 
    PG_FREE_IF_COPY(num1, 0);
    PG_FREE_IF_COPY(num2, 1);
 
    PG_RETURN_BOOL(result);
}

References cmp_numerics(), PG_FREE_IF_COPY, PG_GETARG_NUMERIC, and PG_RETURN_BOOL.

Referenced by brin_minmax_multi_distance_numeric(), and gbt_numeric_le().

numeric_ln()

Datum numeric_ln

(

PG_FUNCTION_ARGS

)

Definition at line 3792 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    Numeric     res;
    NumericVar  arg;
    NumericVar  result;
    int         ln_dweight;
    int         rscale;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_NINF(num))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
                     errmsg("cannot take logarithm of a negative number")));
        /* For NAN or PINF, just duplicate the input */
        PG_RETURN_NUMERIC(duplicate_numeric(num));
    }
 
    init_var_from_num(num, &arg);
    init_var(&result);
 
    /* Estimated dweight of logarithm */
    ln_dweight = estimate_ln_dweight(&arg);
 
    rscale = NUMERIC_MIN_SIG_DIGITS - ln_dweight;
    rscale = Max(rscale, arg.dscale);
    rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
    rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);
 
    ln_var(&arg, &result, rscale);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References arg, duplicate_numeric(), ereport, errcode(), errmsg(), ERROR, estimate_ln_dweight(), free_var(), init_var, init_var_from_num(), ln_var(), make_result(), Max, Min, NUMERIC_IS_NINF, NUMERIC_IS_SPECIAL, NUMERIC_MAX_DISPLAY_SCALE, NUMERIC_MIN_DISPLAY_SCALE, NUMERIC_MIN_SIG_DIGITS, PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

numeric_log()

Datum numeric_log

(

PG_FUNCTION_ARGS

)

Definition at line 3841 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    Numeric     res;
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
    {
        int         sign1,
                    sign2;
 
        if (NUMERIC_IS_NAN(num1) || NUMERIC_IS_NAN(num2))
            PG_RETURN_NUMERIC(make_result(&const_nan));
        /* fail on negative inputs including -Inf, as log_var would */
        sign1 = numeric_sign_internal(num1);
        sign2 = numeric_sign_internal(num2);
        if (sign1 < 0 || sign2 < 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
                     errmsg("cannot take logarithm of a negative number")));
        /* fail on zero inputs, as log_var would */
        if (sign1 == 0 || sign2 == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
                     errmsg("cannot take logarithm of zero")));
        if (NUMERIC_IS_PINF(num1))
        {
            /* log(Inf, Inf) reduces to Inf/Inf, so it's NaN */
            if (NUMERIC_IS_PINF(num2))
                PG_RETURN_NUMERIC(make_result(&const_nan));
            /* log(Inf, finite-positive) is zero (we don't throw underflow) */
            PG_RETURN_NUMERIC(make_result(&const_zero));
        }
        Assert(NUMERIC_IS_PINF(num2));
        /* log(finite-positive, Inf) is Inf */
        PG_RETURN_NUMERIC(make_result(&const_pinf));
    }
 
    /*
     * Initialize things
     */
    init_var_from_num(num1, &arg1);
    init_var_from_num(num2, &arg2);
    init_var(&result);
 
    /*
     * Call log_var() to compute and return the result; note it handles scale
     * selection itself.
     */
    log_var(&arg1, &arg2, &result);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References Assert(), const_nan, const_pinf, const_zero, ereport, errcode(), errmsg(), ERROR, free_var(), init_var, init_var_from_num(), log_var(), make_result(), NUMERIC_IS_NAN, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numeric_sign_internal(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

numeric_lt()

Datum numeric_lt

(

PG_FUNCTION_ARGS

)

Definition at line 2492 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    bool        result;
 
    result = cmp_numerics(num1, num2) < 0;
 
    PG_FREE_IF_COPY(num1, 0);
    PG_FREE_IF_COPY(num2, 1);
 
    PG_RETURN_BOOL(result);
}

References cmp_numerics(), PG_FREE_IF_COPY, PG_GETARG_NUMERIC, and PG_RETURN_BOOL.

Referenced by gbt_numeric_lt(), and numeric_is_less().

numeric_maximum_size()

int32 numeric_maximum_size

(

int32

typmod

)

Definition at line 936 of file numeric.c.

{
    int         precision;
    int         numeric_digits;
 
    if (!is_valid_numeric_typmod(typmod))
        return -1;
 
    /* precision (ie, max # of digits) is in upper bits of typmod */
    precision = numeric_typmod_precision(typmod);
 
    /*
     * This formula computes the maximum number of NumericDigits we could need
     * in order to store the specified number of decimal digits. Because the
     * weight is stored as a number of NumericDigits rather than a number of
     * decimal digits, it's possible that the first NumericDigit will contain
     * only a single decimal digit.  Thus, the first two decimal digits can
     * require two NumericDigits to store, but it isn't until we reach
     * DEC_DIGITS + 2 decimal digits that we potentially need a third
     * NumericDigit.
     */
    numeric_digits = (precision + 2 * (DEC_DIGITS - 1)) / DEC_DIGITS;
 
    /*
     * In most cases, the size of a numeric will be smaller than the value
     * computed below, because the varlena header will typically get toasted
     * down to a single byte before being stored on disk, and it may also be
     * possible to use a short numeric header.  But our job here is to compute
     * the worst case.
     */
    return NUMERIC_HDRSZ + (numeric_digits * sizeof(NumericDigit));
}

References DEC_DIGITS, is_valid_numeric_typmod(), NUMERIC_HDRSZ, and numeric_typmod_precision().

Referenced by type_maximum_size().

numeric_min_scale()

Datum numeric_min_scale

(

PG_FUNCTION_ARGS

)

Definition at line 4164 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    NumericVar  arg;
    int         min_scale;
 
    if (NUMERIC_IS_SPECIAL(num))
        PG_RETURN_NULL();
 
    init_var_from_num(num, &arg);
    min_scale = get_min_scale(&arg);
    free_var(&arg);
 
    PG_RETURN_INT32(min_scale);
}

References arg, free_var(), get_min_scale(), init_var_from_num(), NUMERIC_IS_SPECIAL, PG_GETARG_NUMERIC, PG_RETURN_INT32, and PG_RETURN_NULL.

numeric_mod()

Datum numeric_mod

(

PG_FUNCTION_ARGS

)

Definition at line 3338 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    Numeric     res;
 
    res = numeric_mod_safe(num1, num2, NULL);
 
    PG_RETURN_NUMERIC(res);
}

References numeric_mod_safe(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

numeric_mod_safe()

Numeric numeric_mod_safe	(	Numeric	num1,
		Numeric	num2,
		Node *	escontext
	)

Definition at line 3356 of file numeric.c.

{
    Numeric     res;
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
 
    /*
     * Handle NaN and infinities.  We follow POSIX fmod() on this, except that
     * POSIX treats x-is-infinite and y-is-zero identically, raising EDOM and
     * returning NaN.  We choose to throw error only for y-is-zero.
     */
    if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
    {
        if (NUMERIC_IS_NAN(num1) || NUMERIC_IS_NAN(num2))
            return make_result(&const_nan);
        if (NUMERIC_IS_INF(num1))
        {
            if (numeric_sign_internal(num2) == 0)
                goto division_by_zero;
 
            /* Inf % any nonzero = NaN */
            return make_result(&const_nan);
        }
        /* num2 must be [-]Inf; result is num1 regardless of sign of num2 */
        return duplicate_numeric(num1);
    }
 
    init_var_from_num(num1, &arg1);
    init_var_from_num(num2, &arg2);
 
    init_var(&result);
 
    /* Check for division by zero */
    if (arg2.ndigits == 0 || arg2.digits[0] == 0)
        goto division_by_zero;
 
    mod_var(&arg1, &arg2, &result);
 
    res = make_result_safe(&result, escontext);
 
    free_var(&result);
 
    return res;
 
division_by_zero:
    ereturn(escontext, NULL,
            errcode(ERRCODE_DIVISION_BY_ZERO),
            errmsg("division by zero"));
}

References const_nan, NumericVar::digits, duplicate_numeric(), ereturn, errcode(), errmsg(), free_var(), init_var, init_var_from_num(), make_result(), make_result_safe(), mod_var(), NumericVar::ndigits, NUMERIC_IS_INF, NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, and numeric_sign_internal().

Referenced by executeItemOptUnwrapTarget(), and numeric_mod().

numeric_mul()

Datum numeric_mul

(

PG_FUNCTION_ARGS

)

Definition at line 3016 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    Numeric     res;
 
    res = numeric_mul_safe(num1, num2, NULL);
 
    PG_RETURN_NUMERIC(res);
}

References numeric_mul_safe(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

Referenced by numeric_cash(), numeric_to_char(), numeric_to_number(), and pg_size_bytes().

numeric_mul_safe()

Numeric numeric_mul_safe	(	Numeric	num1,
		Numeric	num2,
		Node *	escontext
	)

Definition at line 3034 of file numeric.c.

{
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
    Numeric     res;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
    {
        if (NUMERIC_IS_NAN(num1) || NUMERIC_IS_NAN(num2))
            return make_result(&const_nan);
        if (NUMERIC_IS_PINF(num1))
        {
            switch (numeric_sign_internal(num2))
            {
                case 0:
                    return make_result(&const_nan); /* Inf * 0 */
                case 1:
                    return make_result(&const_pinf);
                case -1:
                    return make_result(&const_ninf);
            }
            Assert(false);
        }
        if (NUMERIC_IS_NINF(num1))
        {
            switch (numeric_sign_internal(num2))
            {
                case 0:
                    return make_result(&const_nan); /* -Inf * 0 */
                case 1:
                    return make_result(&const_ninf);
                case -1:
                    return make_result(&const_pinf);
            }
            Assert(false);
        }
        /* by here, num1 must be finite, so num2 is not */
        if (NUMERIC_IS_PINF(num2))
        {
            switch (numeric_sign_internal(num1))
            {
                case 0:
                    return make_result(&const_nan); /* 0 * Inf */
                case 1:
                    return make_result(&const_pinf);
                case -1:
                    return make_result(&const_ninf);
            }
            Assert(false);
        }
        Assert(NUMERIC_IS_NINF(num2));
        switch (numeric_sign_internal(num1))
        {
            case 0:
                return make_result(&const_nan); /* 0 * -Inf */
            case 1:
                return make_result(&const_ninf);
            case -1:
                return make_result(&const_pinf);
        }
        Assert(false);
    }
 
    /*
     * Unpack the values, let mul_var() compute the result and return it.
     * Unlike add_var() and sub_var(), mul_var() will round its result. In the
     * case of numeric_mul(), which is invoked for the * operator on numerics,
     * we request exact representation for the product (rscale = sum(dscale of
     * arg1, dscale of arg2)).  If the exact result has more digits after the
     * decimal point than can be stored in a numeric, we round it.  Rounding
     * after computing the exact result ensures that the final result is
     * correctly rounded (rounding in mul_var() using a truncated product
     * would not guarantee this).
     */
    init_var_from_num(num1, &arg1);
    init_var_from_num(num2, &arg2);
 
    init_var(&result);
    mul_var(&arg1, &arg2, &result, arg1.dscale + arg2.dscale);
 
    if (result.dscale > NUMERIC_DSCALE_MAX)
        round_var(&result, NUMERIC_DSCALE_MAX);
 
    res = make_result_safe(&result, escontext);
 
    free_var(&result);
 
    return res;
}

References Assert(), const_nan, const_ninf, const_pinf, NumericVar::dscale, free_var(), init_var, init_var_from_num(), make_result(), make_result_safe(), mul_var(), NUMERIC_DSCALE_MAX, NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numeric_sign_internal(), and round_var().

Referenced by executeItemOptUnwrapTarget(), and numeric_mul().

numeric_ne()

Datum numeric_ne

(

PG_FUNCTION_ARGS

)

Definition at line 2447 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    bool        result;
 
    result = cmp_numerics(num1, num2) != 0;
 
    PG_FREE_IF_COPY(num1, 0);
    PG_FREE_IF_COPY(num2, 1);
 
    PG_RETURN_BOOL(result);
}

References cmp_numerics(), PG_FREE_IF_COPY, PG_GETARG_NUMERIC, and PG_RETURN_BOOL.

numeric_normalize()

char * numeric_normalize

(

Numeric

num

)

Definition at line 1009 of file numeric.c.

{
    NumericVar  x;
    char       *str;
    int         last;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_PINF(num))
            return pstrdup("Infinity");
        else if (NUMERIC_IS_NINF(num))
            return pstrdup("-Infinity");
        else
            return pstrdup("NaN");
    }
 
    init_var_from_num(num, &x);
 
    str = get_str_from_var(&x);
 
    /* If there's no decimal point, there's certainly nothing to remove. */
    if (strchr(str, '.') != NULL)
    {
        /*
         * Back up over trailing fractional zeroes.  Since there is a decimal
         * point, this loop will terminate safely.
         */
        last = strlen(str) - 1;
        while (str[last] == '0')
            last--;
 
        /* We want to get rid of the decimal point too, if it's now last. */
        if (str[last] == '.')
            last--;
 
        /* Delete whatever we backed up over. */
        str[last + 1] = '\0';
    }
 
    return str;
}

References get_str_from_var(), init_var_from_num(), NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, pstrdup(), str, and x.

Referenced by make_scalar_key().

numeric_out()

Datum numeric_out

(

PG_FUNCTION_ARGS

)

Definition at line 799 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    NumericVar  x;
    char       *str;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_PINF(num))
            PG_RETURN_CSTRING(pstrdup("Infinity"));
        else if (NUMERIC_IS_NINF(num))
            PG_RETURN_CSTRING(pstrdup("-Infinity"));
        else
            PG_RETURN_CSTRING(pstrdup("NaN"));
    }
 
    /*
     * Get the number in the variable format.
     */
    init_var_from_num(num, &x);
 
    str = get_str_from_var(&x);
 
    PG_RETURN_CSTRING(str);
}

References get_str_from_var(), init_var_from_num(), NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, PG_GETARG_NUMERIC, PG_RETURN_CSTRING, pstrdup(), str, and x.

Referenced by ExecGetJsonValueItemString(), executeItemOptUnwrapTarget(), iterate_jsonb_values(), jsonb_put_escaped_value(), JsonbUnquote(), JsonbValue_to_SV(), JsonbValueAsText(), numeric_float4(), numeric_float8(), numeric_to_char(), numeric_to_cstring(), PLyDecimal_FromNumeric(), PLyObject_FromJsonbValue(), populate_scalar(), and printJsonPathItem().

numeric_out_sci()

char * numeric_out_sci	(	Numeric	num,
		int	scale
	)

Definition at line 975 of file numeric.c.

{
    NumericVar  x;
    char       *str;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_PINF(num))
            return pstrdup("Infinity");
        else if (NUMERIC_IS_NINF(num))
            return pstrdup("-Infinity");
        else
            return pstrdup("NaN");
    }
 
    init_var_from_num(num, &x);
 
    str = get_str_from_var_sci(&x, scale);
 
    return str;
}

References get_str_from_var_sci(), init_var_from_num(), NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, pstrdup(), scale, str, and x.

Referenced by int8_to_char(), and numeric_to_char().

numeric_pg_lsn()

Datum numeric_pg_lsn

(

PG_FUNCTION_ARGS

)

Definition at line 4679 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    NumericVar  x;
    XLogRecPtr  result;
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_NAN(num))
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot convert NaN to %s", "pg_lsn")));
        else
            ereport(ERROR,
                    (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                     errmsg("cannot convert infinity to %s", "pg_lsn")));
    }
 
    /* Convert to variable format and thence to pg_lsn */
    init_var_from_num(num, &x);
 
    if (!numericvar_to_uint64(&x, (uint64 *) &result))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("pg_lsn out of range")));
 
    PG_RETURN_LSN(result);
}

References ereport, errcode(), errmsg(), ERROR, init_var_from_num(), NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, numericvar_to_uint64(), PG_GETARG_NUMERIC, PG_RETURN_LSN, and x.

Referenced by pg_lsn_mii(), and pg_lsn_pli().

numeric_poly_avg()

Datum numeric_poly_avg

(

PG_FUNCTION_ARGS

)

Definition at line 5893 of file numeric.c.

{
    Int128AggState *state;
    NumericVar  result;
    Datum       countd,
                sumd;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    /* If there were no non-null inputs, return NULL */
    if (state == NULL || state->N == 0)
        PG_RETURN_NULL();
 
    init_var(&result);
 
    int128_to_numericvar(state->sumX, &result);
 
    countd = NumericGetDatum(int64_to_numeric(state->N));
    sumd = NumericGetDatum(make_result(&result));
 
    free_var(&result);
 
    PG_RETURN_DATUM(DirectFunctionCall2(numeric_div, sumd, countd));
}

References DirectFunctionCall2, free_var(), init_var, int128_to_numericvar(), int64_to_numeric(), make_result(), numeric_div(), NumericGetDatum(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_DATUM, and PG_RETURN_NULL.

numeric_poly_combine()

Datum numeric_poly_combine

(

PG_FUNCTION_ARGS

)

Definition at line 5525 of file numeric.c.

{
    Int128AggState *state1;
    Int128AggState *state2;
    MemoryContext agg_context;
    MemoryContext old_context;
 
    if (!AggCheckCallContext(fcinfo, &agg_context))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state1 = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
    state2 = PG_ARGISNULL(1) ? NULL : (Int128AggState *) PG_GETARG_POINTER(1);
 
    if (state2 == NULL)
        PG_RETURN_POINTER(state1);
 
    /* manually copy all fields from state2 to state1 */
    if (state1 == NULL)
    {
        old_context = MemoryContextSwitchTo(agg_context);
 
        state1 = makeInt128AggState(fcinfo, true);
        state1->N = state2->N;
        state1->sumX = state2->sumX;
        state1->sumX2 = state2->sumX2;
 
        MemoryContextSwitchTo(old_context);
 
        PG_RETURN_POINTER(state1);
    }
 
    if (state2->N > 0)
    {
        state1->N += state2->N;
        int128_add_int128(&state1->sumX, state2->sumX);
        int128_add_int128(&state1->sumX2, state2->sumX2);
    }
    PG_RETURN_POINTER(state1);
}

References AggCheckCallContext(), elog, ERROR, int128_add_int128(), makeInt128AggState(), MemoryContextSwitchTo(), Int128AggState::N, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_POINTER, Int128AggState::sumX, and Int128AggState::sumX2.

numeric_poly_deserialize()

Datum numeric_poly_deserialize

(

PG_FUNCTION_ARGS

)

Definition at line 5627 of file numeric.c.

{
    bytea      *sstate;
    Int128AggState *result;
    StringInfoData buf;
 
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    sstate = PG_GETARG_BYTEA_PP(0);
 
    /*
     * Initialize a StringInfo so that we can "receive" it using the standard
     * recv-function infrastructure.
     */
    initReadOnlyStringInfo(&buf, VARDATA_ANY(sstate),
                           VARSIZE_ANY_EXHDR(sstate));
 
    result = makeInt128AggStateCurrentContext(false);
 
    /* N */
    result->N = pq_getmsgint64(&buf);
 
    /* sumX */
    result->sumX = int128_deserialize(&buf);
 
    /* sumX2 */
    result->sumX2 = int128_deserialize(&buf);
 
    pq_getmsgend(&buf);
 
    PG_RETURN_POINTER(result);
}

References AggCheckCallContext(), buf, elog, ERROR, initReadOnlyStringInfo(), int128_deserialize(), makeInt128AggStateCurrentContext(), Int128AggState::N, PG_GETARG_BYTEA_PP, PG_RETURN_POINTER, pq_getmsgend(), pq_getmsgint64(), Int128AggState::sumX, Int128AggState::sumX2, VARDATA_ANY(), and VARSIZE_ANY_EXHDR().

numeric_poly_serialize()

Datum numeric_poly_serialize

(

PG_FUNCTION_ARGS

)

Definition at line 5593 of file numeric.c.

{
    Int128AggState *state;
    StringInfoData buf;
    bytea      *result;
 
    /* Ensure we disallow calling when not in aggregate context */
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state = (Int128AggState *) PG_GETARG_POINTER(0);
 
    pq_begintypsend(&buf);
 
    /* N */
    pq_sendint64(&buf, state->N);
 
    /* sumX */
    int128_serialize(&buf, state->sumX);
 
    /* sumX2 */
    int128_serialize(&buf, state->sumX2);
 
    result = pq_endtypsend(&buf);
 
    PG_RETURN_BYTEA_P(result);
}

References AggCheckCallContext(), buf, elog, ERROR, int128_serialize(), PG_GETARG_POINTER, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), and pq_sendint64().

numeric_poly_stddev_internal()

static Numeric numeric_poly_stddev_internal ( Int128AggState *  state, bool  variance, bool  sample, bool *  is_null  )

static

Definition at line 6149 of file numeric.c.

{
    NumericAggState numstate;
    Numeric     res;
 
    /* Initialize an empty agg state */
    memset(&numstate, 0, sizeof(NumericAggState));
 
    if (state)
    {
        NumericVar  tmp_var;
 
        numstate.N = state->N;
 
        init_var(&tmp_var);
 
        int128_to_numericvar(state->sumX, &tmp_var);
        accum_sum_add(&numstate.sumX, &tmp_var);
 
        int128_to_numericvar(state->sumX2, &tmp_var);
        accum_sum_add(&numstate.sumX2, &tmp_var);
 
        free_var(&tmp_var);
    }
 
    res = numeric_stddev_internal(&numstate, variance, sample, is_null);
 
    if (numstate.sumX.ndigits > 0)
    {
        pfree(numstate.sumX.pos_digits);
        pfree(numstate.sumX.neg_digits);
    }
    if (numstate.sumX2.ndigits > 0)
    {
        pfree(numstate.sumX2.pos_digits);
        pfree(numstate.sumX2.neg_digits);
    }
 
    return res;
}

References accum_sum_add(), free_var(), init_var, int128_to_numericvar(), NumericAggState::N, NumericSumAccum::ndigits, NumericSumAccum::neg_digits, numeric_stddev_internal(), pfree(), NumericSumAccum::pos_digits, NumericAggState::sumX, and NumericAggState::sumX2.

Referenced by numeric_poly_stddev_pop(), numeric_poly_stddev_samp(), numeric_poly_var_pop(), and numeric_poly_var_samp().

numeric_poly_stddev_pop()

Datum numeric_poly_stddev_pop

(

PG_FUNCTION_ARGS

)

Definition at line 6244 of file numeric.c.

{
    Int128AggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    res = numeric_poly_stddev_internal(state, false, false, &is_null);
 
    if (is_null)
        PG_RETURN_NULL();
    else
        PG_RETURN_NUMERIC(res);
}

References numeric_poly_stddev_internal(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numeric_poly_stddev_samp()

Datum numeric_poly_stddev_samp

(

PG_FUNCTION_ARGS

)

Definition at line 6210 of file numeric.c.

{
    Int128AggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    res = numeric_poly_stddev_internal(state, false, true, &is_null);
 
    if (is_null)
        PG_RETURN_NULL();
    else
        PG_RETURN_NUMERIC(res);
}

References numeric_poly_stddev_internal(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numeric_poly_sum()

Datum numeric_poly_sum

(

PG_FUNCTION_ARGS

)

Definition at line 5869 of file numeric.c.

{
    Int128AggState *state;
    Numeric     res;
    NumericVar  result;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    /* If there were no non-null inputs, return NULL */
    if (state == NULL || state->N == 0)
        PG_RETURN_NULL();
 
    init_var(&result);
 
    int128_to_numericvar(state->sumX, &result);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References free_var(), init_var, int128_to_numericvar(), make_result(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numeric_poly_var_pop()

Datum numeric_poly_var_pop

(

PG_FUNCTION_ARGS

)

Definition at line 6227 of file numeric.c.

{
    Int128AggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    res = numeric_poly_stddev_internal(state, true, false, &is_null);
 
    if (is_null)
        PG_RETURN_NULL();
    else
        PG_RETURN_NUMERIC(res);
}

References numeric_poly_stddev_internal(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numeric_poly_var_samp()

Datum numeric_poly_var_samp

(

PG_FUNCTION_ARGS

)

Definition at line 6193 of file numeric.c.

{
    Int128AggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);
 
    res = numeric_poly_stddev_internal(state, true, true, &is_null);
 
    if (is_null)
        PG_RETURN_NULL();
    else
        PG_RETURN_NUMERIC(res);
}

References numeric_poly_stddev_internal(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numeric_power()

Datum numeric_power

(

PG_FUNCTION_ARGS

)

Definition at line 3912 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    Numeric     res;
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
    int         sign1,
                sign2;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
    {
        /*
         * We follow the POSIX spec for pow(3), which says that NaN ^ 0 = 1,
         * and 1 ^ NaN = 1, while all other cases with NaN inputs yield NaN
         * (with no error).
         */
        if (NUMERIC_IS_NAN(num1))
        {
            if (!NUMERIC_IS_SPECIAL(num2))
            {
                init_var_from_num(num2, &arg2);
                if (cmp_var(&arg2, &const_zero) == 0)
                    PG_RETURN_NUMERIC(make_result(&const_one));
            }
            PG_RETURN_NUMERIC(make_result(&const_nan));
        }
        if (NUMERIC_IS_NAN(num2))
        {
            if (!NUMERIC_IS_SPECIAL(num1))
            {
                init_var_from_num(num1, &arg1);
                if (cmp_var(&arg1, &const_one) == 0)
                    PG_RETURN_NUMERIC(make_result(&const_one));
            }
            PG_RETURN_NUMERIC(make_result(&const_nan));
        }
        /* At least one input is infinite, but error rules still apply */
        sign1 = numeric_sign_internal(num1);
        sign2 = numeric_sign_internal(num2);
        if (sign1 == 0 && sign2 < 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
                     errmsg("zero raised to a negative power is undefined")));
        if (sign1 < 0 && !numeric_is_integral(num2))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
                     errmsg("a negative number raised to a non-integer power yields a complex result")));
 
        /*
         * POSIX gives this series of rules for pow(3) with infinite inputs:
         *
         * For any value of y, if x is +1, 1.0 shall be returned.
         */
        if (!NUMERIC_IS_SPECIAL(num1))
        {
            init_var_from_num(num1, &arg1);
            if (cmp_var(&arg1, &const_one) == 0)
                PG_RETURN_NUMERIC(make_result(&const_one));
        }
 
        /*
         * For any value of x, if y is [-]0, 1.0 shall be returned.
         */
        if (sign2 == 0)
            PG_RETURN_NUMERIC(make_result(&const_one));
 
        /*
         * For any odd integer value of y > 0, if x is [-]0, [-]0 shall be
         * returned.  For y > 0 and not an odd integer, if x is [-]0, +0 shall
         * be returned.  (Since we don't deal in minus zero, we need not
         * distinguish these two cases.)
         */
        if (sign1 == 0 && sign2 > 0)
            PG_RETURN_NUMERIC(make_result(&const_zero));
 
        /*
         * If x is -1, and y is [-]Inf, 1.0 shall be returned.
         *
         * For |x| < 1, if y is -Inf, +Inf shall be returned.
         *
         * For |x| > 1, if y is -Inf, +0 shall be returned.
         *
         * For |x| < 1, if y is +Inf, +0 shall be returned.
         *
         * For |x| > 1, if y is +Inf, +Inf shall be returned.
         */
        if (NUMERIC_IS_INF(num2))
        {
            bool        abs_x_gt_one;
 
            if (NUMERIC_IS_SPECIAL(num1))
                abs_x_gt_one = true;    /* x is either Inf or -Inf */
            else
            {
                init_var_from_num(num1, &arg1);
                if (cmp_var(&arg1, &const_minus_one) == 0)
                    PG_RETURN_NUMERIC(make_result(&const_one));
                arg1.sign = NUMERIC_POS;    /* now arg1 = abs(x) */
                abs_x_gt_one = (cmp_var(&arg1, &const_one) > 0);
            }
            if (abs_x_gt_one == (sign2 > 0))
                PG_RETURN_NUMERIC(make_result(&const_pinf));
            else
                PG_RETURN_NUMERIC(make_result(&const_zero));
        }
 
        /*
         * For y < 0, if x is +Inf, +0 shall be returned.
         *
         * For y > 0, if x is +Inf, +Inf shall be returned.
         */
        if (NUMERIC_IS_PINF(num1))
        {
            if (sign2 > 0)
                PG_RETURN_NUMERIC(make_result(&const_pinf));
            else
                PG_RETURN_NUMERIC(make_result(&const_zero));
        }
 
        Assert(NUMERIC_IS_NINF(num1));
 
        /*
         * For y an odd integer < 0, if x is -Inf, -0 shall be returned.  For
         * y < 0 and not an odd integer, if x is -Inf, +0 shall be returned.
         * (Again, we need not distinguish these two cases.)
         */
        if (sign2 < 0)
            PG_RETURN_NUMERIC(make_result(&const_zero));
 
        /*
         * For y an odd integer > 0, if x is -Inf, -Inf shall be returned. For
         * y > 0 and not an odd integer, if x is -Inf, +Inf shall be returned.
         */
        init_var_from_num(num2, &arg2);
        if (arg2.ndigits > 0 && arg2.ndigits == arg2.weight + 1 &&
            (arg2.digits[arg2.ndigits - 1] & 1))
            PG_RETURN_NUMERIC(make_result(&const_ninf));
        else
            PG_RETURN_NUMERIC(make_result(&const_pinf));
    }
 
    /*
     * The SQL spec requires that we emit a particular SQLSTATE error code for
     * certain error conditions.  Specifically, we don't return a
     * divide-by-zero error code for 0 ^ -1.  Raising a negative number to a
     * non-integer power must produce the same error code, but that case is
     * handled in power_var().
     */
    sign1 = numeric_sign_internal(num1);
    sign2 = numeric_sign_internal(num2);
 
    if (sign1 == 0 && sign2 < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
                 errmsg("zero raised to a negative power is undefined")));
 
    /*
     * Initialize things
     */
    init_var(&result);
    init_var_from_num(num1, &arg1);
    init_var_from_num(num2, &arg2);
 
    /*
     * Call power_var() to compute and return the result; note it handles
     * scale selection itself.
     */
    power_var(&arg1, &arg2, &result);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References Assert(), cmp_var(), const_minus_one, const_nan, const_ninf, const_one, const_pinf, const_zero, NumericVar::digits, ereport, errcode(), errmsg(), ERROR, free_var(), init_var, init_var_from_num(), make_result(), NumericVar::ndigits, NUMERIC_IS_INF, numeric_is_integral(), NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, NUMERIC_POS, numeric_sign_internal(), PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, power_var(), NumericVar::sign, and NumericVar::weight.

Referenced by numeric_to_char(), and numeric_to_number().

numeric_recv()

Datum numeric_recv

(

PG_FUNCTION_ARGS

)

Definition at line 1061 of file numeric.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
 
#ifdef NOT_USED
    Oid         typelem = PG_GETARG_OID(1);
#endif
    int32       typmod = PG_GETARG_INT32(2);
    NumericVar  value;
    Numeric     res;
    int         len,
                i;
 
    init_var(&value);
 
    len = (uint16) pq_getmsgint(buf, sizeof(uint16));
 
    alloc_var(&value, len);
 
    value.weight = (int16) pq_getmsgint(buf, sizeof(int16));
    /* we allow any int16 for weight --- OK? */
 
    value.sign = (uint16) pq_getmsgint(buf, sizeof(uint16));
    if (!(value.sign == NUMERIC_POS ||
          value.sign == NUMERIC_NEG ||
          value.sign == NUMERIC_NAN ||
          value.sign == NUMERIC_PINF ||
          value.sign == NUMERIC_NINF))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid sign in external \"numeric\" value")));
 
    value.dscale = (uint16) pq_getmsgint(buf, sizeof(uint16));
    if ((value.dscale & NUMERIC_DSCALE_MASK) != value.dscale)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("invalid scale in external \"numeric\" value")));
 
    for (i = 0; i < len; i++)
    {
        NumericDigit d = pq_getmsgint(buf, sizeof(NumericDigit));
 
        if (d < 0 || d >= NBASE)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                     errmsg("invalid digit in external \"numeric\" value")));
        value.digits[i] = d;
    }
 
    /*
     * If the given dscale would hide any digits, truncate those digits away.
     * We could alternatively throw an error, but that would take a bunch of
     * extra code (about as much as trunc_var involves), and it might cause
     * client compatibility issues.  Be careful not to apply trunc_var to
     * special values, as it could do the wrong thing; we don't need it
     * anyway, since make_result will ignore all but the sign field.
     *
     * After doing that, be sure to check the typmod restriction.
     */
    if (value.sign == NUMERIC_POS ||
        value.sign == NUMERIC_NEG)
    {
        trunc_var(&value, value.dscale);
 
        (void) apply_typmod(&value, typmod, NULL);
 
        res = make_result(&value);
    }
    else
    {
        /* apply_typmod_special wants us to make the Numeric first */
        res = make_result(&value);
 
        (void) apply_typmod_special(res, typmod, NULL);
    }
 
    free_var(&value);
 
    PG_RETURN_NUMERIC(res);
}

References alloc_var(), apply_typmod(), apply_typmod_special(), buf, ereport, errcode(), errmsg(), ERROR, free_var(), i, init_var, len, make_result(), NBASE, NUMERIC_DSCALE_MASK, NUMERIC_NAN, NUMERIC_NEG, NUMERIC_NINF, NUMERIC_PINF, NUMERIC_POS, PG_GETARG_INT32, PG_GETARG_OID, PG_GETARG_POINTER, PG_RETURN_NUMERIC, pq_getmsgint(), trunc_var(), and value.

numeric_round()

Datum numeric_round

(

PG_FUNCTION_ARGS

)

Definition at line 1526 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    int32       scale = PG_GETARG_INT32(1);
    Numeric     res;
    NumericVar  arg;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
        PG_RETURN_NUMERIC(duplicate_numeric(num));
 
    /*
     * Limit the scale value to avoid possible overflow in calculations.
     *
     * These limits are based on the maximum number of digits a Numeric value
     * can have before and after the decimal point, but we must allow for one
     * extra digit before the decimal point, in case the most significant
     * digit rounds up; we must check if that causes Numeric overflow.
     */
    scale = Max(scale, -(NUMERIC_WEIGHT_MAX + 1) * DEC_DIGITS - 1);
    scale = Min(scale, NUMERIC_DSCALE_MAX);
 
    /*
     * Unpack the argument and round it at the proper digit position
     */
    init_var(&arg);
    set_var_from_num(num, &arg);
 
    round_var(&arg, scale);
 
    /* We don't allow negative output dscale */
    if (scale < 0)
        arg.dscale = 0;
 
    /*
     * Return the rounded result
     */
    res = make_result(&arg);
 
    free_var(&arg);
    PG_RETURN_NUMERIC(res);
}

References arg, DEC_DIGITS, duplicate_numeric(), free_var(), init_var, make_result(), Max, Min, NUMERIC_DSCALE_MAX, NUMERIC_IS_SPECIAL, NUMERIC_WEIGHT_MAX, PG_GETARG_INT32, PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, round_var(), scale, and set_var_from_num().

Referenced by cash_numeric(), numeric_to_char(), timestamp_part_common(), and timestamptz_part_common().

numeric_scale()

Datum numeric_scale

(

PG_FUNCTION_ARGS

)

Definition at line 4099 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
 
    if (NUMERIC_IS_SPECIAL(num))
        PG_RETURN_NULL();
 
    PG_RETURN_INT32(NUMERIC_DSCALE(num));
}

References NUMERIC_DSCALE, NUMERIC_IS_SPECIAL, PG_GETARG_NUMERIC, PG_RETURN_INT32, and PG_RETURN_NULL.

Referenced by cash_numeric(), and numeric_cash().

numeric_send()

Datum numeric_send

(

PG_FUNCTION_ARGS

)

Definition at line 1146 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    NumericVar  x;
    StringInfoData buf;
    int         i;
 
    init_var_from_num(num, &x);
 
    pq_begintypsend(&buf);
 
    pq_sendint16(&buf, x.ndigits);
    pq_sendint16(&buf, x.weight);
    pq_sendint16(&buf, x.sign);
    pq_sendint16(&buf, x.dscale);
    for (i = 0; i < x.ndigits; i++)
        pq_sendint16(&buf, x.digits[i]);
 
    PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}

References buf, i, init_var_from_num(), PG_GETARG_NUMERIC, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint16(), and x.

numeric_serialize()

Datum numeric_serialize

(

PG_FUNCTION_ARGS

)

Definition at line 5243 of file numeric.c.

{
    NumericAggState *state;
    StringInfoData buf;
    bytea      *result;
    NumericVar  tmp_var;
 
    /* Ensure we disallow calling when not in aggregate context */
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state = (NumericAggState *) PG_GETARG_POINTER(0);
 
    init_var(&tmp_var);
 
    pq_begintypsend(&buf);
 
    /* N */
    pq_sendint64(&buf, state->N);
 
    /* sumX */
    accum_sum_final(&state->sumX, &tmp_var);
    numericvar_serialize(&buf, &tmp_var);
 
    /* sumX2 */
    accum_sum_final(&state->sumX2, &tmp_var);
    numericvar_serialize(&buf, &tmp_var);
 
    /* maxScale */
    pq_sendint32(&buf, state->maxScale);
 
    /* maxScaleCount */
    pq_sendint64(&buf, state->maxScaleCount);
 
    /* NaNcount */
    pq_sendint64(&buf, state->NaNcount);
 
    /* pInfcount */
    pq_sendint64(&buf, state->pInfcount);
 
    /* nInfcount */
    pq_sendint64(&buf, state->nInfcount);
 
    result = pq_endtypsend(&buf);
 
    free_var(&tmp_var);
 
    PG_RETURN_BYTEA_P(result);
}

References accum_sum_final(), AggCheckCallContext(), buf, elog, ERROR, free_var(), init_var, numericvar_serialize(), PG_GETARG_POINTER, PG_RETURN_BYTEA_P, pq_begintypsend(), pq_endtypsend(), pq_sendint32(), and pq_sendint64().

numeric_sign()

Datum numeric_sign

(

PG_FUNCTION_ARGS

)

Definition at line 1493 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
 
    /*
     * Handle NaN (infinities can be handled normally)
     */
    if (NUMERIC_IS_NAN(num))
        PG_RETURN_NUMERIC(make_result(&const_nan));
 
    switch (numeric_sign_internal(num))
    {
        case 0:
            PG_RETURN_NUMERIC(make_result(&const_zero));
        case 1:
            PG_RETURN_NUMERIC(make_result(&const_one));
        case -1:
            PG_RETURN_NUMERIC(make_result(&const_minus_one));
    }
 
    Assert(false);
    return (Datum) 0;
}

References Assert(), const_minus_one, const_nan, const_one, const_zero, make_result(), NUMERIC_IS_NAN, numeric_sign_internal(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

numeric_sign_internal()

static int numeric_sign_internal ( Numeric  num )

static

Definition at line 1461 of file numeric.c.

{
    if (NUMERIC_IS_SPECIAL(num))
    {
        Assert(!NUMERIC_IS_NAN(num));
        /* Must be Inf or -Inf */
        if (NUMERIC_IS_PINF(num))
            return 1;
        else
            return -1;
    }
 
    /*
     * The packed format is known to be totally zero digit trimmed always. So
     * once we've eliminated specials, we can identify a zero by the fact that
     * there are no digits at all.
     */
    else if (NUMERIC_NDIGITS(num) == 0)
        return 0;
    else if (NUMERIC_SIGN(num) == NUMERIC_NEG)
        return -1;
    else
        return 1;
}

References Assert(), NUMERIC_IS_NAN, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, NUMERIC_NDIGITS, NUMERIC_NEG, and NUMERIC_SIGN.

Referenced by numeric_div_safe(), numeric_div_trunc(), numeric_log(), numeric_mod_safe(), numeric_mul_safe(), numeric_power(), and numeric_sign().

numeric_smaller()

Datum numeric_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 3447 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
 
    /*
     * Use cmp_numerics so that this will agree with the comparison operators,
     * particularly as regards comparisons involving NaN.
     */
    if (cmp_numerics(num1, num2) < 0)
        PG_RETURN_NUMERIC(num1);
    else
        PG_RETURN_NUMERIC(num2);
}

References cmp_numerics(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

numeric_sortsupport()

Datum numeric_sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 2109 of file numeric.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
 
    ssup->comparator = numeric_fast_cmp;
 
    if (ssup->abbreviate)
    {
        NumericSortSupport *nss;
        MemoryContext oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
 
        nss = palloc(sizeof(NumericSortSupport));
 
        /*
         * palloc a buffer for handling unaligned packed values in addition to
         * the support struct
         */
        nss->buf = palloc(VARATT_SHORT_MAX + VARHDRSZ + 1);
 
        nss->input_count = 0;
        nss->estimating = true;
        initHyperLogLog(&nss->abbr_card, 10);
 
        ssup->ssup_extra = nss;
 
        ssup->abbrev_full_comparator = ssup->comparator;
        ssup->comparator = numeric_cmp_abbrev;
        ssup->abbrev_converter = numeric_abbrev_convert;
        ssup->abbrev_abort = numeric_abbrev_abort;
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    PG_RETURN_VOID();
}

References NumericSortSupport::abbr_card, SortSupportData::abbrev_abort, SortSupportData::abbrev_converter, SortSupportData::abbrev_full_comparator, SortSupportData::abbreviate, NumericSortSupport::buf, SortSupportData::comparator, NumericSortSupport::estimating, initHyperLogLog(), NumericSortSupport::input_count, MemoryContextSwitchTo(), numeric_abbrev_abort(), numeric_abbrev_convert(), numeric_cmp_abbrev(), numeric_fast_cmp(), palloc(), PG_GETARG_POINTER, PG_RETURN_VOID, SortSupportData::ssup_cxt, SortSupportData::ssup_extra, VARATT_SHORT_MAX, and VARHDRSZ.

numeric_sqrt()

Datum numeric_sqrt

(

PG_FUNCTION_ARGS

)

Definition at line 3653 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    Numeric     res;
    NumericVar  arg;
    NumericVar  result;
    int         sweight;
    int         rscale;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
    {
        /* error should match that in sqrt_var() */
        if (NUMERIC_IS_NINF(num))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
                     errmsg("cannot take square root of a negative number")));
        /* For NAN or PINF, just duplicate the input */
        PG_RETURN_NUMERIC(duplicate_numeric(num));
    }
 
    /*
     * Unpack the argument and determine the result scale.  We choose a scale
     * to give at least NUMERIC_MIN_SIG_DIGITS significant digits; but in any
     * case not less than the input's dscale.
     */
    init_var_from_num(num, &arg);
 
    init_var(&result);
 
    /*
     * Assume the input was normalized, so arg.weight is accurate.  The result
     * then has at least sweight = floor(arg.weight * DEC_DIGITS / 2 + 1)
     * digits before the decimal point.  When DEC_DIGITS is even, we can save
     * a few cycles, since the division is exact and there is no need to round
     * towards negative infinity.
     */
#if DEC_DIGITS == ((DEC_DIGITS / 2) * 2)
    sweight = arg.weight * DEC_DIGITS / 2 + 1;
#else
    if (arg.weight >= 0)
        sweight = arg.weight * DEC_DIGITS / 2 + 1;
    else
        sweight = 1 - (1 - arg.weight * DEC_DIGITS) / 2;
#endif
 
    rscale = NUMERIC_MIN_SIG_DIGITS - sweight;
    rscale = Max(rscale, arg.dscale);
    rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
    rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);
 
    /*
     * Let sqrt_var() do the calculation and return the result.
     */
    sqrt_var(&arg, &result, rscale);
 
    res = make_result(&result);
 
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References arg, DEC_DIGITS, duplicate_numeric(), ereport, errcode(), errmsg(), ERROR, free_var(), init_var, init_var_from_num(), make_result(), Max, Min, NUMERIC_IS_NINF, NUMERIC_IS_SPECIAL, NUMERIC_MAX_DISPLAY_SCALE, NUMERIC_MIN_DISPLAY_SCALE, NUMERIC_MIN_SIG_DIGITS, PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, and sqrt_var().

numeric_stddev_internal()

static Numeric numeric_stddev_internal ( NumericAggState *  state, bool  variance, bool  sample, bool *  is_null  )

static

Definition at line 5997 of file numeric.c.

{
    Numeric     res;
    NumericVar  vN,
                vsumX,
                vsumX2,
                vNminus1;
    int64       totCount;
    int         rscale;
 
    /*
     * Sample stddev and variance are undefined when N <= 1; population stddev
     * is undefined when N == 0.  Return NULL in either case (note that NaNs
     * and infinities count as normal inputs for this purpose).
     */
    if (state == NULL || (totCount = NA_TOTAL_COUNT(state)) == 0)
    {
        *is_null = true;
        return NULL;
    }
 
    if (sample && totCount <= 1)
    {
        *is_null = true;
        return NULL;
    }
 
    *is_null = false;
 
    /*
     * Deal with NaN and infinity cases.  By analogy to the behavior of the
     * float8 functions, any infinity input produces NaN output.
     */
    if (state->NaNcount > 0 || state->pInfcount > 0 || state->nInfcount > 0)
        return make_result(&const_nan);
 
    /* OK, normal calculation applies */
    init_var(&vN);
    init_var(&vsumX);
    init_var(&vsumX2);
 
    int64_to_numericvar(state->N, &vN);
    accum_sum_final(&(state->sumX), &vsumX);
    accum_sum_final(&(state->sumX2), &vsumX2);
 
    init_var(&vNminus1);
    sub_var(&vN, &const_one, &vNminus1);
 
    /* compute rscale for mul_var calls */
    rscale = vsumX.dscale * 2;
 
    mul_var(&vsumX, &vsumX, &vsumX, rscale);    /* vsumX = sumX * sumX */
    mul_var(&vN, &vsumX2, &vsumX2, rscale); /* vsumX2 = N * sumX2 */
    sub_var(&vsumX2, &vsumX, &vsumX2);  /* N * sumX2 - sumX * sumX */
 
    if (cmp_var(&vsumX2, &const_zero) <= 0)
    {
        /* Watch out for roundoff error producing a negative numerator */
        res = make_result(&const_zero);
    }
    else
    {
        if (sample)
            mul_var(&vN, &vNminus1, &vNminus1, 0);  /* N * (N - 1) */
        else
            mul_var(&vN, &vN, &vNminus1, 0);    /* N * N */
        rscale = select_div_scale(&vsumX2, &vNminus1);
        div_var(&vsumX2, &vNminus1, &vsumX, rscale, true, true);    /* variance */
        if (!variance)
            sqrt_var(&vsumX, &vsumX, rscale);   /* stddev */
 
        res = make_result(&vsumX);
    }
 
    free_var(&vNminus1);
    free_var(&vsumX);
    free_var(&vsumX2);
 
    return res;
}

References accum_sum_final(), cmp_var(), const_nan, const_one, const_zero, div_var(), NumericVar::dscale, free_var(), init_var, int64_to_numericvar(), make_result(), mul_var(), NA_TOTAL_COUNT, select_div_scale(), sqrt_var(), and sub_var().

Referenced by numeric_poly_stddev_internal(), numeric_stddev_pop(), numeric_stddev_samp(), numeric_var_pop(), and numeric_var_samp().

numeric_stddev_pop()

Datum numeric_stddev_pop

(

PG_FUNCTION_ARGS

)

Definition at line 6132 of file numeric.c.

{
    NumericAggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    res = numeric_stddev_internal(state, false, false, &is_null);
 
    if (is_null)
        PG_RETURN_NULL();
    else
        PG_RETURN_NUMERIC(res);
}

References numeric_stddev_internal(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numeric_stddev_samp()

Datum numeric_stddev_samp

(

PG_FUNCTION_ARGS

)

Definition at line 6098 of file numeric.c.

{
    NumericAggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    res = numeric_stddev_internal(state, false, true, &is_null);
 
    if (is_null)
        PG_RETURN_NULL();
    else
        PG_RETURN_NUMERIC(res);
}

References numeric_stddev_internal(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numeric_sub()

Datum numeric_sub

(

PG_FUNCTION_ARGS

)

Definition at line 2940 of file numeric.c.

{
    Numeric     num1 = PG_GETARG_NUMERIC(0);
    Numeric     num2 = PG_GETARG_NUMERIC(1);
    Numeric     res;
 
    res = numeric_sub_safe(num1, num2, NULL);
 
    PG_RETURN_NUMERIC(res);
}

References numeric_sub_safe(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

Referenced by brin_minmax_multi_distance_numeric(), gbt_numeric_penalty(), numeric_half_rounded(), numrange_subdiff(), and pg_lsn_mii().

numeric_sub_safe()

Numeric numeric_sub_safe	(	Numeric	num1,
		Numeric	num2,
		Node *	escontext
	)

Definition at line 2958 of file numeric.c.

{
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
    Numeric     res;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
    {
        if (NUMERIC_IS_NAN(num1) || NUMERIC_IS_NAN(num2))
            return make_result(&const_nan);
        if (NUMERIC_IS_PINF(num1))
        {
            if (NUMERIC_IS_PINF(num2))
                return make_result(&const_nan); /* Inf - Inf */
            else
                return make_result(&const_pinf);
        }
        if (NUMERIC_IS_NINF(num1))
        {
            if (NUMERIC_IS_NINF(num2))
                return make_result(&const_nan); /* -Inf - -Inf */
            else
                return make_result(&const_ninf);
        }
        /* by here, num1 must be finite, so num2 is not */
        if (NUMERIC_IS_PINF(num2))
            return make_result(&const_ninf);
        Assert(NUMERIC_IS_NINF(num2));
        return make_result(&const_pinf);
    }
 
    /*
     * Unpack the values, let sub_var() compute the result and return it.
     */
    init_var_from_num(num1, &arg1);
    init_var_from_num(num2, &arg2);
 
    init_var(&result);
    sub_var(&arg1, &arg2, &result);
 
    res = make_result_safe(&result, escontext);
 
    free_var(&result);
 
    return res;
}

References Assert(), const_nan, const_ninf, const_pinf, free_var(), init_var, init_var_from_num(), make_result(), make_result_safe(), NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, and sub_var().

Referenced by executeItemOptUnwrapTarget(), numeric_sub(), timestamp_part_common(), and timestamptz_part_common().

numeric_sum()

Datum numeric_sum

(

PG_FUNCTION_ARGS

)

Definition at line 5954 of file numeric.c.

{
    NumericAggState *state;
    NumericVar  sumX_var;
    Numeric     result;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    /* If there were no non-null inputs, return NULL */
    if (state == NULL || NA_TOTAL_COUNT(state) == 0)
        PG_RETURN_NULL();
 
    if (state->NaNcount > 0)    /* there was at least one NaN input */
        PG_RETURN_NUMERIC(make_result(&const_nan));
 
    /* adding plus and minus infinities gives NaN */
    if (state->pInfcount > 0 && state->nInfcount > 0)
        PG_RETURN_NUMERIC(make_result(&const_nan));
    if (state->pInfcount > 0)
        PG_RETURN_NUMERIC(make_result(&const_pinf));
    if (state->nInfcount > 0)
        PG_RETURN_NUMERIC(make_result(&const_ninf));
 
    init_var(&sumX_var);
    accum_sum_final(&state->sumX, &sumX_var);
    result = make_result(&sumX_var);
    free_var(&sumX_var);
 
    PG_RETURN_NUMERIC(result);
}

References accum_sum_final(), const_nan, const_ninf, const_pinf, free_var(), init_var, make_result(), NA_TOTAL_COUNT, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numeric_support()

Datum numeric_support

(

PG_FUNCTION_ARGS

)

Definition at line 1179 of file numeric.c.

{
    Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
    Node       *ret = NULL;
 
    if (IsA(rawreq, SupportRequestSimplify))
    {
        SupportRequestSimplify *req = (SupportRequestSimplify *) rawreq;
        FuncExpr   *expr = req->fcall;
        Node       *typmod;
 
        Assert(list_length(expr->args) >= 2);
 
        typmod = (Node *) lsecond(expr->args);
 
        if (IsA(typmod, Const) && !((Const *) typmod)->constisnull)
        {
            Node       *source = (Node *) linitial(expr->args);
            int32       old_typmod = exprTypmod(source);
            int32       new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);
            int32       old_scale = numeric_typmod_scale(old_typmod);
            int32       new_scale = numeric_typmod_scale(new_typmod);
            int32       old_precision = numeric_typmod_precision(old_typmod);
            int32       new_precision = numeric_typmod_precision(new_typmod);
 
            /*
             * If new_typmod is invalid, the destination is unconstrained;
             * that's always OK.  If old_typmod is valid, the source is
             * constrained, and we're OK if the scale is unchanged and the
             * precision is not decreasing.  See further notes in function
             * header comment.
             */
            if (!is_valid_numeric_typmod(new_typmod) ||
                (is_valid_numeric_typmod(old_typmod) &&
                 new_scale == old_scale && new_precision >= old_precision))
                ret = relabel_to_typmod(source, new_typmod);
        }
    }
 
    PG_RETURN_POINTER(ret);
}

References FuncExpr::args, Assert(), DatumGetInt32(), exprTypmod(), SupportRequestSimplify::fcall, is_valid_numeric_typmod(), IsA, linitial, list_length(), lsecond, numeric_typmod_precision(), numeric_typmod_scale(), PG_GETARG_POINTER, PG_RETURN_POINTER, relabel_to_typmod(), and source.

numeric_trim_scale()

Datum numeric_trim_scale

(

PG_FUNCTION_ARGS

)

Definition at line 4184 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    Numeric     res;
    NumericVar  result;
 
    if (NUMERIC_IS_SPECIAL(num))
        PG_RETURN_NUMERIC(duplicate_numeric(num));
 
    init_var_from_num(num, &result);
    result.dscale = get_min_scale(&result);
    res = make_result(&result);
    free_var(&result);
 
    PG_RETURN_NUMERIC(res);
}

References NumericVar::dscale, duplicate_numeric(), free_var(), get_min_scale(), init_var_from_num(), make_result(), NUMERIC_IS_SPECIAL, PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

numeric_trunc()

Datum numeric_trunc

(

PG_FUNCTION_ARGS

)

Definition at line 1580 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    int32       scale = PG_GETARG_INT32(1);
    Numeric     res;
    NumericVar  arg;
 
    /*
     * Handle NaN and infinities
     */
    if (NUMERIC_IS_SPECIAL(num))
        PG_RETURN_NUMERIC(duplicate_numeric(num));
 
    /*
     * Limit the scale value to avoid possible overflow in calculations.
     *
     * These limits are based on the maximum number of digits a Numeric value
     * can have before and after the decimal point.
     */
    scale = Max(scale, -(NUMERIC_WEIGHT_MAX + 1) * DEC_DIGITS);
    scale = Min(scale, NUMERIC_DSCALE_MAX);
 
    /*
     * Unpack the argument and truncate it at the proper digit position
     */
    init_var(&arg);
    set_var_from_num(num, &arg);
 
    trunc_var(&arg, scale);
 
    /* We don't allow negative output dscale */
    if (scale < 0)
        arg.dscale = 0;
 
    /*
     * Return the truncated result
     */
    res = make_result(&arg);
 
    free_var(&arg);
    PG_RETURN_NUMERIC(res);
}

References arg, DEC_DIGITS, duplicate_numeric(), free_var(), init_var, make_result(), Max, Min, NUMERIC_DSCALE_MAX, NUMERIC_IS_SPECIAL, NUMERIC_WEIGHT_MAX, PG_GETARG_INT32, PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, scale, set_var_from_num(), and trunc_var().

Referenced by getArrayIndex().

numeric_typmod_precision()

static int numeric_typmod_precision ( int32  typmod )

inlinestatic

Definition at line 910 of file numeric.c.

{
    return ((typmod - VARHDRSZ) >> 16) & 0xffff;
}

References VARHDRSZ.

Referenced by apply_typmod(), apply_typmod_special(), numeric(), numeric_maximum_size(), numeric_support(), and numerictypmodout().

numeric_typmod_scale()

static int numeric_typmod_scale ( int32  typmod )

inlinestatic

Definition at line 925 of file numeric.c.

{
    return (((typmod - VARHDRSZ) & 0x7ff) ^ 1024) - 1024;
}

References VARHDRSZ.

Referenced by apply_typmod(), apply_typmod_special(), numeric(), numeric_support(), and numerictypmodout().

numeric_uminus()

Datum numeric_uminus

(

PG_FUNCTION_ARGS

)

Definition at line 1403 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    Numeric     res;
 
    /*
     * Do it the easy way directly on the packed format
     */
    res = duplicate_numeric(num);
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        /* Flip the sign, if it's Inf or -Inf */
        if (!NUMERIC_IS_NAN(num))
            res->choice.n_short.n_header =
                num->choice.n_short.n_header ^ NUMERIC_INF_SIGN_MASK;
    }
 
    /*
     * The packed format is known to be totally zero digit trimmed always. So
     * once we've eliminated specials, we can identify a zero by the fact that
     * there are no digits at all. Do nothing to a zero.
     */
    else if (NUMERIC_NDIGITS(num) != 0)
    {
        /* Else, flip the sign */
        if (NUMERIC_IS_SHORT(num))
            res->choice.n_short.n_header =
                num->choice.n_short.n_header ^ NUMERIC_SHORT_SIGN_MASK;
        else if (NUMERIC_SIGN(num) == NUMERIC_POS)
            res->choice.n_long.n_sign_dscale =
                NUMERIC_NEG | NUMERIC_DSCALE(num);
        else
            res->choice.n_long.n_sign_dscale =
                NUMERIC_POS | NUMERIC_DSCALE(num);
    }
 
    PG_RETURN_NUMERIC(res);
}

References NumericData::choice, duplicate_numeric(), NumericShort::n_header, NumericChoice::n_long, NumericChoice::n_short, NumericLong::n_sign_dscale, NUMERIC_DSCALE, NUMERIC_INF_SIGN_MASK, NUMERIC_IS_NAN, NUMERIC_IS_SHORT, NUMERIC_IS_SPECIAL, NUMERIC_NDIGITS, NUMERIC_NEG, NUMERIC_POS, NUMERIC_SHORT_SIGN_MASK, NUMERIC_SIGN, PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

Referenced by executeItemOptUnwrapTarget().

numeric_uplus()

Datum numeric_uplus

(

PG_FUNCTION_ARGS

)

Definition at line 1445 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
 
    PG_RETURN_NUMERIC(duplicate_numeric(num));
}

References duplicate_numeric(), PG_GETARG_NUMERIC, and PG_RETURN_NUMERIC.

Referenced by jsonb_agg_transfn_worker(), and jsonb_object_agg_transfn_worker().

numeric_var_pop()

Datum numeric_var_pop

(

PG_FUNCTION_ARGS

)

Definition at line 6115 of file numeric.c.

{
    NumericAggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    res = numeric_stddev_internal(state, true, false, &is_null);
 
    if (is_null)
        PG_RETURN_NULL();
    else
        PG_RETURN_NUMERIC(res);
}

References numeric_stddev_internal(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numeric_var_samp()

Datum numeric_var_samp

(

PG_FUNCTION_ARGS

)

Definition at line 6081 of file numeric.c.

{
    NumericAggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
 
    res = numeric_stddev_internal(state, true, true, &is_null);
 
    if (is_null)
        PG_RETURN_NULL();
    else
        PG_RETURN_NUMERIC(res);
}

References numeric_stddev_internal(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, and PG_RETURN_NUMERIC.

numerictypmodin()

Datum numerictypmodin

(

PG_FUNCTION_ARGS

)

Definition at line 1307 of file numeric.c.

{
    ArrayType  *ta = PG_GETARG_ARRAYTYPE_P(0);
    int32      *tl;
    int         n;
    int32       typmod;
 
    tl = ArrayGetIntegerTypmods(ta, &n);
 
    if (n == 2)
    {
        if (tl[0] < 1 || tl[0] > NUMERIC_MAX_PRECISION)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("NUMERIC precision %d must be between 1 and %d",
                            tl[0], NUMERIC_MAX_PRECISION)));
        if (tl[1] < NUMERIC_MIN_SCALE || tl[1] > NUMERIC_MAX_SCALE)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("NUMERIC scale %d must be between %d and %d",
                            tl[1], NUMERIC_MIN_SCALE, NUMERIC_MAX_SCALE)));
        typmod = make_numeric_typmod(tl[0], tl[1]);
    }
    else if (n == 1)
    {
        if (tl[0] < 1 || tl[0] > NUMERIC_MAX_PRECISION)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("NUMERIC precision %d must be between 1 and %d",
                            tl[0], NUMERIC_MAX_PRECISION)));
        /* scale defaults to zero */
        typmod = make_numeric_typmod(tl[0], 0);
    }
    else
    {
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid NUMERIC type modifier")));
        typmod = 0;             /* keep compiler quiet */
    }
 
    PG_RETURN_INT32(typmod);
}

References ArrayGetIntegerTypmods(), ereport, errcode(), errmsg(), ERROR, make_numeric_typmod(), NUMERIC_MAX_PRECISION, NUMERIC_MAX_SCALE, NUMERIC_MIN_SCALE, PG_GETARG_ARRAYTYPE_P, and PG_RETURN_INT32.

Referenced by executeItemOptUnwrapTarget().

numerictypmodout()

Datum numerictypmodout

(

PG_FUNCTION_ARGS

)

Definition at line 1352 of file numeric.c.

{
    int32       typmod = PG_GETARG_INT32(0);
    char       *res = (char *) palloc(64);
 
    if (is_valid_numeric_typmod(typmod))
        snprintf(res, 64, "(%d,%d)",
                 numeric_typmod_precision(typmod),
                 numeric_typmod_scale(typmod));
    else
        *res = '\0';
 
    PG_RETURN_CSTRING(res);
}

References is_valid_numeric_typmod(), numeric_typmod_precision(), numeric_typmod_scale(), palloc(), PG_GETARG_INT32, PG_RETURN_CSTRING, and snprintf.

numericvar_deserialize()

static void numericvar_deserialize ( StringInfo  buf, NumericVar *  var  )

static

Definition at line 7471 of file numeric.c.

{
    int         len,
                i;
 
    len = pq_getmsgint(buf, sizeof(int32));
 
    alloc_var(var, len);        /* sets var->ndigits */
 
    var->weight = pq_getmsgint(buf, sizeof(int32));
    var->sign = pq_getmsgint(buf, sizeof(int32));
    var->dscale = pq_getmsgint(buf, sizeof(int32));
    for (i = 0; i < len; i++)
        var->digits[i] = pq_getmsgint(buf, sizeof(int16));
}

References alloc_var(), buf, NumericVar::digits, NumericVar::dscale, i, len, pq_getmsgint(), NumericVar::sign, and NumericVar::weight.

Referenced by numeric_avg_deserialize(), and numeric_deserialize().

numericvar_serialize()

static void numericvar_serialize ( StringInfo  buf, const NumericVar *  var  )

static

Definition at line 7455 of file numeric.c.

{
    int         i;
 
    pq_sendint32(buf, var->ndigits);
    pq_sendint32(buf, var->weight);
    pq_sendint32(buf, var->sign);
    pq_sendint32(buf, var->dscale);
    for (i = 0; i < var->ndigits; i++)
        pq_sendint16(buf, var->digits[i]);
}

References buf, NumericVar::digits, NumericVar::dscale, i, NumericVar::ndigits, pq_sendint16(), pq_sendint32(), NumericVar::sign, and NumericVar::weight.

Referenced by numeric_avg_serialize(), and numeric_serialize().

numericvar_to_double_no_overflow()

static double numericvar_to_double_no_overflow ( const NumericVar *  var )

static

Definition at line 7972 of file numeric.c.

{
    char       *tmp;
    double      val;
    char       *endptr;
 
    tmp = get_str_from_var(var);
 
    /* unlike float8in, we ignore ERANGE from strtod */
    val = strtod(tmp, &endptr);
    if (*endptr != '\0')
    {
        /* shouldn't happen ... */
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        "double precision", tmp)));
    }
 
    pfree(tmp);
 
    return val;
}

References ereport, errcode(), errmsg(), ERROR, get_str_from_var(), pfree(), and val.

Referenced by exp_var(), generate_series_numeric_support(), numeric_exp(), numeric_float8_no_overflow(), and power_var().

numericvar_to_int32()

static bool numericvar_to_int32 ( const NumericVar *  var, int32 *  result  )

static

Definition at line 4407 of file numeric.c.

{
    int64       val;
 
    if (!numericvar_to_int64(var, &val))
        return false;
 
    if (unlikely(val < PG_INT32_MIN) || unlikely(val > PG_INT32_MAX))
        return false;
 
    /* Down-convert to int4 */
    *result = (int32) val;
 
    return true;
}

References numericvar_to_int64(), PG_INT32_MAX, PG_INT32_MIN, unlikely, and val.

Referenced by numeric_int4_safe(), and width_bucket_numeric().

numericvar_to_int64()

static bool numericvar_to_int64 ( const NumericVar *  var, int64 *  result  )

static

Definition at line 7744 of file numeric.c.

{
    NumericDigit *digits;
    int         ndigits;
    int         weight;
    int         i;
    int64       val;
    bool        neg;
    NumericVar  rounded;
 
    /* Round to nearest integer */
    init_var(&rounded);
    set_var_from_var(var, &rounded);
    round_var(&rounded, 0);
 
    /* Check for zero input */
    strip_var(&rounded);
    ndigits = rounded.ndigits;
    if (ndigits == 0)
    {
        *result = 0;
        free_var(&rounded);
        return true;
    }
 
    /*
     * For input like 10000000000, we must treat stripped digits as real. So
     * the loop assumes there are weight+1 digits before the decimal point.
     */
    weight = rounded.weight;
    Assert(weight >= 0 && ndigits <= weight + 1);
 
    /*
     * Construct the result. To avoid issues with converting a value
     * corresponding to INT64_MIN (which can't be represented as a positive 64
     * bit two's complement integer), accumulate value as a negative number.
     */
    digits = rounded.digits;
    neg = (rounded.sign == NUMERIC_NEG);
    val = -digits[0];
    for (i = 1; i <= weight; i++)
    {
        if (unlikely(pg_mul_s64_overflow(val, NBASE, &val)))
        {
            free_var(&rounded);
            return false;
        }
 
        if (i < ndigits)
        {
            if (unlikely(pg_sub_s64_overflow(val, digits[i], &val)))
            {
                free_var(&rounded);
                return false;
            }
        }
    }
 
    free_var(&rounded);
 
    if (!neg)
    {
        if (unlikely(val == PG_INT64_MIN))
            return false;
        val = -val;
    }
    *result = val;
 
    return true;
}

References Assert(), NumericVar::digits, digits, free_var(), i, init_var, NBASE, NumericVar::ndigits, NUMERIC_NEG, PG_INT64_MIN, pg_mul_s64_overflow(), pg_sub_s64_overflow(), round_var(), set_var_from_var(), NumericVar::sign, strip_var(), unlikely, val, and NumericVar::weight.

Referenced by numeric_int2(), numeric_int8_safe(), numericvar_to_int32(), and power_var().

numericvar_to_uint64()

static bool numericvar_to_uint64 ( const NumericVar *  var, uint64 *  result  )

static

Definition at line 7866 of file numeric.c.

{
    NumericDigit *digits;
    int         ndigits;
    int         weight;
    int         i;
    uint64      val;
    NumericVar  rounded;
 
    /* Round to nearest integer */
    init_var(&rounded);
    set_var_from_var(var, &rounded);
    round_var(&rounded, 0);
 
    /* Check for zero input */
    strip_var(&rounded);
    ndigits = rounded.ndigits;
    if (ndigits == 0)
    {
        *result = 0;
        free_var(&rounded);
        return true;
    }
 
    /* Check for negative input */
    if (rounded.sign == NUMERIC_NEG)
    {
        free_var(&rounded);
        return false;
    }
 
    /*
     * For input like 10000000000, we must treat stripped digits as real. So
     * the loop assumes there are weight+1 digits before the decimal point.
     */
    weight = rounded.weight;
    Assert(weight >= 0 && ndigits <= weight + 1);
 
    /* Construct the result */
    digits = rounded.digits;
    val = digits[0];
    for (i = 1; i <= weight; i++)
    {
        if (unlikely(pg_mul_u64_overflow(val, NBASE, &val)))
        {
            free_var(&rounded);
            return false;
        }
 
        if (i < ndigits)
        {
            if (unlikely(pg_add_u64_overflow(val, digits[i], &val)))
            {
                free_var(&rounded);
                return false;
            }
        }
    }
 
    free_var(&rounded);
 
    *result = val;
 
    return true;
}

References Assert(), NumericVar::digits, digits, free_var(), i, init_var, NBASE, NumericVar::ndigits, NUMERIC_NEG, pg_add_u64_overflow(), pg_mul_u64_overflow(), round_var(), set_var_from_var(), NumericVar::sign, strip_var(), unlikely, val, and NumericVar::weight.

Referenced by numeric_pg_lsn().

power_ten_int()

static void power_ten_int ( int  exp, NumericVar *  result  )

static

Definition at line 11168 of file numeric.c.

{
    /* Construct the result directly, starting from 10^0 = 1 */
    set_var_from_var(&const_one, result);
 
    /* Scale needed to represent the result exactly */
    result->dscale = exp < 0 ? -exp : 0;
 
    /* Base-NBASE weight of result and remaining exponent */
    if (exp >= 0)
        result->weight = exp / DEC_DIGITS;
    else
        result->weight = (exp + 1) / DEC_DIGITS - 1;
 
    exp -= result->weight * DEC_DIGITS;
 
    /* Final adjustment of the result's single NBASE digit */
    while (exp-- > 0)
        result->digits[0] *= 10;
}

References const_one, DEC_DIGITS, NumericVar::digits, NumericVar::dscale, set_var_from_var(), and NumericVar::weight.

Referenced by get_str_from_var_sci().

power_var()

static void power_var ( const NumericVar *  base, const NumericVar *  exp, NumericVar *  result  )

static

Definition at line 10801 of file numeric.c.

{
    int         res_sign;
    NumericVar  abs_base;
    NumericVar  ln_base;
    NumericVar  ln_num;
    int         ln_dweight;
    int         rscale;
    int         sig_digits;
    int         local_rscale;
    double      val;
 
    /* If exp can be represented as an integer, use power_var_int */
    if (exp->ndigits == 0 || exp->ndigits <= exp->weight + 1)
    {
        /* exact integer, but does it fit in int? */
        int64       expval64;
 
        if (numericvar_to_int64(exp, &expval64))
        {
            if (expval64 >= PG_INT32_MIN && expval64 <= PG_INT32_MAX)
            {
                /* Okay, use power_var_int */
                power_var_int(base, (int) expval64, exp->dscale, result);
                return;
            }
        }
    }
 
    /*
     * This avoids log(0) for cases of 0 raised to a non-integer.  0 ^ 0 is
     * handled by power_var_int().
     */
    if (cmp_var(base, &const_zero) == 0)
    {
        set_var_from_var(&const_zero, result);
        result->dscale = NUMERIC_MIN_SIG_DIGITS;    /* no need to round */
        return;
    }
 
    init_var(&abs_base);
    init_var(&ln_base);
    init_var(&ln_num);
 
    /*
     * If base is negative, insist that exp be an integer.  The result is then
     * positive if exp is even and negative if exp is odd.
     */
    if (base->sign == NUMERIC_NEG)
    {
        /*
         * Check that exp is an integer.  This error code is defined by the
         * SQL standard, and matches other errors in numeric_power().
         */
        if (exp->ndigits > 0 && exp->ndigits > exp->weight + 1)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
                     errmsg("a negative number raised to a non-integer power yields a complex result")));
 
        /* Test if exp is odd or even */
        if (exp->ndigits > 0 && exp->ndigits == exp->weight + 1 &&
            (exp->digits[exp->ndigits - 1] & 1))
            res_sign = NUMERIC_NEG;
        else
            res_sign = NUMERIC_POS;
 
        /* Then work with abs(base) below */
        set_var_from_var(base, &abs_base);
        abs_base.sign = NUMERIC_POS;
        base = &abs_base;
    }
    else
        res_sign = NUMERIC_POS;
 
    /*----------
     * Decide on the scale for the ln() calculation.  For this we need an
     * estimate of the weight of the result, which we obtain by doing an
     * initial low-precision calculation of exp * ln(base).
     *
     * We want result = e ^ (exp * ln(base))
     * so result dweight = log10(result) = exp * ln(base) * log10(e)
     *
     * We also perform a crude overflow test here so that we can exit early if
     * the full-precision result is sure to overflow, and to guard against
     * integer overflow when determining the scale for the real calculation.
     * exp_var() supports inputs up to NUMERIC_MAX_RESULT_SCALE * 3, so the
     * result will overflow if exp * ln(base) >= NUMERIC_MAX_RESULT_SCALE * 3.
     * Since the values here are only approximations, we apply a small fuzz
     * factor to this overflow test and let exp_var() determine the exact
     * overflow threshold so that it is consistent for all inputs.
     *----------
     */
    ln_dweight = estimate_ln_dweight(base);
 
    /*
     * Set the scale for the low-precision calculation, computing ln(base) to
     * around 8 significant digits.  Note that ln_dweight may be as small as
     * -NUMERIC_DSCALE_MAX, so the scale may exceed NUMERIC_MAX_DISPLAY_SCALE
     * here.
     */
    local_rscale = 8 - ln_dweight;
    local_rscale = Max(local_rscale, NUMERIC_MIN_DISPLAY_SCALE);
 
    ln_var(base, &ln_base, local_rscale);
 
    mul_var(&ln_base, exp, &ln_num, local_rscale);
 
    val = numericvar_to_double_no_overflow(&ln_num);
 
    /* initial overflow/underflow test with fuzz factor */
    if (fabs(val) > NUMERIC_MAX_RESULT_SCALE * 3.01)
    {
        if (val > 0)
            ereport(ERROR,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("value overflows numeric format")));
        zero_var(result);
        result->dscale = NUMERIC_MAX_DISPLAY_SCALE;
        return;
    }
 
    val *= 0.434294481903252;   /* approximate decimal result weight */
 
    /* choose the result scale */
    rscale = NUMERIC_MIN_SIG_DIGITS - (int) val;
    rscale = Max(rscale, base->dscale);
    rscale = Max(rscale, exp->dscale);
    rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
    rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);
 
    /* significant digits required in the result */
    sig_digits = rscale + (int) val;
    sig_digits = Max(sig_digits, 0);
 
    /* set the scale for the real exp * ln(base) calculation */
    local_rscale = sig_digits - ln_dweight + 8;
    local_rscale = Max(local_rscale, NUMERIC_MIN_DISPLAY_SCALE);
 
    /* and do the real calculation */
 
    ln_var(base, &ln_base, local_rscale);
 
    mul_var(&ln_base, exp, &ln_num, local_rscale);
 
    exp_var(&ln_num, result, rscale);
 
    if (res_sign == NUMERIC_NEG && result->ndigits > 0)
        result->sign = NUMERIC_NEG;
 
    free_var(&ln_num);
    free_var(&ln_base);
    free_var(&abs_base);
}

References cmp_var(), const_zero, NumericVar::digits, NumericVar::dscale, ereport, errcode(), errmsg(), ERROR, estimate_ln_dweight(), exp_var(), free_var(), init_var, ln_var(), Max, Min, mul_var(), NumericVar::ndigits, NUMERIC_MAX_DISPLAY_SCALE, NUMERIC_MAX_RESULT_SCALE, NUMERIC_MIN_DISPLAY_SCALE, NUMERIC_MIN_SIG_DIGITS, NUMERIC_NEG, NUMERIC_POS, numericvar_to_double_no_overflow(), numericvar_to_int64(), PG_INT32_MAX, PG_INT32_MIN, power_var_int(), set_var_from_var(), NumericVar::sign, val, NumericVar::weight, and zero_var().

Referenced by numeric_power().

power_var_int()

static void power_var_int ( const NumericVar *  base, int  exp, int  exp_dscale, NumericVar *  result  )

static

Definition at line 10963 of file numeric.c.

{
    double      f;
    int         p;
    int         i;
    int         rscale;
    int         sig_digits;
    unsigned int mask;
    bool        neg;
    NumericVar  base_prod;
    int         local_rscale;
 
    /*
     * Choose the result scale.  For this we need an estimate of the decimal
     * weight of the result, which we obtain by approximating using double
     * precision arithmetic.
     *
     * We also perform crude overflow/underflow tests here so that we can exit
     * early if the result is sure to overflow/underflow, and to guard against
     * integer overflow when choosing the result scale.
     */
    if (base->ndigits != 0)
    {
        /*----------
         * Choose f (double) and p (int) such that base ~= f * 10^p.
         * Then log10(result) = log10(base^exp) ~= exp * (log10(f) + p).
         *----------
         */
        f = base->digits[0];
        p = base->weight * DEC_DIGITS;
 
        for (i = 1; i < base->ndigits && i * DEC_DIGITS < 16; i++)
        {
            f = f * NBASE + base->digits[i];
            p -= DEC_DIGITS;
        }
 
        f = exp * (log10(f) + p);   /* approximate decimal result weight */
    }
    else
        f = 0;                  /* result is 0 or 1 (weight 0), or error */
 
    /* overflow/underflow tests with fuzz factors */
    if (f > (NUMERIC_WEIGHT_MAX + 1) * DEC_DIGITS)
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value overflows numeric format")));
    if (f + 1 < -NUMERIC_MAX_DISPLAY_SCALE)
    {
        zero_var(result);
        result->dscale = NUMERIC_MAX_DISPLAY_SCALE;
        return;
    }
 
    /*
     * Choose the result scale in the same way as power_var(), so it has at
     * least NUMERIC_MIN_SIG_DIGITS significant digits and is not less than
     * either input's display scale.
     */
    rscale = NUMERIC_MIN_SIG_DIGITS - (int) f;
    rscale = Max(rscale, base->dscale);
    rscale = Max(rscale, exp_dscale);
    rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
    rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);
 
    /* Handle some common special cases, as well as corner cases */
    switch (exp)
    {
        case 0:
 
            /*
             * While 0 ^ 0 can be either 1 or indeterminate (error), we treat
             * it as 1 because most programming languages do this. SQL:2003
             * also requires a return value of 1.
             * https://en.wikipedia.org/wiki/Exponentiation#Zero_to_the_zero_power
             */
            set_var_from_var(&const_one, result);
            result->dscale = rscale;    /* no need to round */
            return;
        case 1:
            set_var_from_var(base, result);
            round_var(result, rscale);
            return;
        case -1:
            div_var(&const_one, base, result, rscale, true, true);
            return;
        case 2:
            mul_var(base, base, result, rscale);
            return;
        default:
            break;
    }
 
    /* Handle the special case where the base is zero */
    if (base->ndigits == 0)
    {
        if (exp < 0)
            ereport(ERROR,
                    (errcode(ERRCODE_DIVISION_BY_ZERO),
                     errmsg("division by zero")));
        zero_var(result);
        result->dscale = rscale;
        return;
    }
 
    /*
     * The general case repeatedly multiplies base according to the bit
     * pattern of exp.
     *
     * The local rscale used for each multiplication is varied to keep a fixed
     * number of significant digits, sufficient to give the required result
     * scale.
     */
 
    /*
     * Approximate number of significant digits in the result.  Note that the
     * underflow test above, together with the choice of rscale, ensures that
     * this approximation is necessarily > 0.
     */
    sig_digits = 1 + rscale + (int) f;
 
    /*
     * The multiplications to produce the result may introduce an error of up
     * to around log10(abs(exp)) digits, so work with this many extra digits
     * of precision (plus a few more for good measure).
     */
    sig_digits += (int) log(fabs((double) exp)) + 8;
 
    /*
     * Now we can proceed with the multiplications.
     */
    neg = (exp < 0);
    mask = pg_abs_s32(exp);
 
    init_var(&base_prod);
    set_var_from_var(base, &base_prod);
 
    if (mask & 1)
        set_var_from_var(base, result);
    else
        set_var_from_var(&const_one, result);
 
    while ((mask >>= 1) > 0)
    {
        /*
         * Do the multiplications using rscales large enough to hold the
         * results to the required number of significant digits, but don't
         * waste time by exceeding the scales of the numbers themselves.
         */
        local_rscale = sig_digits - 2 * base_prod.weight * DEC_DIGITS;
        local_rscale = Min(local_rscale, 2 * base_prod.dscale);
        local_rscale = Max(local_rscale, NUMERIC_MIN_DISPLAY_SCALE);
 
        mul_var(&base_prod, &base_prod, &base_prod, local_rscale);
 
        if (mask & 1)
        {
            local_rscale = sig_digits -
                (base_prod.weight + result->weight) * DEC_DIGITS;
            local_rscale = Min(local_rscale,
                               base_prod.dscale + result->dscale);
            local_rscale = Max(local_rscale, NUMERIC_MIN_DISPLAY_SCALE);
 
            mul_var(&base_prod, result, result, local_rscale);
        }
 
        /*
         * When abs(base) > 1, the number of digits to the left of the decimal
         * point in base_prod doubles at each iteration, so if exp is large we
         * could easily spend large amounts of time and memory space doing the
         * multiplications.  But once the weight exceeds what will fit in
         * int16, the final result is guaranteed to overflow (or underflow, if
         * exp < 0), so we can give up before wasting too many cycles.
         */
        if (base_prod.weight > NUMERIC_WEIGHT_MAX ||
            result->weight > NUMERIC_WEIGHT_MAX)
        {
            /* overflow, unless neg, in which case result should be 0 */
            if (!neg)
                ereport(ERROR,
                        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                         errmsg("value overflows numeric format")));
            zero_var(result);
            neg = false;
            break;
        }
    }
 
    free_var(&base_prod);
 
    /* Compensate for input sign, and round to requested rscale */
    if (neg)
        div_var(&const_one, result, result, rscale, true, false);
    else
        round_var(result, rscale);
}

References const_one, DEC_DIGITS, NumericVar::digits, div_var(), NumericVar::dscale, ereport, errcode(), errmsg(), ERROR, free_var(), i, init_var, Max, Min, mul_var(), NBASE, NumericVar::ndigits, NUMERIC_MAX_DISPLAY_SCALE, NUMERIC_MIN_DISPLAY_SCALE, NUMERIC_MIN_SIG_DIGITS, NUMERIC_WEIGHT_MAX, pg_abs_s32(), round_var(), set_var_from_var(), NumericVar::weight, and zero_var().

Referenced by power_var().

random_numeric()

Numeric random_numeric	(	pg_prng_state *	state,
		Numeric	rmin,
		Numeric	rmax
	)

Definition at line 4205 of file numeric.c.

{
    NumericVar  rmin_var;
    NumericVar  rmax_var;
    NumericVar  result;
    Numeric     res;
 
    /* Range bounds must not be NaN/infinity */
    if (NUMERIC_IS_SPECIAL(rmin))
    {
        if (NUMERIC_IS_NAN(rmin))
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                    errmsg("lower bound cannot be NaN"));
        else
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                    errmsg("lower bound cannot be infinity"));
    }
    if (NUMERIC_IS_SPECIAL(rmax))
    {
        if (NUMERIC_IS_NAN(rmax))
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                    errmsg("upper bound cannot be NaN"));
        else
            ereport(ERROR,
                    errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                    errmsg("upper bound cannot be infinity"));
    }
 
    /* Return a random value in the range [rmin, rmax] */
    init_var_from_num(rmin, &rmin_var);
    init_var_from_num(rmax, &rmax_var);
 
    init_var(&result);
 
    random_var(state, &rmin_var, &rmax_var, &result);
 
    res = make_result(&result);
 
    free_var(&result);
 
    return res;
}

References ereport, errcode(), errmsg(), ERROR, free_var(), init_var, init_var_from_num(), make_result(), NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, and random_var().

Referenced by numeric_random().

random_var()

static void random_var ( pg_prng_state *  state, const NumericVar *  rmin, const NumericVar *  rmax, NumericVar *  result  )

static

Definition at line 11193 of file numeric.c.

{
    int         rscale;
    NumericVar  rlen;
    int         res_ndigits;
    int         n;
    int         pow10;
    int         i;
    uint64      rlen64;
    int         rlen64_ndigits;
 
    rscale = Max(rmin->dscale, rmax->dscale);
 
    /* Compute rlen = rmax - rmin and check the range bounds */
    init_var(&rlen);
    sub_var(rmax, rmin, &rlen);
 
    if (rlen.sign == NUMERIC_NEG)
        ereport(ERROR,
                errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                errmsg("lower bound must be less than or equal to upper bound"));
 
    /* Special case for an empty range */
    if (rlen.ndigits == 0)
    {
        set_var_from_var(rmin, result);
        result->dscale = rscale;
        free_var(&rlen);
        return;
    }
 
    /*
     * Otherwise, select a random value in the range [0, rlen = rmax - rmin],
     * and shift it to the required range by adding rmin.
     */
 
    /* Required result digits */
    res_ndigits = rlen.weight + 1 + (rscale + DEC_DIGITS - 1) / DEC_DIGITS;
 
    /*
     * To get the required rscale, the final result digit must be a multiple
     * of pow10 = 10^n, where n = (-rscale) mod DEC_DIGITS.
     */
    n = ((rscale + DEC_DIGITS - 1) / DEC_DIGITS) * DEC_DIGITS - rscale;
    pow10 = 1;
    for (i = 0; i < n; i++)
        pow10 *= 10;
 
    /*
     * To choose a random value uniformly from the range [0, rlen], we choose
     * from the slightly larger range [0, rlen2], where rlen2 is formed from
     * rlen by copying the first 4 NBASE digits, and setting all remaining
     * decimal digits to "9".
     *
     * Without loss of generality, we can ignore the weight of rlen2 and treat
     * it as a pure integer for the purposes of this discussion.  The process
     * above gives rlen2 + 1 = rlen64 * 10^N, for some integer N, where rlen64
     * is a 64-bit integer formed from the first 4 NBASE digits copied from
     * rlen.  Since this trivially factors into smaller pieces that fit in
     * 64-bit integers, the task of choosing a random value uniformly from the
     * rlen2 + 1 possible values in [0, rlen2] is much simpler.
     *
     * If the random value selected is too large, it is rejected, and we try
     * again until we get a result <= rlen, ensuring that the overall result
     * is uniform (no particular value is any more likely than any other).
     *
     * Since rlen64 holds 4 NBASE digits from rlen, it contains at least
     * DEC_DIGITS * 3 + 1 decimal digits (i.e., at least 13 decimal digits,
     * when DEC_DIGITS is 4). Therefore the probability of needing to reject
     * the value chosen and retry is less than 1e-13.
     */
    rlen64 = (uint64) rlen.digits[0];
    rlen64_ndigits = 1;
    while (rlen64_ndigits < res_ndigits && rlen64_ndigits < 4)
    {
        rlen64 *= NBASE;
        if (rlen64_ndigits < rlen.ndigits)
            rlen64 += rlen.digits[rlen64_ndigits];
        rlen64_ndigits++;
    }
 
    /* Loop until we get a result <= rlen */
    do
    {
        NumericDigit *res_digits;
        uint64      rand;
        int         whole_ndigits;
 
        alloc_var(result, res_ndigits);
        result->sign = NUMERIC_POS;
        result->weight = rlen.weight;
        result->dscale = rscale;
        res_digits = result->digits;
 
        /*
         * Set the first rlen64_ndigits using a random value in [0, rlen64].
         *
         * If this is the whole result, and rscale is not a multiple of
         * DEC_DIGITS (pow10 from above is not 1), then we need this to be a
         * multiple of pow10.
         */
        if (rlen64_ndigits == res_ndigits && pow10 != 1)
            rand = pg_prng_uint64_range(state, 0, rlen64 / pow10) * pow10;
        else
            rand = pg_prng_uint64_range(state, 0, rlen64);
 
        for (i = rlen64_ndigits - 1; i >= 0; i--)
        {
            res_digits[i] = (NumericDigit) (rand % NBASE);
            rand = rand / NBASE;
        }
 
        /*
         * Set the remaining digits to random values in range [0, NBASE),
         * noting that the last digit needs to be a multiple of pow10.
         */
        whole_ndigits = res_ndigits;
        if (pow10 != 1)
            whole_ndigits--;
 
        /* Set whole digits in groups of 4 for best performance */
        i = rlen64_ndigits;
        while (i < whole_ndigits - 3)
        {
            rand = pg_prng_uint64_range(state, 0,
                                        (uint64) NBASE * NBASE * NBASE * NBASE - 1);
            res_digits[i++] = (NumericDigit) (rand % NBASE);
            rand = rand / NBASE;
            res_digits[i++] = (NumericDigit) (rand % NBASE);
            rand = rand / NBASE;
            res_digits[i++] = (NumericDigit) (rand % NBASE);
            rand = rand / NBASE;
            res_digits[i++] = (NumericDigit) rand;
        }
 
        /* Remaining whole digits */
        while (i < whole_ndigits)
        {
            rand = pg_prng_uint64_range(state, 0, NBASE - 1);
            res_digits[i++] = (NumericDigit) rand;
        }
 
        /* Final partial digit (multiple of pow10) */
        if (i < res_ndigits)
        {
            rand = pg_prng_uint64_range(state, 0, NBASE / pow10 - 1) * pow10;
            res_digits[i] = (NumericDigit) rand;
        }
 
        /* Remove leading/trailing zeroes */
        strip_var(result);
 
        /* If result > rlen, try again */
 
    } while (cmp_var(result, &rlen) > 0);
 
    /* Offset the result to the required range */
    add_var(result, rmin, result);
 
    free_var(&rlen);
}

References add_var(), alloc_var(), cmp_var(), DEC_DIGITS, NumericVar::digits, NumericVar::dscale, ereport, errcode(), errmsg(), ERROR, free_var(), i, init_var, Max, NBASE, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, pg_prng_uint64_range(), set_var_from_var(), NumericVar::sign, strip_var(), sub_var(), NumericVar::weight, and while().

Referenced by random_numeric().

round_var()

static void round_var ( NumericVar *  var, int  rscale  )

static

Definition at line 11621 of file numeric.c.

{
    NumericDigit *digits = var->digits;
    int         di;
    int         ndigits;
    int         carry;
 
    var->dscale = rscale;
 
    /* decimal digits wanted */
    di = (var->weight + 1) * DEC_DIGITS + rscale;
 
    /*
     * If di = 0, the value loses all digits, but could round up to 1 if its
     * first extra digit is >= 5.  If di < 0 the result must be 0.
     */
    if (di < 0)
    {
        var->ndigits = 0;
        var->weight = 0;
        var->sign = NUMERIC_POS;
    }
    else
    {
        /* NBASE digits wanted */
        ndigits = (di + DEC_DIGITS - 1) / DEC_DIGITS;
 
        /* 0, or number of decimal digits to keep in last NBASE digit */
        di %= DEC_DIGITS;
 
        if (ndigits < var->ndigits ||
            (ndigits == var->ndigits && di > 0))
        {
            var->ndigits = ndigits;
 
#if DEC_DIGITS == 1
            /* di must be zero */
            carry = (digits[ndigits] >= HALF_NBASE) ? 1 : 0;
#else
            if (di == 0)
                carry = (digits[ndigits] >= HALF_NBASE) ? 1 : 0;
            else
            {
                /* Must round within last NBASE digit */
                int         extra,
                            pow10;
 
#if DEC_DIGITS == 4
                pow10 = round_powers[di];
#elif DEC_DIGITS == 2
                pow10 = 10;
#else
#error unsupported NBASE
#endif
                extra = digits[--ndigits] % pow10;
                digits[ndigits] -= extra;
                carry = 0;
                if (extra >= pow10 / 2)
                {
                    pow10 += digits[ndigits];
                    if (pow10 >= NBASE)
                    {
                        pow10 -= NBASE;
                        carry = 1;
                    }
                    digits[ndigits] = pow10;
                }
            }
#endif
 
            /* Propagate carry if needed */
            while (carry)
            {
                carry += digits[--ndigits];
                if (carry >= NBASE)
                {
                    digits[ndigits] = carry - NBASE;
                    carry = 1;
                }
                else
                {
                    digits[ndigits] = carry;
                    carry = 0;
                }
            }
 
            if (ndigits < 0)
            {
                Assert(ndigits == -1);  /* better not have added > 1 digit */
                Assert(var->digits > var->buf);
                var->digits--;
                var->ndigits++;
                var->weight++;
            }
        }
    }
}

References Assert(), NumericVar::buf, DEC_DIGITS, NumericVar::digits, digits, NumericVar::dscale, HALF_NBASE, NBASE, NumericVar::ndigits, NUMERIC_POS, round_powers, NumericVar::sign, and NumericVar::weight.

Referenced by apply_typmod(), div_var(), div_var_int(), exp_var(), mul_var(), numeric_mul_safe(), numeric_round(), numericvar_to_int64(), numericvar_to_uint64(), power_var_int(), and sqrt_var().

select_div_scale()

static int select_div_scale ( const NumericVar *  var1, const NumericVar *  var2  )

static

Definition at line 9647 of file numeric.c.

{
    int         weight1,
                weight2,
                qweight,
                i;
    NumericDigit firstdigit1,
                firstdigit2;
    int         rscale;
 
    /*
     * The result scale of a division isn't specified in any SQL standard. For
     * PostgreSQL we select a result scale that will give at least
     * NUMERIC_MIN_SIG_DIGITS significant digits, so that numeric gives a
     * result no less accurate than float8; but use a scale not less than
     * either input's display scale.
     */
 
    /* Get the actual (normalized) weight and first digit of each input */
 
    weight1 = 0;                /* values to use if var1 is zero */
    firstdigit1 = 0;
    for (i = 0; i < var1->ndigits; i++)
    {
        firstdigit1 = var1->digits[i];
        if (firstdigit1 != 0)
        {
            weight1 = var1->weight - i;
            break;
        }
    }
 
    weight2 = 0;                /* values to use if var2 is zero */
    firstdigit2 = 0;
    for (i = 0; i < var2->ndigits; i++)
    {
        firstdigit2 = var2->digits[i];
        if (firstdigit2 != 0)
        {
            weight2 = var2->weight - i;
            break;
        }
    }
 
    /*
     * Estimate weight of quotient.  If the two first digits are equal, we
     * can't be sure, but assume that var1 is less than var2.
     */
    qweight = weight1 - weight2;
    if (firstdigit1 <= firstdigit2)
        qweight--;
 
    /* Select result scale */
    rscale = NUMERIC_MIN_SIG_DIGITS - qweight * DEC_DIGITS;
    rscale = Max(rscale, var1->dscale);
    rscale = Max(rscale, var2->dscale);
    rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
    rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);
 
    return rscale;
}

References DEC_DIGITS, NumericVar::digits, NumericVar::dscale, i, Max, Min, NumericVar::ndigits, NUMERIC_MAX_DISPLAY_SCALE, NUMERIC_MIN_DISPLAY_SCALE, NUMERIC_MIN_SIG_DIGITS, and NumericVar::weight.

Referenced by numeric_div_safe(), and numeric_stddev_internal().

set_var_from_non_decimal_integer_str()

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  )

static

Definition at line 6973 of file numeric.c.

{
    const char *firstdigit = cp;
    int64       tmp;
    int64       mul;
    NumericVar  tmp_var;
 
    init_var(&tmp_var);
 
    zero_var(dest);
 
    /*
     * Process input digits in groups that fit in int64.  Here "tmp" is the
     * value of the digits in the group, and "mul" is base^n, where n is the
     * number of digits in the group.  Thus tmp < mul, and we must start a new
     * group when mul * base threatens to overflow PG_INT64_MAX.
     */
    tmp = 0;
    mul = 1;
 
    if (base == 16)
    {
        while (*cp)
        {
            if (isxdigit((unsigned char) *cp))
            {
                if (mul > PG_INT64_MAX / 16)
                {
                    /* Add the contribution from this group of digits */
                    int64_to_numericvar(mul, &tmp_var);
                    mul_var(dest, &tmp_var, dest, 0);
                    int64_to_numericvar(tmp, &tmp_var);
                    add_var(dest, &tmp_var, dest);
 
                    /* Result will overflow if weight overflows int16 */
                    if (dest->weight > NUMERIC_WEIGHT_MAX)
                        goto out_of_range;
 
                    /* Begin a new group */
                    tmp = 0;
                    mul = 1;
                }
 
                tmp = tmp * 16 + xdigit_value(*cp++);
                mul = mul * 16;
            }
            else if (*cp == '_')
            {
                /* Underscore must be followed by more digits */
                cp++;
                if (!isxdigit((unsigned char) *cp))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (base == 8)
    {
        while (*cp)
        {
            if (*cp >= '0' && *cp <= '7')
            {
                if (mul > PG_INT64_MAX / 8)
                {
                    /* Add the contribution from this group of digits */
                    int64_to_numericvar(mul, &tmp_var);
                    mul_var(dest, &tmp_var, dest, 0);
                    int64_to_numericvar(tmp, &tmp_var);
                    add_var(dest, &tmp_var, dest);
 
                    /* Result will overflow if weight overflows int16 */
                    if (dest->weight > NUMERIC_WEIGHT_MAX)
                        goto out_of_range;
 
                    /* Begin a new group */
                    tmp = 0;
                    mul = 1;
                }
 
                tmp = tmp * 8 + (*cp++ - '0');
                mul = mul * 8;
            }
            else if (*cp == '_')
            {
                /* Underscore must be followed by more digits */
                cp++;
                if (*cp < '0' || *cp > '7')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (base == 2)
    {
        while (*cp)
        {
            if (*cp >= '0' && *cp <= '1')
            {
                if (mul > PG_INT64_MAX / 2)
                {
                    /* Add the contribution from this group of digits */
                    int64_to_numericvar(mul, &tmp_var);
                    mul_var(dest, &tmp_var, dest, 0);
                    int64_to_numericvar(tmp, &tmp_var);
                    add_var(dest, &tmp_var, dest);
 
                    /* Result will overflow if weight overflows int16 */
                    if (dest->weight > NUMERIC_WEIGHT_MAX)
                        goto out_of_range;
 
                    /* Begin a new group */
                    tmp = 0;
                    mul = 1;
                }
 
                tmp = tmp * 2 + (*cp++ - '0');
                mul = mul * 2;
            }
            else if (*cp == '_')
            {
                /* Underscore must be followed by more digits */
                cp++;
                if (*cp < '0' || *cp > '1')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else
        /* Should never happen; treat as invalid input */
        goto invalid_syntax;
 
    /* Check that we got at least one digit */
    if (unlikely(cp == firstdigit))
        goto invalid_syntax;
 
    /* Add the contribution from the final group of digits */
    int64_to_numericvar(mul, &tmp_var);
    mul_var(dest, &tmp_var, dest, 0);
    int64_to_numericvar(tmp, &tmp_var);
    add_var(dest, &tmp_var, dest);
 
    if (dest->weight > NUMERIC_WEIGHT_MAX)
        goto out_of_range;
 
    dest->sign = sign;
 
    free_var(&tmp_var);
 
    /* Return end+1 position for caller */
    *endptr = cp;
 
    return true;
 
out_of_range:
    ereturn(escontext, false,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value overflows numeric format")));
 
invalid_syntax:
    ereturn(escontext, false,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "numeric", str)));
}

References add_var(), generate_unaccent_rules::dest, ereturn, errcode(), errmsg(), free_var(), init_var, int64_to_numericvar(), mul_var(), NUMERIC_WEIGHT_MAX, PG_INT64_MAX, sign, str, unlikely, xdigit_value(), and zero_var().

Referenced by numeric_in().

set_var_from_num()

static void set_var_from_num ( Numeric  num, NumericVar *  dest  )

static

Definition at line 7151 of file numeric.c.

{
    int         ndigits;
 
    ndigits = NUMERIC_NDIGITS(num);
 
    alloc_var(dest, ndigits);
 
    dest->weight = NUMERIC_WEIGHT(num);
    dest->sign = NUMERIC_SIGN(num);
    dest->dscale = NUMERIC_DSCALE(num);
 
    memcpy(dest->digits, NUMERIC_DIGITS(num), ndigits * sizeof(NumericDigit));
}

References alloc_var(), generate_unaccent_rules::dest, NUMERIC_DIGITS, NUMERIC_DSCALE, NUMERIC_NDIGITS, NUMERIC_SIGN, and NUMERIC_WEIGHT.

Referenced by generate_series_step_numeric(), numeric(), numeric_round(), and numeric_trunc().

set_var_from_str()

static bool set_var_from_str ( const char *  str, const char *  cp, NumericVar *  dest, const char **  endptr, Node *  escontext  )

static

Definition at line 6743 of file numeric.c.

{
    bool        have_dp = false;
    int         i;
    unsigned char *decdigits;
    int         sign = NUMERIC_POS;
    int         dweight = -1;
    int         ddigits;
    int         dscale = 0;
    int         weight;
    int         ndigits;
    int         offset;
    NumericDigit *digits;
 
    /*
     * We first parse the string to extract decimal digits and determine the
     * correct decimal weight.  Then convert to NBASE representation.
     */
    switch (*cp)
    {
        case '+':
            sign = NUMERIC_POS;
            cp++;
            break;
 
        case '-':
            sign = NUMERIC_NEG;
            cp++;
            break;
    }
 
    if (*cp == '.')
    {
        have_dp = true;
        cp++;
    }
 
    if (!isdigit((unsigned char) *cp))
        goto invalid_syntax;
 
    decdigits = (unsigned char *) palloc(strlen(cp) + DEC_DIGITS * 2);
 
    /* leading padding for digit alignment later */
    memset(decdigits, 0, DEC_DIGITS);
    i = DEC_DIGITS;
 
    while (*cp)
    {
        if (isdigit((unsigned char) *cp))
        {
            decdigits[i++] = *cp++ - '0';
            if (!have_dp)
                dweight++;
            else
                dscale++;
        }
        else if (*cp == '.')
        {
            if (have_dp)
                goto invalid_syntax;
            have_dp = true;
            cp++;
            /* decimal point must not be followed by underscore */
            if (*cp == '_')
                goto invalid_syntax;
        }
        else if (*cp == '_')
        {
            /* underscore must be followed by more digits */
            cp++;
            if (!isdigit((unsigned char) *cp))
                goto invalid_syntax;
        }
        else
            break;
    }
 
    ddigits = i - DEC_DIGITS;
    /* trailing padding for digit alignment later */
    memset(decdigits + i, 0, DEC_DIGITS - 1);
 
    /* Handle exponent, if any */
    if (*cp == 'e' || *cp == 'E')
    {
        int64       exponent = 0;
        bool        neg = false;
 
        /*
         * At this point, dweight and dscale can't be more than about
         * INT_MAX/2 due to the MaxAllocSize limit on string length, so
         * constraining the exponent similarly should be enough to prevent
         * integer overflow in this function.  If the value is too large to
         * fit in storage format, make_result() will complain about it later;
         * for consistency use the same ereport errcode/text as make_result().
         */
 
        /* exponent sign */
        cp++;
        if (*cp == '+')
            cp++;
        else if (*cp == '-')
        {
            neg = true;
            cp++;
        }
 
        /* exponent digits */
        if (!isdigit((unsigned char) *cp))
            goto invalid_syntax;
 
        while (*cp)
        {
            if (isdigit((unsigned char) *cp))
            {
                exponent = exponent * 10 + (*cp++ - '0');
                if (exponent > PG_INT32_MAX / 2)
                    goto out_of_range;
            }
            else if (*cp == '_')
            {
                /* underscore must be followed by more digits */
                cp++;
                if (!isdigit((unsigned char) *cp))
                    goto invalid_syntax;
            }
            else
                break;
        }
 
        if (neg)
            exponent = -exponent;
 
        dweight += (int) exponent;
        dscale -= (int) exponent;
        if (dscale < 0)
            dscale = 0;
    }
 
    /*
     * Okay, convert pure-decimal representation to base NBASE.  First we need
     * to determine the converted weight and ndigits.  offset is the number of
     * decimal zeroes to insert before the first given digit to have a
     * correctly aligned first NBASE digit.
     */
    if (dweight >= 0)
        weight = (dweight + 1 + DEC_DIGITS - 1) / DEC_DIGITS - 1;
    else
        weight = -((-dweight - 1) / DEC_DIGITS + 1);
    offset = (weight + 1) * DEC_DIGITS - (dweight + 1);
    ndigits = (ddigits + offset + DEC_DIGITS - 1) / DEC_DIGITS;
 
    alloc_var(dest, ndigits);
    dest->sign = sign;
    dest->weight = weight;
    dest->dscale = dscale;
 
    i = DEC_DIGITS - offset;
    digits = dest->digits;
 
    while (ndigits-- > 0)
    {
#if DEC_DIGITS == 4
        *digits++ = ((decdigits[i] * 10 + decdigits[i + 1]) * 10 +
                     decdigits[i + 2]) * 10 + decdigits[i + 3];
#elif DEC_DIGITS == 2
        *digits++ = decdigits[i] * 10 + decdigits[i + 1];
#elif DEC_DIGITS == 1
        *digits++ = decdigits[i];
#else
#error unsupported NBASE
#endif
        i += DEC_DIGITS;
    }
 
    pfree(decdigits);
 
    /* Strip any leading/trailing zeroes, and normalize weight if zero */
    strip_var(dest);
 
    /* Return end+1 position for caller */
    *endptr = cp;
 
    return true;
 
out_of_range:
    ereturn(escontext, false,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value overflows numeric format")));
 
invalid_syntax:
    ereturn(escontext, false,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "numeric", str)));
}

References alloc_var(), DEC_DIGITS, generate_unaccent_rules::dest, digits, ereturn, errcode(), errmsg(), i, NUMERIC_NEG, NUMERIC_POS, palloc(), pfree(), PG_INT32_MAX, sign, str, and strip_var().

Referenced by float4_numeric(), float8_numeric(), and numeric_in().

set_var_from_var()

static void set_var_from_var ( const NumericVar *  value, NumericVar *  dest  )

static

Definition at line 7199 of file numeric.c.

{
    NumericDigit *newbuf;
 
    newbuf = digitbuf_alloc(value->ndigits + 1);
    newbuf[0] = 0;              /* spare digit for rounding */
    if (value->ndigits > 0)     /* else value->digits might be null */
        memcpy(newbuf + 1, value->digits,
               value->ndigits * sizeof(NumericDigit));
 
    digitbuf_free(dest->buf);
 
    memmove(dest, value, sizeof(NumericVar));
    dest->buf = newbuf;
    dest->digits = newbuf + 1;
}

References generate_unaccent_rules::dest, digitbuf_alloc, digitbuf_free, and value.

Referenced by accum_sum_final(), ceil_var(), div_mod_var(), exp_var(), floor_var(), gcd_var(), generate_series_step_numeric(), ln_var(), numeric_lcm(), numericvar_to_int64(), numericvar_to_uint64(), power_ten_int(), power_var(), power_var_int(), random_var(), sqrt_var(), and width_bucket_numeric().

sqrt_var()

static void sqrt_var ( const NumericVar *  arg, NumericVar *  result, int  rscale  )

static

Definition at line 9932 of file numeric.c.

{
    int         stat;
    int         res_weight;
    int         res_ndigits;
    int         src_ndigits;
    int         step;
    int         ndigits[32];
    int         blen;
    int64       arg_int64;
    int         src_idx;
    int64       s_int64;
    int64       r_int64;
    NumericVar  s_var;
    NumericVar  r_var;
    NumericVar  a0_var;
    NumericVar  a1_var;
    NumericVar  q_var;
    NumericVar  u_var;
 
    stat = cmp_var(arg, &const_zero);
    if (stat == 0)
    {
        zero_var(result);
        result->dscale = rscale;
        return;
    }
 
    /*
     * SQL2003 defines sqrt() in terms of power, so we need to emit the right
     * SQLSTATE error code if the operand is negative.
     */
    if (stat < 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
                 errmsg("cannot take square root of a negative number")));
 
    init_var(&s_var);
    init_var(&r_var);
    init_var(&a0_var);
    init_var(&a1_var);
    init_var(&q_var);
    init_var(&u_var);
 
    /*
     * The result weight is half the input weight, rounded towards minus
     * infinity --- res_weight = floor(arg->weight / 2).
     */
    if (arg->weight >= 0)
        res_weight = arg->weight / 2;
    else
        res_weight = -((-arg->weight - 1) / 2 + 1);
 
    /*
     * Number of NBASE digits to compute.  To ensure correct rounding, compute
     * at least 1 extra decimal digit.  We explicitly allow rscale to be
     * negative here, but must always compute at least 1 NBASE digit.  Thus
     * res_ndigits = res_weight + 1 + ceil((rscale + 1) / DEC_DIGITS) or 1.
     */
    if (rscale + 1 >= 0)
        res_ndigits = res_weight + 1 + (rscale + DEC_DIGITS) / DEC_DIGITS;
    else
        res_ndigits = res_weight + 1 - (-rscale - 1) / DEC_DIGITS;
    res_ndigits = Max(res_ndigits, 1);
 
    /*
     * Number of source NBASE digits logically required to produce a result
     * with this precision --- every digit before the decimal point, plus 2
     * for each result digit after the decimal point (or minus 2 for each
     * result digit we round before the decimal point).
     */
    src_ndigits = arg->weight + 1 + (res_ndigits - res_weight - 1) * 2;
    src_ndigits = Max(src_ndigits, 1);
 
    /* ----------
     * From this point on, we treat the input and the result as integers and
     * compute the integer square root and remainder using the Karatsuba
     * Square Root algorithm, which may be written recursively as follows:
     *
     *  SqrtRem(n = a3*b^3 + a2*b^2 + a1*b + a0):
     *      [ for some base b, and coefficients a0,a1,a2,a3 chosen so that
     *        0 <= a0,a1,a2 < b and a3 >= b/4 ]
     *      Let (s,r) = SqrtRem(a3*b + a2)
     *      Let (q,u) = DivRem(r*b + a1, 2*s)
     *      Let s = s*b + q
     *      Let r = u*b + a0 - q^2
     *      If r < 0 Then
     *          Let r = r + s
     *          Let s = s - 1
     *          Let r = r + s
     *      Return (s,r)
     *
     * See "Karatsuba Square Root", Paul Zimmermann, INRIA Research Report
     * RR-3805, November 1999.  At the time of writing this was available
     * on the net at <https://hal.inria.fr/inria-00072854>.
     *
     * The way to read the assumption "n = a3*b^3 + a2*b^2 + a1*b + a0" is
     * "choose a base b such that n requires at least four base-b digits to
     * express; then those digits are a3,a2,a1,a0, with a3 possibly larger
     * than b".  For optimal performance, b should have approximately a
     * quarter the number of digits in the input, so that the outer square
     * root computes roughly twice as many digits as the inner one.  For
     * simplicity, we choose b = NBASE^blen, an integer power of NBASE.
     *
     * We implement the algorithm iteratively rather than recursively, to
     * allow the working variables to be reused.  With this approach, each
     * digit of the input is read precisely once --- src_idx tracks the number
     * of input digits used so far.
     *
     * The array ndigits[] holds the number of NBASE digits of the input that
     * will have been used at the end of each iteration, which roughly doubles
     * each time.  Note that the array elements are stored in reverse order,
     * so if the final iteration requires src_ndigits = 37 input digits, the
     * array will contain [37,19,11,7,5,3], and we would start by computing
     * the square root of the 3 most significant NBASE digits.
     *
     * In each iteration, we choose blen to be the largest integer for which
     * the input number has a3 >= b/4, when written in the form above.  In
     * general, this means blen = src_ndigits / 4 (truncated), but if
     * src_ndigits is a multiple of 4, that might lead to the coefficient a3
     * being less than b/4 (if the first input digit is less than NBASE/4), in
     * which case we choose blen = src_ndigits / 4 - 1.  The number of digits
     * in the inner square root is then src_ndigits - 2*blen.  So, for
     * example, if we have src_ndigits = 26 initially, the array ndigits[]
     * will be either [26,14,8,4] or [26,14,8,6,4], depending on the size of
     * the first input digit.
     *
     * Additionally, we can put an upper bound on the number of steps required
     * as follows --- suppose that the number of source digits is an n-bit
     * number in the range [2^(n-1), 2^n-1], then blen will be in the range
     * [2^(n-3)-1, 2^(n-2)-1] and the number of digits in the inner square
     * root will be in the range [2^(n-2), 2^(n-1)+1].  In the next step, blen
     * will be in the range [2^(n-4)-1, 2^(n-3)] and the number of digits in
     * the next inner square root will be in the range [2^(n-3), 2^(n-2)+1].
     * This pattern repeats, and in the worst case the array ndigits[] will
     * contain [2^n-1, 2^(n-1)+1, 2^(n-2)+1, ... 9, 5, 3], and the computation
     * will require n steps.  Therefore, since all digit array sizes are
     * signed 32-bit integers, the number of steps required is guaranteed to
     * be less than 32.
     * ----------
     */
    step = 0;
    while ((ndigits[step] = src_ndigits) > 4)
    {
        /* Choose b so that a3 >= b/4, as described above */
        blen = src_ndigits / 4;
        if (blen * 4 == src_ndigits && arg->digits[0] < NBASE / 4)
            blen--;
 
        /* Number of digits in the next step (inner square root) */
        src_ndigits -= 2 * blen;
        step++;
    }
 
    /*
     * First iteration (innermost square root and remainder):
     *
     * Here src_ndigits <= 4, and the input fits in an int64.  Its square root
     * has at most 9 decimal digits, so estimate it using double precision
     * arithmetic, which will in fact almost certainly return the correct
     * result with no further correction required.
     */
    arg_int64 = arg->digits[0];
    for (src_idx = 1; src_idx < src_ndigits; src_idx++)
    {
        arg_int64 *= NBASE;
        if (src_idx < arg->ndigits)
            arg_int64 += arg->digits[src_idx];
    }
 
    s_int64 = (int64) sqrt((double) arg_int64);
    r_int64 = arg_int64 - s_int64 * s_int64;
 
    /*
     * Use Newton's method to correct the result, if necessary.
     *
     * This uses integer division with truncation to compute the truncated
     * integer square root by iterating using the formula x -> (x + n/x) / 2.
     * This is known to converge to isqrt(n), unless n+1 is a perfect square.
     * If n+1 is a perfect square, the sequence will oscillate between the two
     * values isqrt(n) and isqrt(n)+1, so we can be assured of convergence by
     * checking the remainder.
     */
    while (r_int64 < 0 || r_int64 > 2 * s_int64)
    {
        s_int64 = (s_int64 + arg_int64 / s_int64) / 2;
        r_int64 = arg_int64 - s_int64 * s_int64;
    }
 
    /*
     * Iterations with src_ndigits <= 8:
     *
     * The next 1 or 2 iterations compute larger (outer) square roots with
     * src_ndigits <= 8, so the result still fits in an int64 (even though the
     * input no longer does) and we can continue to compute using int64
     * variables to avoid more expensive numeric computations.
     *
     * It is fairly easy to see that there is no risk of the intermediate
     * values below overflowing 64-bit integers.  In the worst case, the
     * previous iteration will have computed a 3-digit square root (of a
     * 6-digit input less than NBASE^6 / 4), so at the start of this
     * iteration, s will be less than NBASE^3 / 2 = 10^12 / 2, and r will be
     * less than 10^12.  In this case, blen will be 1, so numer will be less
     * than 10^17, and denom will be less than 10^12 (and hence u will also be
     * less than 10^12).  Finally, since q^2 = u*b + a0 - r, we can also be
     * sure that q^2 < 10^17.  Therefore all these quantities fit comfortably
     * in 64-bit integers.
     */
    step--;
    while (step >= 0 && (src_ndigits = ndigits[step]) <= 8)
    {
        int         b;
        int         a0;
        int         a1;
        int         i;
        int64       numer;
        int64       denom;
        int64       q;
        int64       u;
 
        blen = (src_ndigits - src_idx) / 2;
 
        /* Extract a1 and a0, and compute b */
        a0 = 0;
        a1 = 0;
        b = 1;
 
        for (i = 0; i < blen; i++, src_idx++)
        {
            b *= NBASE;
            a1 *= NBASE;
            if (src_idx < arg->ndigits)
                a1 += arg->digits[src_idx];
        }
 
        for (i = 0; i < blen; i++, src_idx++)
        {
            a0 *= NBASE;
            if (src_idx < arg->ndigits)
                a0 += arg->digits[src_idx];
        }
 
        /* Compute (q,u) = DivRem(r*b + a1, 2*s) */
        numer = r_int64 * b + a1;
        denom = 2 * s_int64;
        q = numer / denom;
        u = numer - q * denom;
 
        /* Compute s = s*b + q and r = u*b + a0 - q^2 */
        s_int64 = s_int64 * b + q;
        r_int64 = u * b + a0 - q * q;
 
        if (r_int64 < 0)
        {
            /* s is too large by 1; set r += s, s--, r += s */
            r_int64 += s_int64;
            s_int64--;
            r_int64 += s_int64;
        }
 
        Assert(src_idx == src_ndigits); /* All input digits consumed */
        step--;
    }
 
    /*
     * On platforms with 128-bit integer support, we can further delay the
     * need to use numeric variables.
     */
#ifdef HAVE_INT128
    if (step >= 0)
    {
        int128      s_int128;
        int128      r_int128;
 
        s_int128 = s_int64;
        r_int128 = r_int64;
 
        /*
         * Iterations with src_ndigits <= 16:
         *
         * The result fits in an int128 (even though the input doesn't) so we
         * use int128 variables to avoid more expensive numeric computations.
         */
        while (step >= 0 && (src_ndigits = ndigits[step]) <= 16)
        {
            int64       b;
            int64       a0;
            int64       a1;
            int64       i;
            int128      numer;
            int128      denom;
            int128      q;
            int128      u;
 
            blen = (src_ndigits - src_idx) / 2;
 
            /* Extract a1 and a0, and compute b */
            a0 = 0;
            a1 = 0;
            b = 1;
 
            for (i = 0; i < blen; i++, src_idx++)
            {
                b *= NBASE;
                a1 *= NBASE;
                if (src_idx < arg->ndigits)
                    a1 += arg->digits[src_idx];
            }
 
            for (i = 0; i < blen; i++, src_idx++)
            {
                a0 *= NBASE;
                if (src_idx < arg->ndigits)
                    a0 += arg->digits[src_idx];
            }
 
            /* Compute (q,u) = DivRem(r*b + a1, 2*s) */
            numer = r_int128 * b + a1;
            denom = 2 * s_int128;
            q = numer / denom;
            u = numer - q * denom;
 
            /* Compute s = s*b + q and r = u*b + a0 - q^2 */
            s_int128 = s_int128 * b + q;
            r_int128 = u * b + a0 - q * q;
 
            if (r_int128 < 0)
            {
                /* s is too large by 1; set r += s, s--, r += s */
                r_int128 += s_int128;
                s_int128--;
                r_int128 += s_int128;
            }
 
            Assert(src_idx == src_ndigits); /* All input digits consumed */
            step--;
        }
 
        /*
         * All remaining iterations require numeric variables.  Convert the
         * integer values to NumericVar and continue.  Note that in the final
         * iteration we don't need the remainder, so we can save a few cycles
         * there by not fully computing it.
         */
        int128_to_numericvar(s_int128, &s_var);
        if (step >= 0)
            int128_to_numericvar(r_int128, &r_var);
    }
    else
    {
        int64_to_numericvar(s_int64, &s_var);
        /* step < 0, so we certainly don't need r */
    }
#else                           /* !HAVE_INT128 */
    int64_to_numericvar(s_int64, &s_var);
    if (step >= 0)
        int64_to_numericvar(r_int64, &r_var);
#endif                          /* HAVE_INT128 */
 
    /*
     * The remaining iterations with src_ndigits > 8 (or 16, if have int128)
     * use numeric variables.
     */
    while (step >= 0)
    {
        int         tmp_len;
 
        src_ndigits = ndigits[step];
        blen = (src_ndigits - src_idx) / 2;
 
        /* Extract a1 and a0 */
        if (src_idx < arg->ndigits)
        {
            tmp_len = Min(blen, arg->ndigits - src_idx);
            alloc_var(&a1_var, tmp_len);
            memcpy(a1_var.digits, arg->digits + src_idx,
                   tmp_len * sizeof(NumericDigit));
            a1_var.weight = blen - 1;
            a1_var.sign = NUMERIC_POS;
            a1_var.dscale = 0;
            strip_var(&a1_var);
        }
        else
        {
            zero_var(&a1_var);
            a1_var.dscale = 0;
        }
        src_idx += blen;
 
        if (src_idx < arg->ndigits)
        {
            tmp_len = Min(blen, arg->ndigits - src_idx);
            alloc_var(&a0_var, tmp_len);
            memcpy(a0_var.digits, arg->digits + src_idx,
                   tmp_len * sizeof(NumericDigit));
            a0_var.weight = blen - 1;
            a0_var.sign = NUMERIC_POS;
            a0_var.dscale = 0;
            strip_var(&a0_var);
        }
        else
        {
            zero_var(&a0_var);
            a0_var.dscale = 0;
        }
        src_idx += blen;
 
        /* Compute (q,u) = DivRem(r*b + a1, 2*s) */
        set_var_from_var(&r_var, &q_var);
        q_var.weight += blen;
        add_var(&q_var, &a1_var, &q_var);
        add_var(&s_var, &s_var, &u_var);
        div_mod_var(&q_var, &u_var, &q_var, &u_var);
 
        /* Compute s = s*b + q */
        s_var.weight += blen;
        add_var(&s_var, &q_var, &s_var);
 
        /*
         * Compute r = u*b + a0 - q^2.
         *
         * In the final iteration, we don't actually need r; we just need to
         * know whether it is negative, so that we know whether to adjust s.
         * So instead of the final subtraction we can just compare.
         */
        u_var.weight += blen;
        add_var(&u_var, &a0_var, &u_var);
        mul_var(&q_var, &q_var, &q_var, 0);
 
        if (step > 0)
        {
            /* Need r for later iterations */
            sub_var(&u_var, &q_var, &r_var);
            if (r_var.sign == NUMERIC_NEG)
            {
                /* s is too large by 1; set r += s, s--, r += s */
                add_var(&r_var, &s_var, &r_var);
                sub_var(&s_var, &const_one, &s_var);
                add_var(&r_var, &s_var, &r_var);
            }
        }
        else
        {
            /* Don't need r anymore, except to test if s is too large by 1 */
            if (cmp_var(&u_var, &q_var) < 0)
                sub_var(&s_var, &const_one, &s_var);
        }
 
        Assert(src_idx == src_ndigits); /* All input digits consumed */
        step--;
    }
 
    /*
     * Construct the final result, rounding it to the requested precision.
     */
    set_var_from_var(&s_var, result);
    result->weight = res_weight;
    result->sign = NUMERIC_POS;
 
    /* Round to target rscale (and set result->dscale) */
    round_var(result, rscale);
 
    /* Strip leading and trailing zeroes */
    strip_var(result);
 
    free_var(&s_var);
    free_var(&r_var);
    free_var(&a0_var);
    free_var(&a1_var);
    free_var(&q_var);
    free_var(&u_var);
}

References a1, add_var(), alloc_var(), arg, Assert(), b, cmp_var(), const_one, const_zero, DEC_DIGITS, NumericVar::digits, div_mod_var(), NumericVar::dscale, ereport, errcode(), errmsg(), ERROR, free_var(), i, init_var, int128_to_numericvar(), int64_to_numericvar(), Max, Min, mul_var(), NBASE, NUMERIC_NEG, NUMERIC_POS, round_var(), set_var_from_var(), NumericVar::sign, stat, strip_var(), sub_var(), NumericVar::weight, and zero_var().

Referenced by ln_var(), numeric_sqrt(), and numeric_stddev_internal().

strip_var()

static void strip_var ( NumericVar *  var )

static

Definition at line 11789 of file numeric.c.

{
    NumericDigit *digits = var->digits;
    int         ndigits = var->ndigits;
 
    /* Strip leading zeroes */
    while (ndigits > 0 && *digits == 0)
    {
        digits++;
        var->weight--;
        ndigits--;
    }
 
    /* Strip trailing zeroes */
    while (ndigits > 0 && digits[ndigits - 1] == 0)
        ndigits--;
 
    /* If it's zero, normalize the sign and weight */
    if (ndigits == 0)
    {
        var->sign = NUMERIC_POS;
        var->weight = 0;
    }
 
    var->digits = digits;
    var->ndigits = ndigits;
}

References NumericVar::digits, digits, NumericVar::ndigits, NUMERIC_POS, NumericVar::sign, and NumericVar::weight.

Referenced by accum_sum_final(), add_abs(), div_var(), div_var_int(), mul_var(), mul_var_short(), numericvar_to_int64(), numericvar_to_uint64(), random_var(), set_var_from_str(), sqrt_var(), and sub_abs().

sub_abs()

static void sub_abs ( const NumericVar *  var1, const NumericVar *  var2, NumericVar *  result  )

static

Definition at line 11539 of file numeric.c.

{
    NumericDigit *res_buf;
    NumericDigit *res_digits;
    int         res_ndigits;
    int         res_weight;
    int         res_rscale,
                rscale1,
                rscale2;
    int         res_dscale;
    int         i,
                i1,
                i2;
    int         borrow = 0;
 
    /* copy these values into local vars for speed in inner loop */
    int         var1ndigits = var1->ndigits;
    int         var2ndigits = var2->ndigits;
    NumericDigit *var1digits = var1->digits;
    NumericDigit *var2digits = var2->digits;
 
    res_weight = var1->weight;
 
    res_dscale = Max(var1->dscale, var2->dscale);
 
    /* Note: here we are figuring rscale in base-NBASE digits */
    rscale1 = var1->ndigits - var1->weight - 1;
    rscale2 = var2->ndigits - var2->weight - 1;
    res_rscale = Max(rscale1, rscale2);
 
    res_ndigits = res_rscale + res_weight + 1;
    if (res_ndigits <= 0)
        res_ndigits = 1;
 
    res_buf = digitbuf_alloc(res_ndigits + 1);
    res_buf[0] = 0;             /* spare digit for later rounding */
    res_digits = res_buf + 1;
 
    i1 = res_rscale + var1->weight + 1;
    i2 = res_rscale + var2->weight + 1;
    for (i = res_ndigits - 1; i >= 0; i--)
    {
        i1--;
        i2--;
        if (i1 >= 0 && i1 < var1ndigits)
            borrow += var1digits[i1];
        if (i2 >= 0 && i2 < var2ndigits)
            borrow -= var2digits[i2];
 
        if (borrow < 0)
        {
            res_digits[i] = borrow + NBASE;
            borrow = -1;
        }
        else
        {
            res_digits[i] = borrow;
            borrow = 0;
        }
    }
 
    Assert(borrow == 0);        /* else caller gave us var1 < var2 */
 
    digitbuf_free(result->buf);
    result->ndigits = res_ndigits;
    result->buf = res_buf;
    result->digits = res_digits;
    result->weight = res_weight;
    result->dscale = res_dscale;
 
    /* Remove leading/trailing zeroes */
    strip_var(result);
}

References Assert(), NumericVar::buf, digitbuf_alloc, digitbuf_free, NumericVar::digits, NumericVar::dscale, i, Max, NBASE, NumericVar::ndigits, strip_var(), and NumericVar::weight.

Referenced by add_var(), and sub_var().

sub_var()

static void sub_var ( const NumericVar *  var1, const NumericVar *  var2, NumericVar *  result  )

static

Definition at line 8179 of file numeric.c.

{
    /*
     * Decide on the signs of the two variables what to do
     */
    if (var1->sign == NUMERIC_POS)
    {
        if (var2->sign == NUMERIC_NEG)
        {
            /* ----------
             * var1 is positive, var2 is negative
             * result = +(ABS(var1) + ABS(var2))
             * ----------
             */
            add_abs(var1, var2, result);
            result->sign = NUMERIC_POS;
        }
        else
        {
            /* ----------
             * Both are positive
             * Must compare absolute values
             * ----------
             */
            switch (cmp_abs(var1, var2))
            {
                case 0:
                    /* ----------
                     * ABS(var1) == ABS(var2)
                     * result = ZERO
                     * ----------
                     */
                    zero_var(result);
                    result->dscale = Max(var1->dscale, var2->dscale);
                    break;
 
                case 1:
                    /* ----------
                     * ABS(var1) > ABS(var2)
                     * result = +(ABS(var1) - ABS(var2))
                     * ----------
                     */
                    sub_abs(var1, var2, result);
                    result->sign = NUMERIC_POS;
                    break;
 
                case -1:
                    /* ----------
                     * ABS(var1) < ABS(var2)
                     * result = -(ABS(var2) - ABS(var1))
                     * ----------
                     */
                    sub_abs(var2, var1, result);
                    result->sign = NUMERIC_NEG;
                    break;
            }
        }
    }
    else
    {
        if (var2->sign == NUMERIC_NEG)
        {
            /* ----------
             * Both are negative
             * Must compare absolute values
             * ----------
             */
            switch (cmp_abs(var1, var2))
            {
                case 0:
                    /* ----------
                     * ABS(var1) == ABS(var2)
                     * result = ZERO
                     * ----------
                     */
                    zero_var(result);
                    result->dscale = Max(var1->dscale, var2->dscale);
                    break;
 
                case 1:
                    /* ----------
                     * ABS(var1) > ABS(var2)
                     * result = -(ABS(var1) - ABS(var2))
                     * ----------
                     */
                    sub_abs(var1, var2, result);
                    result->sign = NUMERIC_NEG;
                    break;
 
                case -1:
                    /* ----------
                     * ABS(var1) < ABS(var2)
                     * result = +(ABS(var2) - ABS(var1))
                     * ----------
                     */
                    sub_abs(var2, var1, result);
                    result->sign = NUMERIC_POS;
                    break;
            }
        }
        else
        {
            /* ----------
             * var1 is negative, var2 is positive
             * result = -(ABS(var1) + ABS(var2))
             * ----------
             */
            add_abs(var1, var2, result);
            result->sign = NUMERIC_NEG;
        }
    }
}

References add_abs(), cmp_abs(), NumericVar::dscale, Max, NUMERIC_NEG, NUMERIC_POS, NumericVar::sign, sub_abs(), and zero_var().

Referenced by compute_bucket(), div_mod_var(), estimate_ln_dweight(), floor_var(), generate_series_numeric_support(), in_range_numeric_numeric(), ln_var(), mod_var(), numeric_stddev_internal(), numeric_sub_safe(), random_var(), and sqrt_var().

trunc_var()

static void trunc_var ( NumericVar *  var, int  rscale  )

static

Definition at line 11727 of file numeric.c.

{
    int         di;
    int         ndigits;
 
    var->dscale = rscale;
 
    /* decimal digits wanted */
    di = (var->weight + 1) * DEC_DIGITS + rscale;
 
    /*
     * If di <= 0, the value loses all digits.
     */
    if (di <= 0)
    {
        var->ndigits = 0;
        var->weight = 0;
        var->sign = NUMERIC_POS;
    }
    else
    {
        /* NBASE digits wanted */
        ndigits = (di + DEC_DIGITS - 1) / DEC_DIGITS;
 
        if (ndigits <= var->ndigits)
        {
            var->ndigits = ndigits;
 
#if DEC_DIGITS == 1
            /* no within-digit stuff to worry about */
#else
            /* 0, or number of decimal digits to keep in last NBASE digit */
            di %= DEC_DIGITS;
 
            if (di > 0)
            {
                /* Must truncate within last NBASE digit */
                NumericDigit *digits = var->digits;
                int         extra,
                            pow10;
 
#if DEC_DIGITS == 4
                pow10 = round_powers[di];
#elif DEC_DIGITS == 2
                pow10 = 10;
#else
#error unsupported NBASE
#endif
                extra = digits[--ndigits] % pow10;
                digits[ndigits] -= extra;
            }
#endif
        }
    }
}

References DEC_DIGITS, NumericVar::digits, digits, NumericVar::dscale, NumericVar::ndigits, NUMERIC_POS, round_powers, NumericVar::sign, and NumericVar::weight.

Referenced by ceil_var(), div_var(), div_var_int(), floor_var(), generate_series_numeric_support(), numeric_recv(), and numeric_trunc().

width_bucket_numeric()

Datum width_bucket_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 1951 of file numeric.c.

{
    Numeric     operand = PG_GETARG_NUMERIC(0);
    Numeric     bound1 = PG_GETARG_NUMERIC(1);
    Numeric     bound2 = PG_GETARG_NUMERIC(2);
    int32       count = PG_GETARG_INT32(3);
    NumericVar  count_var;
    NumericVar  result_var;
    int32       result;
 
    if (count <= 0)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
                 errmsg("count must be greater than zero")));
 
    if (NUMERIC_IS_SPECIAL(bound1) || NUMERIC_IS_SPECIAL(bound2))
    {
        if (NUMERIC_IS_NAN(bound1) || NUMERIC_IS_NAN(bound2))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
                     errmsg("lower and upper bounds cannot be NaN")));
 
        if (NUMERIC_IS_INF(bound1) || NUMERIC_IS_INF(bound2))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
                     errmsg("lower and upper bounds must be finite")));
    }
 
    init_var(&result_var);
    init_var(&count_var);
 
    /* Convert 'count' to a numeric, for ease of use later */
    int64_to_numericvar((int64) count, &count_var);
 
    switch (cmp_numerics(bound1, bound2))
    {
        case 0:
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
                     errmsg("lower bound cannot equal upper bound")));
            break;
 
            /* bound1 < bound2 */
        case -1:
            if (cmp_numerics(operand, bound1) < 0)
                set_var_from_var(&const_zero, &result_var);
            else if (cmp_numerics(operand, bound2) >= 0)
                add_var(&count_var, &const_one, &result_var);
            else
                compute_bucket(operand, bound1, bound2, &count_var,
                               &result_var);
            break;
 
            /* bound1 > bound2 */
        case 1:
            if (cmp_numerics(operand, bound1) > 0)
                set_var_from_var(&const_zero, &result_var);
            else if (cmp_numerics(operand, bound2) <= 0)
                add_var(&count_var, &const_one, &result_var);
            else
                compute_bucket(operand, bound1, bound2, &count_var,
                               &result_var);
            break;
    }
 
    /* if result exceeds the range of a legal int4, we ereport here */
    if (!numericvar_to_int32(&result_var, &result))
        ereport(ERROR,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("integer out of range")));
 
    free_var(&count_var);
    free_var(&result_var);
 
    PG_RETURN_INT32(result);
}

References add_var(), cmp_numerics(), compute_bucket(), const_one, const_zero, ereport, errcode(), errmsg(), ERROR, free_var(), init_var, int64_to_numericvar(), NUMERIC_IS_INF, NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, numericvar_to_int32(), PG_GETARG_INT32, PG_GETARG_NUMERIC, PG_RETURN_INT32, and set_var_from_var().

xdigit_value()

static int xdigit_value ( char  dig )

inlinestatic

Definition at line 6946 of file numeric.c.

{
    return dig >= '0' && dig <= '9' ? dig - '0' :
        dig >= 'a' && dig <= 'f' ? dig - 'a' + 10 :
        dig >= 'A' && dig <= 'F' ? dig - 'A' + 10 : -1;
}

Referenced by set_var_from_non_decimal_integer_str().

zero_var()

static void zero_var ( NumericVar *  var )

static

Definition at line 6716 of file numeric.c.

{
    digitbuf_free(var->buf);
    var->buf = NULL;
    var->digits = NULL;
    var->ndigits = 0;
    var->weight = 0;            /* by convention; doesn't really matter */
    var->sign = NUMERIC_POS;    /* anything but NAN... */
}

References NumericVar::buf, digitbuf_free, NumericVar::digits, NumericVar::ndigits, NUMERIC_POS, NumericVar::sign, and NumericVar::weight.

Referenced by add_var(), div_var(), div_var_int(), exp_var(), mul_var(), power_var(), power_var_int(), set_var_from_non_decimal_integer_str(), sqrt_var(), and sub_var().

Variable Documentation

const_minus_one

const NumericVar const_minus_one

static

Initial value:

=
{1, 0, NUMERIC_NEG, 0, NULL, (NumericDigit *) const_one_data}

Definition at line 424 of file numeric.c.

Referenced by numeric_power(), and numeric_sign().

const_nan

const NumericVar const_nan

static

Initial value:

=
{0, 0, NUMERIC_NAN, 0, NULL, NULL}

Definition at line 451 of file numeric.c.

Referenced by float4_numeric(), float8_numeric(), numeric_add_safe(), numeric_avg(), numeric_div_safe(), numeric_div_trunc(), numeric_gcd(), numeric_in(), numeric_lcm(), numeric_log(), numeric_mod_safe(), numeric_mul_safe(), numeric_power(), numeric_sign(), numeric_stddev_internal(), numeric_sub_safe(), and numeric_sum().

const_ninf

const NumericVar const_ninf

static

Initial value:

=
{0, 0, NUMERIC_NINF, 0, NULL, NULL}

Definition at line 457 of file numeric.c.

Referenced by float4_numeric(), float8_numeric(), numeric_add_safe(), numeric_avg(), numeric_div_safe(), numeric_div_trunc(), numeric_in(), numeric_mul_safe(), numeric_power(), numeric_sub_safe(), and numeric_sum().

const_one

const NumericVar const_one

static

Initial value:

=
{1, 0, NUMERIC_POS, 0, NULL, (NumericDigit *) const_one_data}

Definition at line 421 of file numeric.c.

Referenced by ceil_var(), compute_bucket(), div_mod_var(), estimate_ln_dweight(), exp_var(), floor_var(), generate_series_numeric_support(), generate_series_step_numeric(), ln_var(), numeric_fac(), numeric_inc(), numeric_power(), numeric_sign(), numeric_stddev_internal(), power_ten_int(), power_var_int(), sqrt_var(), and width_bucket_numeric().

const_one_data

const NumericDigit const_one_data[1] = {1}

static

Definition at line 420 of file numeric.c.

const_one_point_one

const NumericVar const_one_point_one

static

Initial value:

=
{2, 0, NUMERIC_POS, 1, NULL, (NumericDigit *) const_one_point_one_data}

Definition at line 448 of file numeric.c.

Referenced by estimate_ln_dweight(), and ln_var().

const_one_point_one_data

const NumericDigit const_one_point_one_data[2] = {1, 1000}

static

Definition at line 442 of file numeric.c.

const_pinf

const NumericVar const_pinf

static

Initial value:

=
{0, 0, NUMERIC_PINF, 0, NULL, NULL}

Definition at line 454 of file numeric.c.

Referenced by float4_numeric(), float8_numeric(), numeric_add_safe(), numeric_avg(), numeric_div_safe(), numeric_div_trunc(), numeric_in(), numeric_log(), numeric_mul_safe(), numeric_power(), numeric_sub_safe(), and numeric_sum().

const_two

const NumericVar const_two

static

Initial value:

=
{1, 0, NUMERIC_POS, 0, NULL, (NumericDigit *) const_two_data}

Definition at line 428 of file numeric.c.

Referenced by ln_var().

const_two_data

const NumericDigit const_two_data[1] = {2}

static

Definition at line 427 of file numeric.c.

const_zero

const NumericVar const_zero

static

Initial value:

=
{0, 0, NUMERIC_POS, 0, NULL, (NumericDigit *) const_zero_data}

Definition at line 417 of file numeric.c.

Referenced by accum_sum_final(), generate_series_numeric_support(), generate_series_step_numeric(), ln_var(), numeric_div_safe(), numeric_div_trunc(), numeric_exp(), numeric_lcm(), numeric_log(), numeric_power(), numeric_sign(), numeric_stddev_internal(), power_var(), sqrt_var(), and width_bucket_numeric().

const_zero_data

const NumericDigit const_zero_data[1] = {0}

static

Definition at line 416 of file numeric.c.

const_zero_point_nine

const NumericVar const_zero_point_nine

static

Initial value:

=
{1, -1, NUMERIC_POS, 1, NULL, (NumericDigit *) const_zero_point_nine_data}

Definition at line 438 of file numeric.c.

Referenced by estimate_ln_dweight(), and ln_var().

const_zero_point_nine_data

const NumericDigit const_zero_point_nine_data[1] = {9000}

static

Definition at line 432 of file numeric.c.

round_powers

const int round_powers[4] = {0, 1000, 100, 10}

static

Definition at line 461 of file numeric.c.

Referenced by round_var(), and trunc_var().