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 "optimizer/optimizer.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/guc.h"
#include "utils/numeric.h"
#include "utils/pg_lsn.h"
#include "utils/sortsupport.h"

Include dependency graph for numeric.c:

Go to the source code of this file.

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

Macros
#define	NBASE   10000
#define	HALF_NBASE   5000
#define	DEC_DIGITS   4 /* decimal digits per NBASE digit */
#define	MUL_GUARD_DIGITS   2 /* these are measured in NBASE digits */
#define	DIV_GUARD_DIGITS   4
#define	NBASE_SQR   (NBASE * NBASE)
#define	NUMERIC_SIGN_MASK   0xC000
#define	NUMERIC_POS   0x0000
#define	NUMERIC_NEG   0x4000
#define	NUMERIC_SHORT   0x8000
#define	NUMERIC_SPECIAL   0xC000
#define	NUMERIC_FLAGBITS(n)   ((n)->choice.n_header & NUMERIC_SIGN_MASK)
#define	NUMERIC_IS_SHORT(n)   (NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)
#define	NUMERIC_IS_SPECIAL(n)   (NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)
#define	NUMERIC_HDRSZ   (VARHDRSZ + sizeof(uint16) + sizeof(int16))
#define	NUMERIC_HDRSZ_SHORT   (VARHDRSZ + sizeof(uint16))
#define	NUMERIC_HEADER_IS_SHORT(n)   (((n)->choice.n_header & 0x8000) != 0)
#define	NUMERIC_HEADER_SIZE(n)
#define	NUMERIC_EXT_SIGN_MASK   0xF000 /* high bits plus NaN/Inf flag bits */
#define	NUMERIC_NAN   0xC000
#define	NUMERIC_PINF   0xD000
#define	NUMERIC_NINF   0xF000
#define	NUMERIC_INF_SIGN_MASK   0x2000
#define	NUMERIC_EXT_FLAGBITS(n)   ((n)->choice.n_header & NUMERIC_EXT_SIGN_MASK)
#define	NUMERIC_IS_NAN(n)   ((n)->choice.n_header == NUMERIC_NAN)
#define	NUMERIC_IS_PINF(n)   ((n)->choice.n_header == NUMERIC_PINF)
#define	NUMERIC_IS_NINF(n)   ((n)->choice.n_header == NUMERIC_NINF)
#define	NUMERIC_IS_INF(n)    (((n)->choice.n_header & ~NUMERIC_INF_SIGN_MASK) == NUMERIC_PINF)
#define	NUMERIC_SHORT_SIGN_MASK   0x2000
#define	NUMERIC_SHORT_DSCALE_MASK   0x1F80
#define	NUMERIC_SHORT_DSCALE_SHIFT   7
#define	NUMERIC_SHORT_DSCALE_MAX    (NUMERIC_SHORT_DSCALE_MASK >> NUMERIC_SHORT_DSCALE_SHIFT)
#define	NUMERIC_SHORT_WEIGHT_SIGN_MASK   0x0040
#define	NUMERIC_SHORT_WEIGHT_MASK   0x003F
#define	NUMERIC_SHORT_WEIGHT_MAX   NUMERIC_SHORT_WEIGHT_MASK
#define	NUMERIC_SHORT_WEIGHT_MIN   (-(NUMERIC_SHORT_WEIGHT_MASK+1))
#define	NUMERIC_DSCALE_MASK   0x3FFF
#define	NUMERIC_DSCALE_MAX   NUMERIC_DSCALE_MASK
#define	NUMERIC_SIGN(n)
#define	NUMERIC_DSCALE(n)
#define	NUMERIC_WEIGHT(n)
#define	NUMERIC_WEIGHT_MAX   PG_INT16_MAX
#define	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
#define	PRODSUM1(v1, i1, v2, i2)   ((v1)[(i1)] * (v2)[(i2)])
#define	PRODSUM2(v1, i1, v2, i2)   (PRODSUM1(v1,i1,v2,i2) + (v1)[(i1)+1] * (v2)[(i2)-1])
#define	PRODSUM3(v1, i1, v2, i2)   (PRODSUM2(v1,i1,v2,i2) + (v1)[(i1)+2] * (v2)[(i2)-2])
#define	PRODSUM4(v1, i1, v2, i2)   (PRODSUM3(v1,i1,v2,i2) + (v1)[(i1)+3] * (v2)[(i2)-3])
#define	PRODSUM5(v1, i1, v2, i2)   (PRODSUM4(v1,i1,v2,i2) + (v1)[(i1)+4] * (v2)[(i2)-4])
#define	PRODSUM6(v1, i1, v2, i2)   (PRODSUM5(v1,i1,v2,i2) + (v1)[(i1)+5] * (v2)[(i2)-5])

Typedefs
typedef int16	NumericDigit
typedef struct NumericVar	NumericVar
typedef struct NumericSumAccum	NumericSumAccum
typedef struct NumericAggState	NumericAggState
typedef 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, bool exact)
static void	div_var_int (const NumericVar *var, int ival, int ival_weight, NumericVar *result, int rscale, bool round)
static int	select_div_scale (const NumericVar *var1, const NumericVar *var2)
static void	mod_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	div_mod_var (const NumericVar *var1, const NumericVar *var2, NumericVar *quot, NumericVar *rem)
static void	ceil_var (const NumericVar *var, NumericVar *result)
static void	floor_var (const NumericVar *var, NumericVar *result)
static void	gcd_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	sqrt_var (const NumericVar *arg, NumericVar *result, int rscale)
static void	exp_var (const NumericVar *arg, NumericVar *result, int rscale)
static int	estimate_ln_dweight (const NumericVar *var)
static void	ln_var (const NumericVar *arg, NumericVar *result, int rscale)
static void	log_var (const NumericVar *base, const NumericVar *num, NumericVar *result)
static void	power_var (const NumericVar *base, const NumericVar *exp, NumericVar *result)
static void	power_var_int (const NumericVar *base, int exp, int exp_dscale, NumericVar *result)
static void	power_ten_int (int exp, NumericVar *result)
static void	random_var (pg_prng_state *state, const NumericVar *rmin, const NumericVar *rmax, NumericVar *result)
static int	cmp_abs (const NumericVar *var1, const NumericVar *var2)
static int	cmp_abs_common (const NumericDigit *var1digits, int var1ndigits, int var1weight, const NumericDigit *var2digits, int var2ndigits, int var2weight)
static void	add_abs (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	sub_abs (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	round_var (NumericVar *var, int rscale)
static void	trunc_var (NumericVar *var, int rscale)
static void	strip_var (NumericVar *var)
static void	compute_bucket (Numeric operand, Numeric bound1, Numeric bound2, const NumericVar *count_var, NumericVar *result_var)
static void	accum_sum_add (NumericSumAccum *accum, const NumericVar *val)
static void	accum_sum_rescale (NumericSumAccum *accum, const NumericVar *val)
static void	accum_sum_carry (NumericSumAccum *accum)
static void	accum_sum_reset (NumericSumAccum *accum)
static void	accum_sum_final (NumericSumAccum *accum, NumericVar *result)
static void	accum_sum_copy (NumericSumAccum *dst, NumericSumAccum *src)
static void	accum_sum_combine (NumericSumAccum *accum, NumericSumAccum *accum2)
Datum	numeric_in (PG_FUNCTION_ARGS)
Datum	numeric_out (PG_FUNCTION_ARGS)
bool	numeric_is_nan (Numeric num)
bool	numeric_is_inf (Numeric num)
static bool	numeric_is_integral (Numeric num)
static int32	make_numeric_typmod (int precision, int scale)
static bool	is_valid_numeric_typmod (int32 typmod)
static int	numeric_typmod_precision (int32 typmod)
static int	numeric_typmod_scale (int32 typmod)
int32	numeric_maximum_size (int32 typmod)
char *	numeric_out_sci (Numeric num, int scale)
char *	numeric_normalize (Numeric num)
Datum	numeric_recv (PG_FUNCTION_ARGS)
Datum	numeric_send (PG_FUNCTION_ARGS)
Datum	numeric_support (PG_FUNCTION_ARGS)
Datum	numeric (PG_FUNCTION_ARGS)
Datum	numerictypmodin (PG_FUNCTION_ARGS)
Datum	numerictypmodout (PG_FUNCTION_ARGS)
Datum	numeric_abs (PG_FUNCTION_ARGS)
Datum	numeric_uminus (PG_FUNCTION_ARGS)
Datum	numeric_uplus (PG_FUNCTION_ARGS)
static int	numeric_sign_internal (Numeric num)
Datum	numeric_sign (PG_FUNCTION_ARGS)
Datum	numeric_round (PG_FUNCTION_ARGS)
Datum	numeric_trunc (PG_FUNCTION_ARGS)
Datum	numeric_ceil (PG_FUNCTION_ARGS)
Datum	numeric_floor (PG_FUNCTION_ARGS)
Datum	generate_series_numeric (PG_FUNCTION_ARGS)
Datum	generate_series_step_numeric (PG_FUNCTION_ARGS)
Datum	generate_series_numeric_support (PG_FUNCTION_ARGS)
Datum	width_bucket_numeric (PG_FUNCTION_ARGS)
Datum	numeric_sortsupport (PG_FUNCTION_ARGS)
Datum	numeric_cmp (PG_FUNCTION_ARGS)
Datum	numeric_eq (PG_FUNCTION_ARGS)
Datum	numeric_ne (PG_FUNCTION_ARGS)
Datum	numeric_gt (PG_FUNCTION_ARGS)
Datum	numeric_ge (PG_FUNCTION_ARGS)
Datum	numeric_lt (PG_FUNCTION_ARGS)
Datum	numeric_le (PG_FUNCTION_ARGS)
Datum	in_range_numeric_numeric (PG_FUNCTION_ARGS)
Datum	hash_numeric (PG_FUNCTION_ARGS)
Datum	hash_numeric_extended (PG_FUNCTION_ARGS)
Datum	numeric_add (PG_FUNCTION_ARGS)
Numeric	numeric_add_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 413 of file numeric.c.

DEC_DIGITS

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

Definition at line 98 of file numeric.c.

digitbuf_alloc

#define digitbuf_alloc

(

ndigits

)

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

Definition at line 486 of file numeric.c.

digitbuf_free

#define digitbuf_free

(

buf

)

Value:

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

Definition at line 488 of file numeric.c.

DIV_GUARD_DIGITS

#define DIV_GUARD_DIGITS   4

Definition at line 100 of file numeric.c.

dump_numeric

#define dump_numeric	(		s,
			n
	)

Definition at line 482 of file numeric.c.

dump_var

#define dump_var	(		s,
			v
	)

Definition at line 483 of file numeric.c.

HALF_NBASE

#define HALF_NBASE   5000

Definition at line 97 of file numeric.c.

init_var

#define init_var

(

v

)

memset(v, 0, sizeof(NumericVar))

Definition at line 494 of file numeric.c.

makePolyNumAggState

#define makePolyNumAggState   makeNumericAggState

Definition at line 5663 of file numeric.c.

makePolyNumAggStateCurrentContext

#define makePolyNumAggStateCurrentContext   makeNumericAggStateCurrentContext

Definition at line 5664 of file numeric.c.

MUL_GUARD_DIGITS

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

Definition at line 99 of file numeric.c.

NA_TOTAL_COUNT

#define NA_TOTAL_COUNT

(

na

)

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

Definition at line 4927 of file numeric.c.

NBASE

#define NBASE   10000

Definition at line 96 of file numeric.c.

NBASE_SQR

#define NBASE_SQR   (NBASE * NBASE)

Definition at line 105 of file numeric.c.

NUMERIC_ABBREV_BITS

#define NUMERIC_ABBREV_BITS   (SIZEOF_DATUM * BITS_PER_BYTE)

Definition at line 404 of file numeric.c.

NUMERIC_ABBREV_NAN

#define NUMERIC_ABBREV_NAN   NumericAbbrevGetDatum(PG_INT32_MIN)

Definition at line 414 of file numeric.c.

NUMERIC_ABBREV_NINF

#define NUMERIC_ABBREV_NINF   NumericAbbrevGetDatum(PG_INT32_MAX)

Definition at line 416 of file numeric.c.

NUMERIC_ABBREV_PINF

#define NUMERIC_ABBREV_PINF   NumericAbbrevGetDatum(-PG_INT32_MAX)

Definition at line 415 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 500 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 496 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 245 of file numeric.c.

NUMERIC_DSCALE_MASK

#define NUMERIC_DSCALE_MASK   0x3FFF

Definition at line 236 of file numeric.c.

NUMERIC_DSCALE_MAX

#define NUMERIC_DSCALE_MAX   NUMERIC_DSCALE_MASK

Definition at line 237 of file numeric.c.

NUMERIC_EXT_FLAGBITS

#define NUMERIC_EXT_FLAGBITS

(

n

)

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

Definition at line 205 of file numeric.c.

NUMERIC_EXT_SIGN_MASK

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

Definition at line 199 of file numeric.c.

NUMERIC_FLAGBITS

#define NUMERIC_FLAGBITS

(

n

)

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

Definition at line 173 of file numeric.c.

NUMERIC_HDRSZ

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

Definition at line 177 of file numeric.c.

NUMERIC_HDRSZ_SHORT

#define NUMERIC_HDRSZ_SHORT   (VARHDRSZ + sizeof(uint16))

Definition at line 178 of file numeric.c.

NUMERIC_HEADER_IS_SHORT

#define NUMERIC_HEADER_IS_SHORT

(

n

)

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

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

NUMERIC_INF_SIGN_MASK

#define NUMERIC_INF_SIGN_MASK   0x2000

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

NUMERIC_IS_NAN

#define NUMERIC_IS_NAN

(

n

)

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

Definition at line 206 of file numeric.c.

NUMERIC_IS_NINF

#define NUMERIC_IS_NINF

(

n

)

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

Definition at line 208 of file numeric.c.

NUMERIC_IS_PINF

#define NUMERIC_IS_PINF

(

n

)

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

Definition at line 207 of file numeric.c.

NUMERIC_IS_SHORT

#define NUMERIC_IS_SHORT

(

n

)

(NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)

Definition at line 174 of file numeric.c.

NUMERIC_IS_SPECIAL

#define NUMERIC_IS_SPECIAL

(

n

)

(NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)

Definition at line 175 of file numeric.c.

NUMERIC_NAN

#define NUMERIC_NAN   0xC000

Definition at line 200 of file numeric.c.

NUMERIC_NDIGITS

#define NUMERIC_NDIGITS

(

num

)

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

Definition at line 498 of file numeric.c.

NUMERIC_NEG

#define NUMERIC_NEG   0x4000

Definition at line 169 of file numeric.c.

NUMERIC_NINF

#define NUMERIC_NINF   0xF000

Definition at line 202 of file numeric.c.

NUMERIC_PINF

#define NUMERIC_PINF   0xD000

Definition at line 201 of file numeric.c.

NUMERIC_POS

#define NUMERIC_POS   0x0000

Definition at line 168 of file numeric.c.

NUMERIC_SHORT

#define NUMERIC_SHORT   0x8000

Definition at line 170 of file numeric.c.

NUMERIC_SHORT_DSCALE_MASK

#define NUMERIC_SHORT_DSCALE_MASK   0x1F80

Definition at line 217 of file numeric.c.

NUMERIC_SHORT_DSCALE_MAX

#define NUMERIC_SHORT_DSCALE_MAX    (NUMERIC_SHORT_DSCALE_MASK >> NUMERIC_SHORT_DSCALE_SHIFT)

Definition at line 219 of file numeric.c.

NUMERIC_SHORT_DSCALE_SHIFT

#define NUMERIC_SHORT_DSCALE_SHIFT   7

Definition at line 218 of file numeric.c.

NUMERIC_SHORT_SIGN_MASK

#define NUMERIC_SHORT_SIGN_MASK   0x2000

Definition at line 216 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MASK

#define NUMERIC_SHORT_WEIGHT_MASK   0x003F

Definition at line 222 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MAX

#define NUMERIC_SHORT_WEIGHT_MAX   NUMERIC_SHORT_WEIGHT_MASK

Definition at line 223 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MIN

#define NUMERIC_SHORT_WEIGHT_MIN   (-(NUMERIC_SHORT_WEIGHT_MASK+1))

Definition at line 224 of file numeric.c.

NUMERIC_SHORT_WEIGHT_SIGN_MASK

#define NUMERIC_SHORT_WEIGHT_SIGN_MASK   0x0040

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

NUMERIC_SIGN_MASK

#define NUMERIC_SIGN_MASK   0xC000

Definition at line 167 of file numeric.c.

NUMERIC_SPECIAL

#define NUMERIC_SPECIAL   0xC000

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

NUMERIC_WEIGHT_MAX

#define NUMERIC_WEIGHT_MAX   PG_INT16_MAX

Definition at line 260 of file numeric.c.

NumericAbbrevGetDatum

#define NumericAbbrevGetDatum

(

X

)

((Datum) (X))

Definition at line 412 of file numeric.c.

PRODSUM1

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

PRODSUM2

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

PRODSUM3

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

PRODSUM4

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

PRODSUM5

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

PRODSUM6

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

Typedef Documentation

Int8TransTypeData

typedef struct Int8TransTypeData Int8TransTypeData

NumericAggState

typedef struct NumericAggState NumericAggState

NumericDigit

typedef int16 NumericDigit

Definition at line 102 of file numeric.c.

NumericSumAccum

typedef struct NumericSumAccum NumericSumAccum

NumericVar

typedef struct NumericVar NumericVar

PolyNumAggState

typedef NumericAggState PolyNumAggState

Definition at line 5662 of file numeric.c.

Function Documentation

accum_sum_add()

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

static

Definition at line 12333 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 12381 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 12611 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 12594 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 12543 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 12454 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 12317 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 11941 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 8549 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 7071 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(), 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 8025 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 8110 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 10302 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 11863 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 11877 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 2623 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 8491 of file numeric.c.

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

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

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

cmp_var_common()

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

static

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

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

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

Referenced by width_bucket_numeric().

div_mod_var()

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

static

Definition at line 10232 of file numeric.c.

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

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

Referenced by sqrt_var().

div_var()

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

static

Definition at line 9365 of file numeric.c.

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

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

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

div_var_int()

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

static

Definition at line 9906 of file numeric.c.

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

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

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

do_numeric_accum()

static void do_numeric_accum ( NumericAggState *  state, Numeric  newval  )

static

Definition at line 4975 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 5045 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 7881 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 11028 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 10899 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 4805 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 4711 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 10326 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 7087 of file numeric.c.

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

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

Referenced by accum_sum_combine(), ceil_var(), compute_bucket(), div_mod_var(), estimate_ln_dweight(), exp_var(), float4_numeric(), float8_numeric(), floor_var(), gcd_var(), generate_series_numeric_support(), get_str_from_var_sci(), in_range_numeric_numeric(), int64_div_fast_to_numeric(), int64_to_numeric(), 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 10349 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_numeric_support()

Datum generate_series_numeric_support

(

PG_FUNCTION_ARGS

)

Definition at line 1835 of file numeric.c.

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

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

generate_series_step_numeric()

Datum generate_series_step_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 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 4254 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 7612 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 7765 of file numeric.c.

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

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

Referenced by numeric_out_sci().

hash_numeric()

Datum hash_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 2815 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 2895 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 2680 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 7569 of file numeric.c.

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

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

Referenced by compute_bucket(), do_numeric_accum(), do_numeric_discard(), generate_series_numeric_support(), generate_series_step_numeric(), in_range_numeric_numeric(), numeric_abbrev_convert(), numeric_add_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 5668 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 6092 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 6775 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 6862 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 4662 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 6626 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 6945 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 5691 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 6117 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 6803 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 6890 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 6831 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 4507 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 6675 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 4422 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 4401 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 8222 of file numeric.c.

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

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

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

int8_accum()

Datum int8_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5714 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 6142 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 6918 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 5910 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 6163 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 5937 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;