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 "funcapi.h"
#include "lib/hyperloglog.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "nodes/supportnodes.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	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	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	NUMERIC_ABBREV_BITS   (SIZEOF_DATUM * BITS_PER_BYTE)
#define	NumericAbbrevGetDatum(X)   ((Datum) (X))
#define	DatumGetNumericAbbrev(X)   ((int32) (X))
#define	NUMERIC_ABBREV_NAN   NumericAbbrevGetDatum(PG_INT32_MIN)
#define	NUMERIC_ABBREV_PINF   NumericAbbrevGetDatum(-PG_INT32_MAX)
#define	NUMERIC_ABBREV_NINF   NumericAbbrevGetDatum(PG_INT32_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	makePolyNumAggState   makeNumericAggState
#define	makePolyNumAggStateCurrentContext   makeNumericAggStateCurrentContext

Typedefs
typedef int16	NumericDigit
typedef struct NumericVar	NumericVar
typedef struct NumericSumAccum	NumericSumAccum
typedef struct NumericAggState	NumericAggState
typedef NumericAggState	PolyNumAggState
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_opt_error (const NumericVar *var, bool *have_error)
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 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)
static void	div_var_fast (const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale, bool round)
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	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_opt_error (Numeric num1, Numeric num2, bool *have_error)
Datum	numeric_sub (PG_FUNCTION_ARGS)
Numeric	numeric_sub_opt_error (Numeric num1, Numeric num2, bool *have_error)
Datum	numeric_mul (PG_FUNCTION_ARGS)
Numeric	numeric_mul_opt_error (Numeric num1, Numeric num2, bool *have_error)
Datum	numeric_div (PG_FUNCTION_ARGS)
Numeric	numeric_div_opt_error (Numeric num1, Numeric num2, bool *have_error)
Datum	numeric_div_trunc (PG_FUNCTION_ARGS)
Datum	numeric_mod (PG_FUNCTION_ARGS)
Numeric	numeric_mod_opt_error (Numeric num1, Numeric num2, bool *have_error)
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_opt_error (Numeric num, bool *have_error)
Datum	numeric_int4 (PG_FUNCTION_ARGS)
Datum	int8_numeric (PG_FUNCTION_ARGS)
int64	numeric_int8_opt_error (Numeric num, bool *have_error)
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)
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)
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)
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

)

((int32) (X))

Definition at line 410 of file numeric.c.

DEC_DIGITS

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

Definition at line 97 of file numeric.c.

digitbuf_alloc

#define digitbuf_alloc

(

ndigits

)

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

Definition at line 483 of file numeric.c.

digitbuf_free

#define digitbuf_free

(

buf

)

Value:

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

Definition at line 485 of file numeric.c.

DIV_GUARD_DIGITS

#define DIV_GUARD_DIGITS   4

Definition at line 99 of file numeric.c.

dump_numeric

#define dump_numeric	(		s,
			n
	)

Definition at line 479 of file numeric.c.

dump_var

#define dump_var	(		s,
			v
	)

Definition at line 480 of file numeric.c.

HALF_NBASE

#define HALF_NBASE   5000

Definition at line 96 of file numeric.c.

init_var

#define init_var

(

v

)

memset(v, 0, sizeof(NumericVar))

Definition at line 491 of file numeric.c.

makePolyNumAggState

#define makePolyNumAggState   makeNumericAggState

Definition at line 5549 of file numeric.c.

makePolyNumAggStateCurrentContext

#define makePolyNumAggStateCurrentContext   makeNumericAggStateCurrentContext

Definition at line 5550 of file numeric.c.

MUL_GUARD_DIGITS

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

Definition at line 98 of file numeric.c.

NA_TOTAL_COUNT

#define NA_TOTAL_COUNT

(

na

)

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

Definition at line 4813 of file numeric.c.

NBASE

#define NBASE   10000

Definition at line 95 of file numeric.c.

NUMERIC_ABBREV_BITS

#define NUMERIC_ABBREV_BITS   (SIZEOF_DATUM * BITS_PER_BYTE)

Definition at line 401 of file numeric.c.

NUMERIC_ABBREV_NAN

#define NUMERIC_ABBREV_NAN   NumericAbbrevGetDatum(PG_INT32_MIN)

Definition at line 411 of file numeric.c.

NUMERIC_ABBREV_NINF

#define NUMERIC_ABBREV_NINF   NumericAbbrevGetDatum(PG_INT32_MAX)

Definition at line 413 of file numeric.c.

NUMERIC_ABBREV_PINF

#define NUMERIC_ABBREV_PINF   NumericAbbrevGetDatum(-PG_INT32_MAX)

Definition at line 412 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 497 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 493 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 242 of file numeric.c.

NUMERIC_DSCALE_MASK

#define NUMERIC_DSCALE_MASK   0x3FFF

Definition at line 233 of file numeric.c.

NUMERIC_DSCALE_MAX

#define NUMERIC_DSCALE_MAX   NUMERIC_DSCALE_MASK

Definition at line 234 of file numeric.c.

NUMERIC_EXT_FLAGBITS

#define NUMERIC_EXT_FLAGBITS

(

n

)

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

Definition at line 202 of file numeric.c.

NUMERIC_EXT_SIGN_MASK

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

Definition at line 196 of file numeric.c.

NUMERIC_FLAGBITS

#define NUMERIC_FLAGBITS

(

n

)

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

Definition at line 170 of file numeric.c.

NUMERIC_HDRSZ

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

Definition at line 174 of file numeric.c.

NUMERIC_HDRSZ_SHORT

#define NUMERIC_HDRSZ_SHORT   (VARHDRSZ + sizeof(uint16))

Definition at line 175 of file numeric.c.

NUMERIC_HEADER_IS_SHORT

#define NUMERIC_HEADER_IS_SHORT

(

n

)

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

Definition at line 182 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 183 of file numeric.c.

NUMERIC_INF_SIGN_MASK

#define NUMERIC_INF_SIGN_MASK   0x2000

Definition at line 200 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 206 of file numeric.c.

NUMERIC_IS_NAN

#define NUMERIC_IS_NAN

(

n

)

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

Definition at line 203 of file numeric.c.

NUMERIC_IS_NINF

#define NUMERIC_IS_NINF

(

n

)

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

Definition at line 205 of file numeric.c.

NUMERIC_IS_PINF

#define NUMERIC_IS_PINF

(

n

)

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

Definition at line 204 of file numeric.c.

NUMERIC_IS_SHORT

#define NUMERIC_IS_SHORT

(

n

)

(NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)

Definition at line 171 of file numeric.c.

NUMERIC_IS_SPECIAL

#define NUMERIC_IS_SPECIAL

(

n

)

(NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)

Definition at line 172 of file numeric.c.

NUMERIC_NAN

#define NUMERIC_NAN   0xC000

Definition at line 197 of file numeric.c.

NUMERIC_NDIGITS

#define NUMERIC_NDIGITS

(

num

)

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

Definition at line 495 of file numeric.c.

NUMERIC_NEG

#define NUMERIC_NEG   0x4000

Definition at line 166 of file numeric.c.

NUMERIC_NINF

#define NUMERIC_NINF   0xF000

Definition at line 199 of file numeric.c.

NUMERIC_PINF

#define NUMERIC_PINF   0xD000

Definition at line 198 of file numeric.c.

NUMERIC_POS

#define NUMERIC_POS   0x0000

Definition at line 165 of file numeric.c.

NUMERIC_SHORT

#define NUMERIC_SHORT   0x8000

Definition at line 167 of file numeric.c.

NUMERIC_SHORT_DSCALE_MASK

#define NUMERIC_SHORT_DSCALE_MASK   0x1F80

Definition at line 214 of file numeric.c.

NUMERIC_SHORT_DSCALE_MAX

#define NUMERIC_SHORT_DSCALE_MAX    (NUMERIC_SHORT_DSCALE_MASK >> NUMERIC_SHORT_DSCALE_SHIFT)

Definition at line 216 of file numeric.c.

NUMERIC_SHORT_DSCALE_SHIFT

#define NUMERIC_SHORT_DSCALE_SHIFT   7

Definition at line 215 of file numeric.c.

NUMERIC_SHORT_SIGN_MASK

#define NUMERIC_SHORT_SIGN_MASK   0x2000

Definition at line 213 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MASK

#define NUMERIC_SHORT_WEIGHT_MASK   0x003F

Definition at line 219 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MAX

#define NUMERIC_SHORT_WEIGHT_MAX   NUMERIC_SHORT_WEIGHT_MASK

Definition at line 220 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MIN

#define NUMERIC_SHORT_WEIGHT_MIN   (-(NUMERIC_SHORT_WEIGHT_MASK+1))

Definition at line 221 of file numeric.c.

NUMERIC_SHORT_WEIGHT_SIGN_MASK

#define NUMERIC_SHORT_WEIGHT_SIGN_MASK   0x0040

Definition at line 218 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 236 of file numeric.c.

NUMERIC_SIGN_MASK

#define NUMERIC_SIGN_MASK   0xC000

Definition at line 164 of file numeric.c.

NUMERIC_SPECIAL

#define NUMERIC_SPECIAL   0xC000

Definition at line 168 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 246 of file numeric.c.

NUMERIC_WEIGHT_MAX

#define NUMERIC_WEIGHT_MAX   PG_INT16_MAX

Definition at line 257 of file numeric.c.

NumericAbbrevGetDatum

#define NumericAbbrevGetDatum

(

X

)

((Datum) (X))

Definition at line 409 of file numeric.c.

Typedef Documentation

Int8TransTypeData

typedef struct Int8TransTypeData Int8TransTypeData

NumericAggState

typedef struct NumericAggState NumericAggState

NumericDigit

typedef int16 NumericDigit

Definition at line 101 of file numeric.c.

NumericSumAccum

typedef struct NumericSumAccum NumericSumAccum

NumericVar

typedef struct NumericVar NumericVar

PolyNumAggState

typedef NumericAggState PolyNumAggState

Definition at line 5548 of file numeric.c.

Function Documentation

accum_sum_add()

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

static

Definition at line 12196 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(), int8_avg_deserialize(), numeric_avg_deserialize(), numeric_deserialize(), and numeric_poly_deserialize().

accum_sum_carry()

static void accum_sum_carry ( NumericSumAccum *  accum )

static

Definition at line 12244 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 12474 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 int8_avg_combine(), numeric_avg_combine(), numeric_combine(), and numeric_poly_combine().

accum_sum_copy()

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

static

Definition at line 12457 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 int8_avg_combine(), numeric_avg_combine(), numeric_combine(), and numeric_poly_combine().

accum_sum_final()

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

static

Definition at line 12406 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(), int8_avg_serialize(), numeric_avg(), numeric_avg_serialize(), numeric_poly_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 12317 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 12180 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 11804 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 8435 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_opt_error(), 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 6957 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(), div_var_fast(), 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 7911 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 7996 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 10165 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 11726 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 11740 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 2509 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 8377 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_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 8392 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 1934 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);
    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 10095 of file numeric.c.

{
    NumericVar  q;
    NumericVar  r;
 
    init_var(&q);
    init_var(&r);
 
    /*
     * Use div_var_fast() to get an initial estimate for the integer quotient.
     * This might be inaccurate (per the warning in div_var_fast's comments),
     * but we can correct it below.
     */
    div_var_fast(var1, var2, &q, 0, 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_fast(), 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  )

static

Definition at line 9097 of file numeric.c.

{
    int         div_ndigits;
    int         res_ndigits;
    int         res_sign;
    int         res_weight;
    int         carry;
    int         borrow;
    int         divisor1;
    int         divisor2;
    NumericDigit *dividend;
    NumericDigit *divisor;
    NumericDigit *res_digits;
    int         i;
    int         j;
 
    /* copy these values into local vars for speed in inner loop */
    int         var1ndigits = var1->ndigits;
    int         var2ndigits = var2->ndigits;
 
    /*
     * 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;
    }
 
    /*
     * 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;
    /* 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++;
 
    /*
     * The working dividend normally requires res_ndigits + var2ndigits
     * digits, but make it at least var1ndigits so we can load all of var1
     * into it.  (There will be an additional digit dividend[0] in the
     * dividend space, but for consistency with Knuth's notation we don't
     * count that in div_ndigits.)
     */
    div_ndigits = res_ndigits + var2ndigits;
    div_ndigits = Max(div_ndigits, var1ndigits);
 
    /*
     * We need a workspace with room for the working dividend (div_ndigits+1
     * digits) plus room for the possibly-normalized divisor (var2ndigits
     * digits).  It is convenient also to have a zero at divisor[0] with the
     * actual divisor data in divisor[1 .. var2ndigits].  Transferring the
     * digits into the workspace also allows us to realloc the result (which
     * might be the same as either input var) before we begin the main loop.
     * Note that we use palloc0 to ensure that divisor[0], dividend[0], and
     * any additional dividend positions beyond var1ndigits, start out 0.
     */
    dividend = (NumericDigit *)
        palloc0((div_ndigits + var2ndigits + 2) * sizeof(NumericDigit));
    divisor = dividend + (div_ndigits + 1);
    memcpy(dividend + 1, var1->digits, var1ndigits * sizeof(NumericDigit));
    memcpy(divisor + 1, var2->digits, var2ndigits * sizeof(NumericDigit));
 
    /*
     * Now we can realloc the result to hold the generated quotient digits.
     */
    alloc_var(result, res_ndigits);
    res_digits = result->digits;
 
    /*
     * The full multiple-place algorithm is taken from Knuth volume 2,
     * Algorithm 4.3.1D.
     *
     * We need the first divisor digit to be >= NBASE/2.  If it isn't, make it
     * so by scaling up both the divisor and dividend by the factor "d".  (The
     * reason for allocating dividend[0] above is to leave room for possible
     * carry here.)
     */
    if (divisor[1] < HALF_NBASE)
    {
        int         d = NBASE / (divisor[1] + 1);
 
        carry = 0;
        for (i = var2ndigits; i > 0; i--)
        {
            carry += divisor[i] * d;
            divisor[i] = carry % NBASE;
            carry = carry / NBASE;
        }
        Assert(carry == 0);
        carry = 0;
        /* at this point only var1ndigits of dividend can be nonzero */
        for (i = var1ndigits; i >= 0; i--)
        {
            carry += dividend[i] * d;
            dividend[i] = carry % NBASE;
            carry = carry / NBASE;
        }
        Assert(carry == 0);
        Assert(divisor[1] >= HALF_NBASE);
    }
    /* First 2 divisor digits are used repeatedly in main loop */
    divisor1 = divisor[1];
    divisor2 = divisor[2];
 
    /*
     * Begin the main loop.  Each iteration of this loop produces the j'th
     * quotient digit by dividing dividend[j .. j + var2ndigits] by the
     * divisor; this is essentially the same as the common manual procedure
     * for long division.
     */
    for (j = 0; j < res_ndigits; j++)
    {
        /* Estimate quotient digit from the first two dividend digits */
        int         next2digits = dividend[j] * NBASE + dividend[j + 1];
        int         qhat;
 
        /*
         * If next2digits are 0, then quotient digit must be 0 and there's no
         * need to adjust the working dividend.  It's worth testing here to
         * fall out ASAP when processing trailing zeroes in a dividend.
         */
        if (next2digits == 0)
        {
            res_digits[j] = 0;
            continue;
        }
 
        if (dividend[j] == divisor1)
            qhat = NBASE - 1;
        else
            qhat = next2digits / divisor1;
 
        /*
         * Adjust quotient digit if it's too large.  Knuth proves that after
         * this step, the quotient digit will be either correct or just one
         * too large.  (Note: it's OK to use dividend[j+2] here because we
         * know the divisor length is at least 2.)
         */
        while (divisor2 * qhat >
               (next2digits - qhat * divisor1) * NBASE + dividend[j + 2])
            qhat--;
 
        /* As above, need do nothing more when quotient digit is 0 */
        if (qhat > 0)
        {
            NumericDigit *dividend_j = &dividend[j];
 
            /*
             * Multiply the divisor by qhat, and subtract that from the
             * working dividend.  The multiplication and subtraction are
             * folded together here, noting that qhat <= NBASE (since it might
             * be one too large), and so the intermediate result "tmp_result"
             * is in the range [-NBASE^2, NBASE - 1], and "borrow" is in the
             * range [0, NBASE].
             */
            borrow = 0;
            for (i = var2ndigits; i >= 0; i--)
            {
                int         tmp_result;
 
                tmp_result = dividend_j[i] - borrow - divisor[i] * qhat;
                borrow = (NBASE - 1 - tmp_result) / NBASE;
                dividend_j[i] = tmp_result + borrow * NBASE;
            }
 
            /*
             * If we got a borrow out of the top dividend digit, then indeed
             * qhat was one too large.  Fix it, and add back the divisor to
             * correct the working dividend.  (Knuth proves that this will
             * occur only about 3/NBASE of the time; hence, it's a good idea
             * to test this code with small NBASE to be sure this section gets
             * exercised.)
             */
            if (borrow)
            {
                qhat--;
                carry = 0;
                for (i = var2ndigits; i >= 0; i--)
                {
                    carry += dividend_j[i] + divisor[i];
                    if (carry >= NBASE)
                    {
                        dividend_j[i] = carry - NBASE;
                        carry = 1;
                    }
                    else
                    {
                        dividend_j[i] = carry;
                        carry = 0;
                    }
                }
                /* A carry should occur here to cancel the borrow above */
                Assert(carry == 1);
            }
        }
 
        /* And we're done with this quotient digit */
        res_digits[j] = qhat;
    }
 
    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_var_int(), NumericVar::dscale, ereport, errcode(), errmsg(), ERROR, HALF_NBASE, i, j, Max, NBASE, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, palloc0(), pfree(), round_var(), NumericVar::sign, strip_var(), trunc_var(), NumericVar::weight, and zero_var().

Referenced by compute_bucket(), get_str_from_var_sci(), mod_var(), numeric_div_opt_error(), numeric_div_trunc(), numeric_lcm(), numeric_stddev_internal(), and power_var_int().

div_var_fast()

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

static

Definition at line 9405 of file numeric.c.

{
    int         div_ndigits;
    int         load_ndigits;
    int         res_sign;
    int         res_weight;
    int        *div;
    int         qdigit;
    int         carry;
    int         maxdiv;
    int         newdig;
    NumericDigit *res_digits;
    double      fdividend,
                fdivisor,
                fdivisorinverse,
                fquotient;
    int         qi;
    int         i;
 
    /* 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;
 
    /*
     * First of all division by zero check; we must not be handed an
     * unnormalized divisor.
     */
    if (var2ndigits == 0 || var2digits[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;
    }
 
    /*
     * Determine the result sign, weight and number of digits to calculate
     */
    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: */
    div_ndigits = res_weight + 1 + (rscale + DEC_DIGITS - 1) / DEC_DIGITS;
    /* Add guard digits for roundoff error */
    div_ndigits += DIV_GUARD_DIGITS;
    if (div_ndigits < DIV_GUARD_DIGITS)
        div_ndigits = DIV_GUARD_DIGITS;
 
    /*
     * We do the arithmetic in an array "div[]" of signed int's.  Since
     * INT_MAX is noticeably larger than NBASE*NBASE, this gives us headroom
     * to avoid normalizing carries immediately.
     *
     * We start with div[] containing one zero digit followed by the
     * dividend's digits (plus appended zeroes to reach the desired precision
     * including guard digits).  Each step of the main loop computes an
     * (approximate) quotient digit and stores it into div[], removing one
     * position of dividend space.  A final pass of carry propagation takes
     * care of any mistaken quotient digits.
     *
     * Note that div[] doesn't necessarily contain all of the digits from the
     * dividend --- the desired precision plus guard digits might be less than
     * the dividend's precision.  This happens, for example, in the square
     * root algorithm, where we typically divide a 2N-digit number by an
     * N-digit number, and only require a result with N digits of precision.
     */
    div = (int *) palloc0((div_ndigits + 1) * sizeof(int));
    load_ndigits = Min(div_ndigits, var1ndigits);
    for (i = 0; i < load_ndigits; i++)
        div[i + 1] = var1digits[i];
 
    /*
     * We estimate each quotient digit using floating-point arithmetic, taking
     * the first four digits of the (current) dividend and divisor.  This must
     * be float to avoid overflow.  The quotient digits will generally be off
     * by no more than one from the exact answer.
     */
    fdivisor = (double) var2digits[0];
    for (i = 1; i < 4; i++)
    {
        fdivisor *= NBASE;
        if (i < var2ndigits)
            fdivisor += (double) var2digits[i];
    }
    fdivisorinverse = 1.0 / fdivisor;
 
    /*
     * maxdiv tracks the maximum possible absolute value of any div[] entry;
     * when this threatens to exceed INT_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 INT_MAX/NBASE + 1, so really we must
     * normalize when digits threaten to exceed INT_MAX - INT_MAX/NBASE - 1.
     *
     * To avoid overflow in maxdiv itself, it represents the max absolute
     * value divided by NBASE-1, ie, at the top of the loop it is known that
     * no div[] entry has an absolute value exceeding maxdiv * (NBASE-1).
     *
     * Actually, though, that holds good only for div[] entries after div[qi];
     * the adjustment done at the bottom of the loop may cause div[qi + 1] to
     * exceed the maxdiv limit, so that div[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 will go into div[qi]
     */
    for (qi = 0; qi < div_ndigits; qi++)
    {
        /* Approximate the current dividend value */
        fdividend = (double) div[qi];
        for (i = 1; i < 4; i++)
        {
            fdividend *= NBASE;
            if (qi + i <= div_ndigits)
                fdividend += (double) div[qi + i];
        }
        /* Compute the (approximate) quotient digit */
        fquotient = fdividend * fdivisorinverse;
        qdigit = (fquotient >= 0.0) ? ((int) fquotient) :
            (((int) fquotient) - 1);    /* truncate towards -infinity */
 
        if (qdigit != 0)
        {
            /* Do we need to normalize now? */
            maxdiv += abs(qdigit);
            if (maxdiv > (INT_MAX - INT_MAX / NBASE - 1) / (NBASE - 1))
            {
                /*
                 * Yes, do it.  Note that if var2ndigits is much smaller than
                 * div_ndigits, we can save a significant amount of effort
                 * here by noting that we only need to normalise those div[]
                 * entries touched where prior iterations subtracted multiples
                 * of the divisor.
                 */
                carry = 0;
                for (i = Min(qi + var2ndigits - 2, div_ndigits); i > qi; i--)
                {
                    newdig = div[i] + carry;
                    if (newdig < 0)
                    {
                        carry = -((-newdig - 1) / NBASE) - 1;
                        newdig -= carry * NBASE;
                    }
                    else if (newdig >= NBASE)
                    {
                        carry = newdig / NBASE;
                        newdig -= carry * NBASE;
                    }
                    else
                        carry = 0;
                    div[i] = newdig;
                }
                newdig = div[qi] + carry;
                div[qi] = newdig;
 
                /*
                 * All the div[] digits except possibly div[qi] are now in the
                 * range 0..NBASE-1.  We do not need to consider div[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 four dividend digits
                 */
                fdividend = (double) div[qi];
                for (i = 1; i < 4; i++)
                {
                    fdividend *= NBASE;
                    if (qi + i <= div_ndigits)
                        fdividend += (double) div[qi + i];
                }
                /* Compute the (approximate) quotient digit */
                fquotient = fdividend * fdivisorinverse;
                qdigit = (fquotient >= 0.0) ? ((int) fquotient) :
                    (((int) fquotient) - 1);    /* truncate towards -infinity */
                maxdiv += abs(qdigit);
            }
 
            /*
             * Subtract off the appropriate multiple of the divisor.
             *
             * The digits beyond div[qi] cannot overflow, because we know they
             * will fall within the maxdiv limit.  As for div[qi] itself, note
             * that qdigit is approximately trunc(div[qi] / vardigits[0]),
             * which would make the new value simply div[qi] mod vardigits[0].
             * The lower-order terms in qdigit can change this result by not
             * more than about twice INT_MAX/NBASE, 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.  We cast qdigit to NumericDigit
             * before multiplying to allow the compiler to generate more
             * efficient code (using 16-bit multiplication), which is safe
             * since we know that the quotient digit is off by at most one, so
             * there is no overflow risk.
             */
            if (qdigit != 0)
            {
                int         istop = Min(var2ndigits, div_ndigits - qi + 1);
                int        *div_qi = &div[qi];
 
                for (i = 0; i < istop; i++)
                    div_qi[i] -= ((NumericDigit) qdigit) * var2digits[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 div[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 div[qi + 1] will be
         * approximately a remainder mod (vardigits[0]*NBASE + vardigits[1]).
         * Accounting for the lower-order terms is a bit complicated but ends
         * up adding not much more than INT_MAX/NBASE to the possible range.
         * Thus, div[qi + 1] cannot overflow here, and in its role as div[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: div[qi] can be more than INT_MAX/NBASE, as
         * noted above, which means that the product div[qi] * NBASE *can*
         * overflow.  When that happens, adding it to div[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 in int64 arithmetic, but so far there appears no need.
         */
        div[qi + 1] += div[qi] * NBASE;
 
        div[qi] = qdigit;
    }
 
    /*
     * Approximate and store the last quotient digit (div[div_ndigits])
     */
    fdividend = (double) div[qi];
    for (i = 1; i < 4; i++)
        fdividend *= NBASE;
    fquotient = fdividend * fdivisorinverse;
    qdigit = (fquotient >= 0.0) ? ((int) fquotient) :
        (((int) fquotient) - 1);    /* truncate towards -infinity */
    div[qi] = qdigit;
 
    /*
     * Because the quotient digits might be off by one, some of them might be
     * -1 or NBASE at this point.  The represented value is correct in a
     * mathematical sense, but it doesn't look right.  We do a final carry
     * propagation pass to normalize the digits, which we combine with storing
     * the result digits into the output.  Note that this is still done at
     * full precision w/guard digits.
     */
    alloc_var(result, div_ndigits + 1);
    res_digits = result->digits;
    carry = 0;
    for (i = div_ndigits; i >= 0; i--)
    {
        newdig = div[i] + carry;
        if (newdig < 0)
        {
            carry = -((-newdig - 1) / NBASE) - 1;
            newdig -= carry * NBASE;
        }
        else if (newdig >= NBASE)
        {
            carry = newdig / NBASE;
            newdig -= carry * NBASE;
        }
        else
            carry = 0;
        res_digits[i] = newdig;
    }
    Assert(carry == 0);
 
    pfree(div);
 
    /*
     * Finally, round the result to the requested precision.
     */
    result->weight = res_weight;
    result->sign = res_sign;
 
    /* Round 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, Min, NBASE, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, palloc0(), pfree(), round_var(), NumericVar::sign, strip_var(), trunc_var(), NumericVar::weight, and zero_var().

Referenced by div_mod_var(), ln_var(), log_var(), 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 9769 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(), div_var_fast(), exp_var(), and ln_var().

do_numeric_accum()

static void do_numeric_accum ( NumericAggState *  state, Numeric  newval  )

static

Definition at line 4861 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 int2_accum(), int4_accum(), int8_accum(), int8_avg_accum(), numeric_accum(), and numeric_avg_accum().

do_numeric_discard()

static bool do_numeric_discard ( NumericAggState *  state, Numeric  newval  )

static

Definition at line 4931 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 int2_accum_inv(), int4_accum_inv(), int8_accum_inv(), int8_avg_accum_inv(), and numeric_accum_inv().

duplicate_numeric()

static Numeric duplicate_numeric ( Numeric  num )

static

Definition at line 7767 of file numeric.c.

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

References palloc(), res, and VARSIZE.

Referenced by numeric(), numeric_abs(), numeric_ceil(), numeric_exp(), numeric_floor(), numeric_inc(), numeric_ln(), numeric_mod_opt_error(), 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 10891 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 10762 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 4691 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, res, set_var_from_str(), snprintf, and val.

Referenced by JsonItemFromDatum().

float8_numeric()

Datum float8_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 4597 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, res, 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 10189 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 6973 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(), get_str_from_var_sci(), in_range_numeric_numeric(), int64_div_fast_to_numeric(), int64_to_numeric(), int8_avg_deserialize(), int8_avg_serialize(), ln_var(), log_var(), mod_var(), numeric(), numeric_add_opt_error(), numeric_avg(), numeric_avg_deserialize(), numeric_avg_serialize(), numeric_ceil(), numeric_deserialize(), numeric_div_opt_error(), 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_opt_error(), numeric_mul_opt_error(), numeric_poly_avg(), numeric_poly_deserialize(), numeric_poly_serialize(), numeric_poly_sum(), numeric_power(), numeric_recv(), numeric_round(), numeric_serialize(), numeric_sqrt(), numeric_stddev_internal(), numeric_sub_opt_error(), 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 10212 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 1703 of file numeric.c.

{
    return generate_series_step_numeric(fcinfo);
}

References generate_series_step_numeric().

generate_series_step_numeric()

Datum generate_series_step_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 1709 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 4140 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 7498 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 7651 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);
    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 2701 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 2781 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 2566 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 7455 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_step_numeric(), in_range_numeric_numeric(), numeric_abbrev_convert(), numeric_add_opt_error(), numeric_ceil(), numeric_div_opt_error(), numeric_div_trunc(), numeric_exp(), numeric_float8_no_overflow(), numeric_floor(), numeric_gcd(), numeric_inc(), numeric_int2(), numeric_int4_opt_error(), numeric_int8_opt_error(), numeric_is_integral(), numeric_lcm(), numeric_ln(), numeric_log(), numeric_min_scale(), numeric_mod_opt_error(), numeric_mul_opt_error(), numeric_normalize(), numeric_out(), numeric_out_sci(), numeric_pg_lsn(), numeric_power(), numeric_send(), numeric_sqrt(), numeric_sub_opt_error(), numeric_trim_scale(), and random_numeric().

int2_accum()

Datum int2_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5554 of file numeric.c.

{
    PolyNumAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) PG_GETARG_POINTER(0);
 
    /* Create the state data on the first call */
    if (state == NULL)
        state = makePolyNumAggState(fcinfo, true);
 
    if (!PG_ARGISNULL(1))
    {
#ifdef HAVE_INT128
        do_int128_accum(state, (int128) PG_GETARG_INT16(1));
#else
        do_numeric_accum(state, int64_to_numeric(PG_GETARG_INT16(1)));
#endif
    }
 
    PG_RETURN_POINTER(state);
}

References do_numeric_accum(), int64_to_numeric(), makePolyNumAggState, 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 5978 of file numeric.c.

{
    PolyNumAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) 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))
    {
#ifdef HAVE_INT128
        do_int128_discard(state, (int128) PG_GETARG_INT16(1));
#else
        /* Should never fail, all inputs have dscale 0 */
        if (!do_numeric_discard(state, int64_to_numeric(PG_GETARG_INT16(1))))
            elog(ERROR, "do_numeric_discard failed unexpectedly");
#endif
    }
 
    PG_RETURN_POINTER(state);
}

References do_numeric_discard(), elog, ERROR, int64_to_numeric(), 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 6661 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 6748 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 4548 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 6512 of file numeric.c.

{
    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);
    }
 
    /*
     * If we're invoked as an aggregate, we can cheat and modify our first
     * parameter in-place to avoid palloc overhead. If not, we need to return
     * the new value of the transition variable. (If int8 is pass-by-value,
     * then of course this is useless as well as incorrect, so just ifdef it
     * out.)
     */
#ifndef USE_FLOAT8_BYVAL        /* controls int8 too */
    if (AggCheckCallContext(fcinfo, NULL))
    {
        int64      *oldsum = (int64 *) PG_GETARG_POINTER(0);
 
        /* Leave the running sum unchanged in the new input is null */
        if (!PG_ARGISNULL(1))
            *oldsum = *oldsum + (int64) PG_GETARG_INT16(1);
 
        PG_RETURN_POINTER(oldsum);
    }
    else
#endif
    {
        int64       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 AggCheckCallContext(), newval, PG_ARGISNULL, PG_GETARG_INT16, PG_GETARG_INT64, PG_GETARG_POINTER, PG_RETURN_INT64, PG_RETURN_NULL, and PG_RETURN_POINTER.

int2int4_sum()

Datum int2int4_sum

(

PG_FUNCTION_ARGS

)

Definition at line 6831 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 5577 of file numeric.c.

{
    PolyNumAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) PG_GETARG_POINTER(0);
 
    /* Create the state data on the first call */
    if (state == NULL)
        state = makePolyNumAggState(fcinfo, true);
 
    if (!PG_ARGISNULL(1))
    {
#ifdef HAVE_INT128
        do_int128_accum(state, (int128) PG_GETARG_INT32(1));
#else
        do_numeric_accum(state, int64_to_numeric(PG_GETARG_INT32(1)));
#endif
    }
 
    PG_RETURN_POINTER(state);
}

References do_numeric_accum(), int64_to_numeric(), makePolyNumAggState, 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 6003 of file numeric.c.

{
    PolyNumAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) 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))
    {
#ifdef HAVE_INT128
        do_int128_discard(state, (int128) PG_GETARG_INT32(1));
#else
        /* Should never fail, all inputs have dscale 0 */
        if (!do_numeric_discard(state, int64_to_numeric(PG_GETARG_INT32(1))))
            elog(ERROR, "do_numeric_discard failed unexpectedly");
#endif
    }
 
    PG_RETURN_POINTER(state);
}

References do_numeric_discard(), elog, ERROR, int64_to_numeric(), 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 6689 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 6776 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 6717 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 4393 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 6561 of file numeric.c.

{
    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);
    }
 
    /*
     * If we're invoked as an aggregate, we can cheat and modify our first
     * parameter in-place to avoid palloc overhead. If not, we need to return
     * the new value of the transition variable. (If int8 is pass-by-value,
     * then of course this is useless as well as incorrect, so just ifdef it
     * out.)
     */
#ifndef USE_FLOAT8_BYVAL        /* controls int8 too */
    if (AggCheckCallContext(fcinfo, NULL))
    {
        int64      *oldsum = (int64 *) PG_GETARG_POINTER(0);
 
        /* Leave the running sum unchanged in the new input is null */
        if (!PG_ARGISNULL(1))
            *oldsum = *oldsum + (int64) PG_GETARG_INT32(1);
 
        PG_RETURN_POINTER(oldsum);
    }
    else
#endif
    {
        int64       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 AggCheckCallContext(), newval, PG_ARGISNULL, PG_GETARG_INT32, PG_GETARG_INT64, PG_GETARG_POINTER, PG_RETURN_INT64, PG_RETURN_NULL, and PG_RETURN_POINTER.

int64_div_fast_to_numeric()

Numeric int64_div_fast_to_numeric	(	int64	val1,
		int	log10val2
	)

Definition at line 4308 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)))
        {
#ifdef HAVE_INT128
            /* do the multiplication using 128-bit integers */
            int128      tmp;
 
            tmp = (int128) val1 * (int128) factor;
 
            int128_to_numericvar(tmp, &result);
#else
            /* do the multiplication using numerics */
            NumericVar  tmp;
 
            init_var(&tmp);
 
            int64_to_numericvar(val1, &result);
            int64_to_numericvar(factor, &tmp);
            mul_var(&result, &tmp, &result, 0);
 
            free_var(&tmp);
#endif
        }
        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, int64_to_numericvar(), lengthof, make_result(), mul_var(), pg_mul_s64_overflow(), res, 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 4287 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(), res, and val.

Referenced by cash_numeric(), executeItemOptUnwrapTarget(), executeKeyValueMethod(), extract_date(), gbt_numeric_penalty(), int2_accum(), int2_accum_inv(), int2_numeric(), int4_accum(), int4_accum_inv(), int4_numeric(), int8_accum(), int8_accum_inv(), int8_avg(), int8_avg_accum(), int8_avg_accum_inv(), 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 8108 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 = -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, 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 5600 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 6028 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 6804 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 5796 of file numeric.c.

{
    PolyNumAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) PG_GETARG_POINTER(0);
 
    /* Create the state data on the first call */
    if (state == NULL)
        state = makePolyNumAggState(fcinfo, false);
 
    if (!PG_ARGISNULL(1))
    {
#ifdef HAVE_INT128
        do_int128_accum(state, (int128) PG_GETARG_INT64(1));
#else
        do_numeric_accum(state, int64_to_numeric(PG_GETARG_INT64(1)));
#endif
    }
 
    PG_RETURN_POINTER(state);
}

References do_numeric_accum(), int64_to_numeric(), makePolyNumAggState, 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 6049 of file numeric.c.

{
    PolyNumAggState *state;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) 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))
    {
#ifdef HAVE_INT128
        do_int128_discard(state, (int128) PG_GETARG_INT64(1));
#else
        /* 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");
#endif
    }
 
    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_combine()

Datum int8_avg_combine

(

PG_FUNCTION_ARGS

)

Definition at line 5823 of file numeric.c.

{
    PolyNumAggState *state1;
    PolyNumAggState *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 : (PolyNumAggState *) PG_GETARG_POINTER(0);
    state2 = PG_ARGISNULL(1) ? NULL : (PolyNumAggState *) 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 = makePolyNumAggState(fcinfo, false);
        state1->N = state2->N;
 
#ifdef HAVE_INT128
        state1->sumX = state2->sumX;
#else
        accum_sum_copy(&state1->sumX, &state2->sumX);
#endif
        MemoryContextSwitchTo(old_context);
 
        PG_RETURN_POINTER(state1);
    }
 
    if (state2->N > 0)
    {
        state1->N += state2->N;
 
#ifdef HAVE_INT128
        state1->sumX += state2->sumX;
#else
        /* 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);
#endif
 
    }
    PG_RETURN_POINTER(state1);
}

References accum_sum_combine(), accum_sum_copy(), AggCheckCallContext(), elog, ERROR, makePolyNumAggState, MemoryContextSwitchTo(), NumericAggState::N, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_POINTER, and NumericAggState::sumX.

int8_avg_deserialize()

Datum int8_avg_deserialize

(

PG_FUNCTION_ARGS

)

Definition at line 5932 of file numeric.c.

{
    bytea      *sstate;
    PolyNumAggState *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 = makePolyNumAggStateCurrentContext(false);
 
    /* N */
    result->N = pq_getmsgint64(&buf);
 
    /* sumX */
    numericvar_deserialize(&buf, &tmp_var);
#ifdef HAVE_INT128
    numericvar_to_int128(&tmp_var, &result->sumX);
#else
    accum_sum_add(&result->sumX, &tmp_var);
#endif
 
    pq_getmsgend(&buf);
 
    free_var(&tmp_var);
 
    PG_RETURN_POINTER(result);
}

References accum_sum_add(), AggCheckCallContext(), buf, elog, ERROR, free_var(), init_var, initReadOnlyStringInfo(), makePolyNumAggStateCurrentContext, NumericAggState::N, numericvar_deserialize(), PG_GETARG_BYTEA_PP, PG_RETURN_POINTER, pq_getmsgend(), pq_getmsgint64(), NumericAggState::sumX, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

int8_avg_serialize()

Datum int8_avg_serialize

(

PG_FUNCTION_ARGS

)

Definition at line 5883 of file numeric.c.

{
    PolyNumAggState *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 = (PolyNumAggState *) PG_GETARG_POINTER(0);
 
    /*
     * If the platform supports int128 then sumX will be a 128 integer type.
     * Here we'll convert that into a numeric type so that the combine state
     * is in the same format for both int128 enabled machines and machines
     * which don't support that type. The logic here is that one day we might
     * like to send these over to another server for further processing and we
     * want a standard format to work with.
     */
 
    init_var(&tmp_var);
 
    pq_begintypsend(&buf);
 
    /* N */
    pq_sendint64(&buf, state->N);
 
    /* sumX */
#ifdef HAVE_INT128
    int128_to_numericvar(state->sumX, &tmp_var);
#else
    accum_sum_final(&state->sumX, &tmp_var);
#endif
    numericvar_serialize(&buf, &tmp_var);
 
    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(), and pq_sendint64().

int8_numeric()

Datum int8_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 4481 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 6613 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 916 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 10973 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_fast(result, &elem, result, local_rscale, true);
    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_fast(), 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 11091 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_fast(&ln_num, &ln_base, result, rscale, true);
 
    free_var(&ln_num);
    free_var(&ln_base);
}

References div_var_fast(), 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 907 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 7895 of file numeric.c.

{
    return make_result_opt_error(var, NULL);
}

References make_result_opt_error().

Referenced by float4_numeric(), float8_numeric(), generate_series_step_numeric(), int64_div_fast_to_numeric(), int64_to_numeric(), numeric(), numeric_add_opt_error(), numeric_avg(), numeric_ceil(), numeric_div_opt_error(), numeric_div_trunc(), numeric_exp(), numeric_fac(), numeric_floor(), numeric_gcd(), numeric_in(), numeric_inc(), numeric_lcm(), numeric_ln(), numeric_log(), numeric_mod_opt_error(), numeric_mul_opt_error(), numeric_poly_avg(), numeric_poly_sum(), numeric_power(), numeric_recv(), numeric_round(), numeric_sign(), numeric_sqrt(), numeric_stddev_internal(), numeric_sub_opt_error(), numeric_sum(), numeric_trim_scale(), numeric_trunc(), and random_numeric().

make_result_opt_error()

static Numeric make_result_opt_error ( const NumericVar *  var, bool *  have_error  )

static

Definition at line 7786 of file numeric.c.

{
    Numeric     result;
    NumericDigit *digits = var->digits;
    int         weight = var->weight;
    int         sign = var->sign;
    int         n;
    Size        len;
 
    if (have_error)
        *have_error = false;
 
    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)
    {
        if (have_error)
        {
            *have_error = true;
            return NULL;
        }
        else
        {
            ereport(ERROR,
                    (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, ereport, 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_opt_error(), numeric_div_opt_error(), numeric_in(), numeric_mod_opt_error(), numeric_mul_opt_error(), and numeric_sub_opt_error().

makeNumericAggState()

static NumericAggState* makeNumericAggState ( FunctionCallInfo  fcinfo, bool  calcSumX2  )

static

Definition at line 4821 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 4846 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 10066 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);
 
    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_opt_error().

mul_var()

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

static

Definition at line 8673 of file numeric.c.

{
    int         res_ndigits;
    int         res_sign;
    int         res_weight;
    int         maxdigits;
    int        *dig;
    int         carry;
    int         maxdig;
    int         newdig;
    int         var1ndigits;
    int         var2ndigits;
    NumericDigit *var1digits;
    NumericDigit *var2digits;
    NumericDigit *res_digits;
    int         i,
                i1,
                i2;
 
    /*
     * 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-4 digits and the exact result was requested, delegate to
     * mul_var_short() which uses a faster direct multiplication algorithm.
     */
    if (var1ndigits <= 4 && rscale == var1->dscale + var2->dscale)
    {
        mul_var_short(var1, var2, result);
        return;
    }
 
    /* Determine result sign and (maximum possible) weight */
    if (var1->sign == var2->sign)
        res_sign = NUMERIC_POS;
    else
        res_sign = NUMERIC_NEG;
    res_weight = var1->weight + var2->weight + 2;
 
    /*
     * Determine the number of result digits to compute.  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 one extra output digit in case
     * rscale-driven rounding produces a carry out of the highest exact digit.
     */
    res_ndigits = var1ndigits + var2ndigits + 1;
    maxdigits = res_weight + 1 + (rscale + DEC_DIGITS - 1) / DEC_DIGITS +
        MUL_GUARD_DIGITS;
    res_ndigits = Min(res_ndigits, maxdigits);
 
    if (res_ndigits < 3)
    {
        /* All input digits will be ignored; so result is zero */
        zero_var(result);
        result->dscale = rscale;
        return;
    }
 
    /*
     * We do the arithmetic in an array "dig[]" of signed int's.  Since
     * INT_MAX is noticeably larger than NBASE*NBASE, this gives us headroom
     * to avoid normalizing carries immediately.
     *
     * maxdig tracks the maximum possible value of any dig[] entry; when this
     * threatens to exceed INT_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
     * INT_MAX/NBASE, so really we must normalize when digits threaten to
     * exceed INT_MAX - INT_MAX/NBASE.
     *
     * To avoid overflow in maxdig itself, it actually represents the max
     * possible value divided by NBASE-1, ie, at the top of the loop it is
     * known that no dig[] entry exceeds maxdig * (NBASE-1).
     */
    dig = (int *) palloc0(res_ndigits * sizeof(int));
    maxdig = 0;
 
    /*
     * The least significant digits of var1 should be ignored if they don't
     * contribute directly to the first res_ndigits digits of the result that
     * we are computing.
     *
     * Digit i1 of var1 and digit i2 of var2 are multiplied and added to digit
     * i1+i2+2 of the accumulator array, so we need only consider digits of
     * var1 for which i1 <= res_ndigits - 3.
     */
    for (i1 = Min(var1ndigits - 1, res_ndigits - 3); i1 >= 0; i1--)
    {
        NumericDigit var1digit = var1digits[i1];
 
        if (var1digit == 0)
            continue;
 
        /* Time to normalize? */
        maxdig += var1digit;
        if (maxdig > (INT_MAX - INT_MAX / NBASE) / (NBASE - 1))
        {
            /* Yes, do it */
            carry = 0;
            for (i = res_ndigits - 1; i >= 0; i--)
            {
                newdig = dig[i] + carry;
                if (newdig >= NBASE)
                {
                    carry = newdig / NBASE;
                    newdig -= carry * NBASE;
                }
                else
                    carry = 0;
                dig[i] = newdig;
            }
            Assert(carry == 0);
            /* Reset maxdig to indicate new worst-case */
            maxdig = 1 + var1digit;
        }
 
        /*
         * Add the appropriate multiple of var2 into the accumulator.
         *
         * As above, digits of var2 can be ignored if they don't contribute,
         * so we only include digits for which i1+i2+2 < res_ndigits.
         *
         * This inner loop 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.
         */
        {
            int         i2limit = Min(var2ndigits, res_ndigits - i1 - 2);
            int        *dig_i1_2 = &dig[i1 + 2];
 
            for (i2 = 0; i2 < i2limit; i2++)
                dig_i1_2[i2] += var1digit * var2digits[i2];
        }
    }
 
    /*
     * Now we do a final carry propagation pass to normalize the result, which
     * we combine with storing the result digits into the output. 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_ndigits - 1; i >= 0; i--)
    {
        newdig = dig[i] + carry;
        if (newdig >= NBASE)
        {
            carry = newdig / NBASE;
            newdig -= carry * NBASE;
        }
        else
            carry = 0;
        res_digits[i] = newdig;
    }
    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, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, palloc0(), pfree(), 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(), int64_div_fast_to_numeric(), ln_var(), mod_var(), numeric_fac(), numeric_lcm(), numeric_mul_opt_error(), 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 8890 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;
    uint32      term;
 
    /* Check preconditions */
    Assert(var1ndigits >= 1);
    Assert(var1ndigits <= 4);
    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.
     */
    switch (var1ndigits)
    {
        case 1:
            /* ---------
             * 1-digit case:
             *      var1ndigits = 1
             *      var2ndigits >= 1
             *      res_ndigits = var2ndigits + 1
             * ----------
             */
            carry = 0;
            for (int i = res_ndigits - 2; i >= 0; i--)
            {
                term = (uint32) 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 = (uint32) var1digits[1] * var2digits[res_ndigits - 3];
            res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            /* remaining digits, except for the first two */
            for (int i = res_ndigits - 3; i >= 1; i--)
            {
                term = (uint32) var1digits[0] * var2digits[i] +
                    (uint32) var1digits[1] * var2digits[i - 1] + carry;
                res_digits[i + 1] = (NumericDigit) (term % NBASE);
                carry = term / NBASE;
            }
 
            /* first two digits */
            term = (uint32) var1digits[0] * var2digits[0] + carry;
            res_digits[1] = (NumericDigit) (term % NBASE);
            res_digits[0] = (NumericDigit) (term / NBASE);
            break;
 
        case 3:
            /* ---------
             * 3-digit case:
             *      var1ndigits = 3
             *      var2ndigits >= 3
             *      res_ndigits = var2ndigits + 3
             * ----------
             */
            /* last two result digits */
            term = (uint32) var1digits[2] * var2digits[res_ndigits - 4];
            res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = (uint32) var1digits[1] * var2digits[res_ndigits - 4] +
                (uint32) var1digits[2] * var2digits[res_ndigits - 5] + carry;
            res_digits[res_ndigits - 2] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            /* remaining digits, except for the first three */
            for (int i = res_ndigits - 4; i >= 2; i--)
            {
                term = (uint32) var1digits[0] * var2digits[i] +
                    (uint32) var1digits[1] * var2digits[i - 1] +
                    (uint32) var1digits[2] * var2digits[i - 2] + carry;
                res_digits[i + 1] = (NumericDigit) (term % NBASE);
                carry = term / NBASE;
            }
 
            /* first three digits */
            term = (uint32) var1digits[0] * var2digits[1] +
                (uint32) var1digits[1] * var2digits[0] + carry;
            res_digits[2] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = (uint32) var1digits[0] * var2digits[0] + carry;
            res_digits[1] = (NumericDigit) (term % NBASE);
            res_digits[0] = (NumericDigit) (term / NBASE);
            break;
 
        case 4:
            /* ---------
             * 4-digit case:
             *      var1ndigits = 4
             *      var2ndigits >= 4
             *      res_ndigits = var2ndigits + 4
             * ----------
             */
            /* last three result digits */
            term = (uint32) var1digits[3] * var2digits[res_ndigits - 5];
            res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = (uint32) var1digits[2] * var2digits[res_ndigits - 5] +
                (uint32) var1digits[3] * var2digits[res_ndigits - 6] + carry;
            res_digits[res_ndigits - 2] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = (uint32) var1digits[1] * var2digits[res_ndigits - 5] +
                (uint32) var1digits[2] * var2digits[res_ndigits - 6] +
                (uint32) var1digits[3] * var2digits[res_ndigits - 7] + carry;
            res_digits[res_ndigits - 3] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            /* remaining digits, except for the first four */
            for (int i = res_ndigits - 5; i >= 3; i--)
            {
                term = (uint32) var1digits[0] * var2digits[i] +
                    (uint32) var1digits[1] * var2digits[i - 1] +
                    (uint32) var1digits[2] * var2digits[i - 2] +
                    (uint32) var1digits[3] * var2digits[i - 3] + carry;
                res_digits[i + 1] = (NumericDigit) (term % NBASE);
                carry = term / NBASE;
            }
 
            /* first four digits */
            term = (uint32) var1digits[0] * var2digits[2] +
                (uint32) var1digits[1] * var2digits[1] +
                (uint32) var1digits[2] * var2digits[0] + carry;
            res_digits[3] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = (uint32) var1digits[0] * var2digits[1] +
                (uint32) var1digits[1] * var2digits[0] + carry;
            res_digits[2] = (NumericDigit) (term % NBASE);
            carry = term / NBASE;
 
            term = (uint32) 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, NumericVar::sign, strip_var(), and NumericVar::weight.

Referenced by mul_var().

numeric()

Datum numeric

(

PG_FUNCTION_ARGS

)

Definition at line 1246 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_MASK, 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 2112 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)
    {
#ifdef TRACE_SORT
        if (trace_sort)
            elog(LOG,
                 "numeric_abbrev: estimation ends at cardinality %f"
                 " after " INT64_FORMAT " values (%d rows)",
                 abbr_card, nss->input_count, memtupcount);
#endif
        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)
    {
#ifdef TRACE_SORT
        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);
#endif
        return true;
    }
 
#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG,
             "numeric_abbrev: cardinality %f"
             " after " INT64_FORMAT " values (%d rows)",
             abbr_card, nss->input_count, memtupcount);
#endif
 
    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 2050 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 ((Pointer) 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

Referenced by numeric_abbrev_convert().

numeric_abs()

Datum numeric_abs

(

PG_FUNCTION_ARGS

)

Definition at line 1393 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_short, NUMERIC_DSCALE, NUMERIC_INF_SIGN_MASK, NUMERIC_IS_SHORT, NUMERIC_IS_SPECIAL, NUMERIC_POS, NUMERIC_SHORT_SIGN_MASK, PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, and res.

Referenced by executeItemOptUnwrapTarget(), and numeric_absolute().

numeric_accum()

Datum numeric_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5024 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 5435 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 2852 of file numeric.c.

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

References numeric_add_opt_error(), PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, and res.

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

numeric_add_opt_error()

Numeric numeric_add_opt_error	(	Numeric	num1,
		Numeric	num2,
		bool *	have_error
	)

Definition at line 2871 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_opt_error(&result, have_error);
 
    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_opt_error(), NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, and res.

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 6132 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.

Referenced by numeric_poly_avg().

numeric_avg_accum()

Datum numeric_avg_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5116 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 5136 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 5260 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 5208 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 1647 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, PG_RETURN_NUMERIC, and res.

Referenced by executeItemOptUnwrapTarget().

numeric_cmp()

Datum numeric_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 2403 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(), and gin_numeric_cmp().

numeric_cmp_abbrev()

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

static

Definition at line 2207 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 5044 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 5374 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 3128 of file numeric.c.

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

References numeric_div_opt_error(), PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, and res.

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

numeric_div_opt_error()

Numeric numeric_div_opt_error	(	Numeric	num1,
		Numeric	num2,
		bool *	have_error
	)

Definition at line 3148 of file numeric.c.

{
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
    Numeric     res;
    int         rscale;
 
    if (have_error)
        *have_error = false;
 
    /*
     * 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:
                    if (have_error)
                    {
                        *have_error = true;
                        return NULL;
                    }
                    ereport(ERROR,
                            (errcode(ERRCODE_DIVISION_BY_ZERO),
                             errmsg("division by zero")));
                    break;
                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:
                    if (have_error)
                    {
                        *have_error = true;
                        return NULL;
                    }
                    ereport(ERROR,
                            (errcode(ERRCODE_DIVISION_BY_ZERO),
                             errmsg("division by zero")));
                    break;
                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);
 
    /*
     * If "have_error" is provided, check for division by zero here
     */
    if (have_error && (arg2.ndigits == 0 || arg2.digits[0] == 0))
    {
        *have_error = true;
        return NULL;
    }
 
    /*
     * Do the divide and return the result
     */
    div_var(&arg1, &arg2, &result, rscale, true);
 
    res = make_result_opt_error(&result, have_error);
 
    free_var(&result);
 
    return res;
}

References Assert, const_nan, const_ninf, const_pinf, const_zero, NumericVar::digits, div_var(), ereport, errcode(), errmsg(), ERROR, free_var(), init_var, init_var_from_num(), make_result(), make_result_opt_error(), NumericVar::ndigits, NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numeric_sign_internal(), res, 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 3263 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);
 
    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, PG_RETURN_NUMERIC, and res.

Referenced by numeric_half_rounded(), and numeric_truncated_divide().

numeric_eq()

Datum numeric_eq

(

PG_FUNCTION_ARGS

)

Definition at line 2419 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 3752 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, res, and val.

numeric_fac()

Datum numeric_fac

(

PG_FUNCTION_ARGS

)

Definition at line 3628 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, PG_RETURN_NUMERIC, and res.

numeric_fast_cmp()

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

static

Definition at line 2185 of file numeric.c.

{
    Numeric     nx = DatumGetNumeric(x);
    Numeric     ny = DatumGetNumeric(y);
    int         result;
 
    result = cmp_numerics(nx, ny);
 
    if ((Pointer) nx != DatumGetPointer(x))
        pfree(nx);
    if ((Pointer) 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 4726 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 4632 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 4665 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 1675 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, PG_RETURN_NUMERIC, and res.

Referenced by executeItemOptUnwrapTarget().

numeric_gcd()

Datum numeric_gcd

(

PG_FUNCTION_ARGS

)

Definition at line 3525 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, PG_RETURN_NUMERIC, and res.

numeric_ge()

Datum numeric_ge

(

PG_FUNCTION_ARGS

)

Definition at line 2464 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 2449 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 637 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;
        bool        have_error;
 
        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_opt_error(&value, &have_error);
 
        if (have_error)
            ereturn(escontext, (Datum) 0,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("value overflows numeric format")));
 
        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_opt_error(), NUMERIC_NEG, NUMERIC_POS, PG_GETARG_CSTRING, PG_GETARG_INT32, PG_GETARG_OID, PG_RETURN_NULL, PG_RETURN_NUMERIC, pg_strncasecmp(), res, 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_get_wal(), pg_stat_statements_internal(), 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 3441 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, PG_RETURN_NUMERIC, and res.

numeric_int2()

Datum numeric_int2

(

PG_FUNCTION_ARGS

)

Definition at line 4557 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 4451 of file numeric.c.

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

References numeric_int4_opt_error(), PG_GETARG_NUMERIC, and PG_RETURN_INT32.

Referenced by jsonb_int4(), and numeric_to_char().

numeric_int4_opt_error()

int32 numeric_int4_opt_error	(	Numeric	num,
		bool *	have_error
	)

Definition at line 4401 of file numeric.c.

{
    NumericVar  x;
    int32       result;
 
    if (have_error)
        *have_error = false;
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (have_error)
        {
            *have_error = true;
            return 0;
        }
        else
        {
            if (NUMERIC_IS_NAN(num))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot convert NaN to %s", "integer")));
            else
                ereport(ERROR,
                        (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))
    {
        if (have_error)
        {
            *have_error = true;
            return 0;
        }
        else
        {
            ereport(ERROR,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("integer out of range")));
        }
    }
 
    return result;
}

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

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

numeric_int8()

Datum numeric_int8

(

PG_FUNCTION_ARGS

)

Definition at line 4539 of file numeric.c.

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

References numeric_int8_opt_error(), PG_GETARG_NUMERIC, and PG_RETURN_INT64.

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

numeric_int8_opt_error()

int64 numeric_int8_opt_error	(	Numeric	num,
		bool *	have_error
	)

Definition at line 4489 of file numeric.c.

{
    NumericVar  x;
    int64       result;
 
    if (have_error)
        *have_error = false;
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (have_error)
        {
            *have_error = true;
            return 0;
        }
        else
        {
            if (NUMERIC_IS_NAN(num))
                ereport(ERROR,
                        (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                         errmsg("cannot convert NaN to %s", "bigint")));
            else
                ereport(ERROR,
                        (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))
    {
        if (have_error)
        {
            *have_error = true;
            return 0;
        }
        else
        {
            ereport(ERROR,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("bigint out of range")));
        }
    }
 
    return result;
}

References ereport, errcode(), errmsg(), ERROR, 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 862 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 873 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 851 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 3496 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 3568 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);
        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, res, set_var_from_var(), and NumericVar::sign.

numeric_le()

Datum numeric_le

(

PG_FUNCTION_ARGS

)

Definition at line 2494 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 3819 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, PG_RETURN_NUMERIC, and res.

numeric_log()

Datum numeric_log

(

PG_FUNCTION_ARGS

)

Definition at line 3868 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, PG_RETURN_NUMERIC, and res.

numeric_lt()

Datum numeric_lt

(

PG_FUNCTION_ARGS

)

Definition at line 2479 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 953 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 4191 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 3352 of file numeric.c.

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

References numeric_mod_opt_error(), PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, and res.

numeric_mod_opt_error()

Numeric numeric_mod_opt_error	(	Numeric	num1,
		Numeric	num2,
		bool *	have_error
	)

Definition at line 3372 of file numeric.c.

{
    Numeric     res;
    NumericVar  arg1;
    NumericVar  arg2;
    NumericVar  result;
 
    if (have_error)
        *have_error = false;
 
    /*
     * 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)
            {
                if (have_error)
                {
                    *have_error = true;
                    return NULL;
                }
                ereport(ERROR,
                        (errcode(ERRCODE_DIVISION_BY_ZERO),
                         errmsg("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);
 
    /*
     * If "have_error" is provided, check for division by zero here
     */
    if (have_error && (arg2.ndigits == 0 || arg2.digits[0] == 0))
    {
        *have_error = true;
        return NULL;
    }
 
    mod_var(&arg1, &arg2, &result);
 
    res = make_result_opt_error(&result, NULL);
 
    free_var(&result);
 
    return res;
}

References const_nan, NumericVar::digits, duplicate_numeric(), ereport, errcode(), errmsg(), ERROR, free_var(), init_var, init_var_from_num(), make_result(), make_result_opt_error(), mod_var(), NumericVar::ndigits, NUMERIC_IS_INF, NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, numeric_sign_internal(), and res.

Referenced by executeItemOptUnwrapTarget(), and numeric_mod().

numeric_mul()

Datum numeric_mul

(

PG_FUNCTION_ARGS

)

Definition at line 3007 of file numeric.c.

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

References numeric_mul_opt_error(), PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, and res.

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

numeric_mul_opt_error()

Numeric numeric_mul_opt_error	(	Numeric	num1,
		Numeric	num2,
		bool *	have_error
	)

Definition at line 3027 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_opt_error(&result, have_error);
 
    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_opt_error(), mul_var(), NUMERIC_DSCALE_MAX, NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numeric_sign_internal(), res, and round_var().

Referenced by executeItemOptUnwrapTarget(), and numeric_mul().

numeric_ne()

Datum numeric_ne

(

PG_FUNCTION_ARGS

)

Definition at line 2434 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 1026 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 816 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 992 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 4754 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 6102 of file numeric.c.

{
#ifdef HAVE_INT128
    PolyNumAggState *state;
    NumericVar  result;
    Datum       countd,
                sumd;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) 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));
#else
    return numeric_avg(fcinfo);
#endif
}

References DirectFunctionCall2, free_var(), init_var, int64_to_numeric(), make_result(), numeric_avg(), 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 5620 of file numeric.c.

{
    PolyNumAggState *state1;
    PolyNumAggState *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 : (PolyNumAggState *) PG_GETARG_POINTER(0);
    state2 = PG_ARGISNULL(1) ? NULL : (PolyNumAggState *) 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 = makePolyNumAggState(fcinfo, true);
        state1->N = state2->N;
 
#ifdef HAVE_INT128
        state1->sumX = state2->sumX;
        state1->sumX2 = state2->sumX2;
#else
        accum_sum_copy(&state1->sumX, &state2->sumX);
        accum_sum_copy(&state1->sumX2, &state2->sumX2);
#endif
 
        MemoryContextSwitchTo(old_context);
 
        PG_RETURN_POINTER(state1);
    }
 
    if (state2->N > 0)
    {
        state1->N += state2->N;
 
#ifdef HAVE_INT128
        state1->sumX += state2->sumX;
        state1->sumX2 += state2->sumX2;
#else
        /* 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);
#endif
 
    }
    PG_RETURN_POINTER(state1);
}

References accum_sum_combine(), accum_sum_copy(), AggCheckCallContext(), elog, ERROR, makePolyNumAggState, MemoryContextSwitchTo(), NumericAggState::N, PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_POINTER, NumericAggState::sumX, and NumericAggState::sumX2.

numeric_poly_deserialize()

Datum numeric_poly_deserialize

(

PG_FUNCTION_ARGS

)

Definition at line 5743 of file numeric.c.

{
    bytea      *sstate;
    PolyNumAggState *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 = makePolyNumAggStateCurrentContext(false);
 
    /* N */
    result->N = pq_getmsgint64(&buf);
 
    /* sumX */
    numericvar_deserialize(&buf, &tmp_var);
#ifdef HAVE_INT128
    numericvar_to_int128(&tmp_var, &result->sumX);
#else
    accum_sum_add(&result->sumX, &tmp_var);
#endif
 
    /* sumX2 */
    numericvar_deserialize(&buf, &tmp_var);
#ifdef HAVE_INT128
    numericvar_to_int128(&tmp_var, &result->sumX2);
#else
    accum_sum_add(&result->sumX2, &tmp_var);
#endif
 
    pq_getmsgend(&buf);
 
    free_var(&tmp_var);
 
    PG_RETURN_POINTER(result);
}

References accum_sum_add(), AggCheckCallContext(), buf, elog, ERROR, free_var(), init_var, initReadOnlyStringInfo(), makePolyNumAggStateCurrentContext, NumericAggState::N, numericvar_deserialize(), PG_GETARG_BYTEA_PP, PG_RETURN_POINTER, pq_getmsgend(), pq_getmsgint64(), NumericAggState::sumX, NumericAggState::sumX2, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

numeric_poly_serialize()

Datum numeric_poly_serialize

(

PG_FUNCTION_ARGS

)

Definition at line 5685 of file numeric.c.

{
    PolyNumAggState *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 = (PolyNumAggState *) PG_GETARG_POINTER(0);
 
    /*
     * If the platform supports int128 then sumX and sumX2 will be a 128 bit
     * integer type. Here we'll convert that into a numeric type so that the
     * combine state is in the same format for both int128 enabled machines
     * and machines which don't support that type. The logic here is that one
     * day we might like to send these over to another server for further
     * processing and we want a standard format to work with.
     */
 
    init_var(&tmp_var);
 
    pq_begintypsend(&buf);
 
    /* N */
    pq_sendint64(&buf, state->N);
 
    /* sumX */
#ifdef HAVE_INT128
    int128_to_numericvar(state->sumX, &tmp_var);
#else
    accum_sum_final(&state->sumX, &tmp_var);
#endif
    numericvar_serialize(&buf, &tmp_var);
 
    /* sumX2 */
#ifdef HAVE_INT128
    int128_to_numericvar(state->sumX2, &tmp_var);
#else
    accum_sum_final(&state->sumX2, &tmp_var);
#endif
    numericvar_serialize(&buf, &tmp_var);
 
    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(), and pq_sendint64().

numeric_poly_stddev_pop()

Datum numeric_poly_stddev_pop

(

PG_FUNCTION_ARGS

)

Definition at line 6471 of file numeric.c.

{
#ifdef HAVE_INT128
    PolyNumAggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) 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);
#else
    return numeric_stddev_pop(fcinfo);
#endif
}

References numeric_stddev_pop(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, PG_RETURN_NUMERIC, and res.

numeric_poly_stddev_samp()

Datum numeric_poly_stddev_samp

(

PG_FUNCTION_ARGS

)

Definition at line 6429 of file numeric.c.

{
#ifdef HAVE_INT128
    PolyNumAggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) 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);
#else
    return numeric_stddev_samp(fcinfo);
#endif
}

References numeric_stddev_samp(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, PG_RETURN_NUMERIC, and res.

numeric_poly_sum()

Datum numeric_poly_sum

(

PG_FUNCTION_ARGS

)

Definition at line 6074 of file numeric.c.

{
#ifdef HAVE_INT128
    PolyNumAggState *state;
    Numeric     res;
    NumericVar  result;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) 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);
#else
    return numeric_sum(fcinfo);
#endif
}

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

numeric_poly_var_pop()

Datum numeric_poly_var_pop

(

PG_FUNCTION_ARGS

)

Definition at line 6450 of file numeric.c.

{
#ifdef HAVE_INT128
    PolyNumAggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) 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);
#else
    return numeric_var_pop(fcinfo);
#endif
}

References numeric_var_pop(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, PG_RETURN_NUMERIC, and res.

numeric_poly_var_samp()

Datum numeric_poly_var_samp

(

PG_FUNCTION_ARGS

)

Definition at line 6408 of file numeric.c.

{
#ifdef HAVE_INT128
    PolyNumAggState *state;
    Numeric     res;
    bool        is_null;
 
    state = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) 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);
#else
    return numeric_var_samp(fcinfo);
#endif
}

References numeric_var_samp(), PG_ARGISNULL, PG_GETARG_POINTER, PG_RETURN_NULL, PG_RETURN_NUMERIC, and res.

numeric_power()

Datum numeric_power

(

PG_FUNCTION_ARGS

)

Definition at line 3939 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(), res, 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 1078 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(), res, trunc_var(), and value.

numeric_round()

Datum numeric_round

(

PG_FUNCTION_ARGS

)

Definition at line 1543 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, res, 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 4126 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 1163 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 5318 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 1510 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 1478 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_opt_error(), numeric_div_trunc(), numeric_log(), numeric_mod_opt_error(), numeric_mul_opt_error(), numeric_power(), and numeric_sign().

numeric_smaller()

Datum numeric_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 3474 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 2009 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 3680 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, res, and sqrt_var().

numeric_stddev_internal()

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

static

Definition at line 6210 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);  /* 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, res, select_div_scale(), sqrt_var(), and sub_var().

Referenced by 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 6345 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, PG_RETURN_NUMERIC, and res.

Referenced by numeric_poly_stddev_pop().

numeric_stddev_samp()

Datum numeric_stddev_samp

(

PG_FUNCTION_ARGS

)

Definition at line 6311 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, PG_RETURN_NUMERIC, and res.

Referenced by numeric_poly_stddev_samp().

numeric_sub()

Datum numeric_sub

(

PG_FUNCTION_ARGS

)

Definition at line 2929 of file numeric.c.

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

References numeric_sub_opt_error(), PG_GETARG_NUMERIC, PG_RETURN_NUMERIC, and res.

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

numeric_sub_opt_error()

Numeric numeric_sub_opt_error	(	Numeric	num1,
		Numeric	num2,
		bool *	have_error
	)

Definition at line 2949 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_opt_error(&result, have_error);
 
    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_opt_error(), NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, res, 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 6167 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.

Referenced by numeric_poly_sum().

numeric_support()

Datum numeric_support

(

PG_FUNCTION_ARGS

)

Definition at line 1196 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 4211 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, PG_RETURN_NUMERIC, and res.

numeric_trunc()

Datum numeric_trunc

(

PG_FUNCTION_ARGS

)

Definition at line 1597 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, res, 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 927 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 942 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 1420 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_short, 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, PG_RETURN_NUMERIC, and res.

Referenced by executeItemOptUnwrapTarget().

numeric_uplus()

Datum numeric_uplus

(

PG_FUNCTION_ARGS

)

Definition at line 1462 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 6328 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, PG_RETURN_NUMERIC, and res.

Referenced by numeric_poly_var_pop().

numeric_var_samp()

Datum numeric_var_samp

(

PG_FUNCTION_ARGS

)

Definition at line 6294 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, PG_RETURN_NUMERIC, and res.

Referenced by numeric_poly_var_samp().

numerictypmodin()

Datum numerictypmodin

(

PG_FUNCTION_ARGS

)

Definition at line 1324 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 1369 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, res, and snprintf.

numericvar_deserialize()

static void numericvar_deserialize ( StringInfo  buf, NumericVar *  var  )

static

Definition at line 7744 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 int8_avg_deserialize(), numeric_avg_deserialize(), numeric_deserialize(), and numeric_poly_deserialize().

numericvar_serialize()

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

static

Definition at line 7728 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 int8_avg_serialize(), numeric_avg_serialize(), numeric_poly_serialize(), and numeric_serialize().

numericvar_to_double_no_overflow()

static double numericvar_to_double_no_overflow ( const NumericVar *  var )

static

Definition at line 8345 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(), 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 4464 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_opt_error(), and width_bucket_numeric().

numericvar_to_int64()

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

static

Definition at line 8033 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_opt_error(), numericvar_to_int32(), and power_var().

numericvar_to_uint64()

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

static

Definition at line 8155 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 11518 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 11151 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 11313 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);
            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 = abs(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_fast(&const_one, result, result, rscale, true);
    else
        round_var(result, rscale);
}

References const_one, DEC_DIGITS, NumericVar::digits, div_var(), div_var_fast(), 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, 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 4232 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, random_var(), and res.

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 11543 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 11971 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_fast(), div_var_int(), exp_var(), mul_var(), numeric_mul_opt_error(), 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 9997 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_opt_error(), 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 7246 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 7424 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 7016 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 7472 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 10282 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, 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 12139 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_fast(), 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 11889 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 8552 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(), in_range_numeric_numeric(), ln_var(), mod_var(), numeric_stddev_internal(), numeric_sub_opt_error(), random_var(), and sqrt_var().

trunc_var()

static void trunc_var ( NumericVar *  var, int  rscale  )

static

Definition at line 12077 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_fast(), div_var_int(), floor_var(), numeric_recv(), and numeric_trunc().

width_bucket_numeric()

Datum width_bucket_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 1846 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(operand) ||
        NUMERIC_IS_SPECIAL(bound1) ||
        NUMERIC_IS_SPECIAL(bound2))
    {
        if (NUMERIC_IS_NAN(operand) ||
            NUMERIC_IS_NAN(bound1) ||
            NUMERIC_IS_NAN(bound2))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
                     errmsg("operand, lower bound, and upper bound cannot be NaN")));
        /* We allow "operand" to be infinite; cmp_numerics will cope */
        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 7219 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 6989 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_fast(), 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 429 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 456 of file numeric.c.

Referenced by float4_numeric(), float8_numeric(), numeric_add_opt_error(), numeric_avg(), numeric_div_opt_error(), numeric_div_trunc(), numeric_gcd(), numeric_in(), numeric_lcm(), numeric_log(), numeric_mod_opt_error(), numeric_mul_opt_error(), numeric_power(), numeric_sign(), numeric_stddev_internal(), numeric_sub_opt_error(), and numeric_sum().

const_ninf

const NumericVar const_ninf

static

Initial value:

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

Definition at line 462 of file numeric.c.

Referenced by float4_numeric(), float8_numeric(), numeric_add_opt_error(), numeric_avg(), numeric_div_opt_error(), numeric_div_trunc(), numeric_in(), numeric_mul_opt_error(), numeric_power(), numeric_sub_opt_error(), 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 426 of file numeric.c.

Referenced by ceil_var(), compute_bucket(), div_mod_var(), estimate_ln_dweight(), exp_var(), floor_var(), 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 425 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 453 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 447 of file numeric.c.

const_pinf

const NumericVar const_pinf

static

Initial value:

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

Definition at line 459 of file numeric.c.

Referenced by float4_numeric(), float8_numeric(), numeric_add_opt_error(), numeric_avg(), numeric_div_opt_error(), numeric_div_trunc(), numeric_in(), numeric_log(), numeric_mul_opt_error(), numeric_power(), numeric_sub_opt_error(), 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 433 of file numeric.c.

Referenced by ln_var().

const_two_data

const NumericDigit const_two_data[1] = {2}

static

Definition at line 432 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 422 of file numeric.c.

Referenced by accum_sum_final(), generate_series_step_numeric(), ln_var(), numeric_div_opt_error(), 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 421 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 443 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 437 of file numeric.c.

round_powers

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

static

Definition at line 466 of file numeric.c.

Referenced by round_var(), and trunc_var().