numeric.c File Reference

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

Include dependency graph for numeric.c:

Go to the source code of this file.

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

Macros
#define	NBASE   10000
#define	HALF_NBASE   5000
#define	DEC_DIGITS   4 /* decimal digits per NBASE digit */
#define	MUL_GUARD_DIGITS   2 /* these are measured in NBASE digits */
#define	DIV_GUARD_DIGITS   4
#define	NUMERIC_SIGN_MASK   0xC000
#define	NUMERIC_POS   0x0000
#define	NUMERIC_NEG   0x4000
#define	NUMERIC_SHORT   0x8000
#define	NUMERIC_SPECIAL   0xC000
#define	NUMERIC_FLAGBITS(n)   ((n)->choice.n_header & NUMERIC_SIGN_MASK)
#define	NUMERIC_IS_SHORT(n)   (NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)
#define	NUMERIC_IS_SPECIAL(n)   (NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)
#define	NUMERIC_HDRSZ   (VARHDRSZ + sizeof(uint16) + sizeof(int16))
#define	NUMERIC_HDRSZ_SHORT   (VARHDRSZ + sizeof(uint16))
#define	NUMERIC_HEADER_IS_SHORT(n)   (((n)->choice.n_header & 0x8000) != 0)
#define	NUMERIC_HEADER_SIZE(n)
#define	NUMERIC_EXT_SIGN_MASK   0xF000 /* high bits plus NaN/Inf flag bits */
#define	NUMERIC_NAN   0xC000
#define	NUMERIC_PINF   0xD000
#define	NUMERIC_NINF   0xF000
#define	NUMERIC_INF_SIGN_MASK   0x2000
#define	NUMERIC_EXT_FLAGBITS(n)   ((n)->choice.n_header & NUMERIC_EXT_SIGN_MASK)
#define	NUMERIC_IS_NAN(n)   ((n)->choice.n_header == NUMERIC_NAN)
#define	NUMERIC_IS_PINF(n)   ((n)->choice.n_header == NUMERIC_PINF)
#define	NUMERIC_IS_NINF(n)   ((n)->choice.n_header == NUMERIC_NINF)
#define	NUMERIC_IS_INF(n)    (((n)->choice.n_header & ~NUMERIC_INF_SIGN_MASK) == NUMERIC_PINF)
#define	NUMERIC_SHORT_SIGN_MASK   0x2000
#define	NUMERIC_SHORT_DSCALE_MASK   0x1F80
#define	NUMERIC_SHORT_DSCALE_SHIFT   7
#define	NUMERIC_SHORT_DSCALE_MAX    (NUMERIC_SHORT_DSCALE_MASK >> NUMERIC_SHORT_DSCALE_SHIFT)
#define	NUMERIC_SHORT_WEIGHT_SIGN_MASK   0x0040
#define	NUMERIC_SHORT_WEIGHT_MASK   0x003F
#define	NUMERIC_SHORT_WEIGHT_MAX   NUMERIC_SHORT_WEIGHT_MASK
#define	NUMERIC_SHORT_WEIGHT_MIN   (-(NUMERIC_SHORT_WEIGHT_MASK+1))
#define	NUMERIC_DSCALE_MASK   0x3FFF
#define	NUMERIC_DSCALE_MAX   NUMERIC_DSCALE_MASK
#define	NUMERIC_SIGN(n)
#define	NUMERIC_DSCALE(n)
#define	NUMERIC_WEIGHT(n)
#define	NUMERIC_ABBREV_BITS   (SIZEOF_DATUM * BITS_PER_BYTE)
#define	NumericAbbrevGetDatum(X)   ((Datum) (X))
#define	DatumGetNumericAbbrev(X)   ((int32) (X))
#define	NUMERIC_ABBREV_NAN   NumericAbbrevGetDatum(PG_INT32_MIN)
#define	NUMERIC_ABBREV_PINF   NumericAbbrevGetDatum(-PG_INT32_MAX)
#define	NUMERIC_ABBREV_NINF   NumericAbbrevGetDatum(PG_INT32_MAX)
#define	dump_numeric(s, n)
#define	dump_var(s, v)
#define	digitbuf_alloc(ndigits)    ((NumericDigit *) palloc((ndigits) * sizeof(NumericDigit)))
#define	digitbuf_free(buf)
#define	init_var(v)   memset(v, 0, sizeof(NumericVar))
#define	NUMERIC_DIGITS(num)
#define	NUMERIC_NDIGITS(num)    ((VARSIZE(num) - NUMERIC_HEADER_SIZE(num)) / sizeof(NumericDigit))
#define	NUMERIC_CAN_BE_SHORT(scale, weight)
#define	NA_TOTAL_COUNT(na)    ((na)->N + (na)->NaNcount + (na)->pInfcount + (na)->nInfcount)
#define	makePolyNumAggState   makeNumericAggState
#define	makePolyNumAggStateCurrentContext   makeNumericAggStateCurrentContext

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

Functions
static void	alloc_var (NumericVar *var, int ndigits)
static void	free_var (NumericVar *var)
static void	zero_var (NumericVar *var)
static bool	set_var_from_str (const char *str, const char *cp, NumericVar *dest, const char **endptr, Node *escontext)
static bool	set_var_from_non_decimal_integer_str (const char *str, const char *cp, int sign, int base, NumericVar *dest, const char **endptr, Node *escontext)
static void	set_var_from_num (Numeric num, NumericVar *dest)
static void	init_var_from_num (Numeric num, NumericVar *dest)
static void	set_var_from_var (const NumericVar *value, NumericVar *dest)
static char *	get_str_from_var (const NumericVar *var)
static char *	get_str_from_var_sci (const NumericVar *var, int rscale)
static void	numericvar_serialize (StringInfo buf, const NumericVar *var)
static void	numericvar_deserialize (StringInfo buf, NumericVar *var)
static Numeric	duplicate_numeric (Numeric num)
static Numeric	make_result (const NumericVar *var)
static Numeric	make_result_opt_error (const NumericVar *var, bool *have_error)
static bool	apply_typmod (NumericVar *var, int32 typmod, Node *escontext)
static bool	apply_typmod_special (Numeric num, int32 typmod, Node *escontext)
static bool	numericvar_to_int32 (const NumericVar *var, int32 *result)
static bool	numericvar_to_int64 (const NumericVar *var, int64 *result)
static void	int64_to_numericvar (int64 val, NumericVar *var)
static bool	numericvar_to_uint64 (const NumericVar *var, uint64 *result)
static double	numericvar_to_double_no_overflow (const NumericVar *var)
static Datum	numeric_abbrev_convert (Datum original_datum, SortSupport ssup)
static bool	numeric_abbrev_abort (int memtupcount, SortSupport ssup)
static int	numeric_fast_cmp (Datum x, Datum y, SortSupport ssup)
static int	numeric_cmp_abbrev (Datum x, Datum y, SortSupport ssup)
static Datum	numeric_abbrev_convert_var (const NumericVar *var, NumericSortSupport *nss)
static int	cmp_numerics (Numeric num1, Numeric num2)
static int	cmp_var (const NumericVar *var1, const NumericVar *var2)
static int	cmp_var_common (const NumericDigit *var1digits, int var1ndigits, int var1weight, int var1sign, const NumericDigit *var2digits, int var2ndigits, int var2weight, int var2sign)
static void	add_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	sub_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	mul_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale)
static void	div_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale, bool round)
static void	div_var_fast (const NumericVar *var1, const NumericVar *var2, NumericVar *result, int rscale, bool round)
static void	div_var_int (const NumericVar *var, int ival, int ival_weight, NumericVar *result, int rscale, bool round)
static int	select_div_scale (const NumericVar *var1, const NumericVar *var2)
static void	mod_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	div_mod_var (const NumericVar *var1, const NumericVar *var2, NumericVar *quot, NumericVar *rem)
static void	ceil_var (const NumericVar *var, NumericVar *result)
static void	floor_var (const NumericVar *var, NumericVar *result)
static void	gcd_var (const NumericVar *var1, const NumericVar *var2, NumericVar *result)
static void	sqrt_var (const NumericVar *arg, NumericVar *result, int rscale)
static void	exp_var (const NumericVar *arg, NumericVar *result, int rscale)
static int	estimate_ln_dweight (const NumericVar *var)
static void	ln_var (const NumericVar *arg, NumericVar *result, int rscale)
static void	log_var (const NumericVar *base, const NumericVar *num, NumericVar *result)
static void	power_var (const NumericVar *base, const NumericVar *exp, NumericVar *result)
static void	power_var_int (const NumericVar *base, int exp, int exp_dscale, NumericVar *result)
static void	power_ten_int (int exp, NumericVar *result)
static 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, bool reversed_bounds, NumericVar *result_var)
static void	accum_sum_add (NumericSumAccum *accum, const NumericVar *val)
static void	accum_sum_rescale (NumericSumAccum *accum, const NumericVar *val)
static void	accum_sum_carry (NumericSumAccum *accum)
static void	accum_sum_reset (NumericSumAccum *accum)
static void	accum_sum_final (NumericSumAccum *accum, NumericVar *result)
static void	accum_sum_copy (NumericSumAccum *dst, NumericSumAccum *src)
static void	accum_sum_combine (NumericSumAccum *accum, NumericSumAccum *accum2)
Datum	numeric_in (PG_FUNCTION_ARGS)
Datum	numeric_out (PG_FUNCTION_ARGS)
bool	numeric_is_nan (Numeric num)
bool	numeric_is_inf (Numeric num)
static bool	numeric_is_integral (Numeric num)
static int32	make_numeric_typmod (int precision, int scale)
static bool	is_valid_numeric_typmod (int32 typmod)
static int	numeric_typmod_precision (int32 typmod)
static int	numeric_typmod_scale (int32 typmod)
int32	numeric_maximum_size (int32 typmod)
char *	numeric_out_sci (Numeric num, int scale)
char *	numeric_normalize (Numeric num)
Datum	numeric_recv (PG_FUNCTION_ARGS)
Datum	numeric_send (PG_FUNCTION_ARGS)
Datum	numeric_support (PG_FUNCTION_ARGS)
Datum	numeric (PG_FUNCTION_ARGS)
Datum	numerictypmodin (PG_FUNCTION_ARGS)
Datum	numerictypmodout (PG_FUNCTION_ARGS)
Datum	numeric_abs (PG_FUNCTION_ARGS)
Datum	numeric_uminus (PG_FUNCTION_ARGS)
Datum	numeric_uplus (PG_FUNCTION_ARGS)
static int	numeric_sign_internal (Numeric num)
Datum	numeric_sign (PG_FUNCTION_ARGS)
Datum	numeric_round (PG_FUNCTION_ARGS)
Datum	numeric_trunc (PG_FUNCTION_ARGS)
Datum	numeric_ceil (PG_FUNCTION_ARGS)
Datum	numeric_floor (PG_FUNCTION_ARGS)
Datum	generate_series_numeric (PG_FUNCTION_ARGS)
Datum	generate_series_step_numeric (PG_FUNCTION_ARGS)
Datum	width_bucket_numeric (PG_FUNCTION_ARGS)
Datum	numeric_sortsupport (PG_FUNCTION_ARGS)
Datum	numeric_cmp (PG_FUNCTION_ARGS)
Datum	numeric_eq (PG_FUNCTION_ARGS)
Datum	numeric_ne (PG_FUNCTION_ARGS)
Datum	numeric_gt (PG_FUNCTION_ARGS)
Datum	numeric_ge (PG_FUNCTION_ARGS)
Datum	numeric_lt (PG_FUNCTION_ARGS)
Datum	numeric_le (PG_FUNCTION_ARGS)
Datum	in_range_numeric_numeric (PG_FUNCTION_ARGS)
Datum	hash_numeric (PG_FUNCTION_ARGS)
Datum	hash_numeric_extended (PG_FUNCTION_ARGS)
Datum	numeric_add (PG_FUNCTION_ARGS)
Numeric	numeric_add_opt_error (Numeric num1, Numeric num2, bool *have_error)
Datum	numeric_sub (PG_FUNCTION_ARGS)
Numeric	numeric_sub_opt_error (Numeric num1, Numeric num2, bool *have_error)
Datum	numeric_mul (PG_FUNCTION_ARGS)
Numeric	numeric_mul_opt_error (Numeric num1, Numeric num2, bool *have_error)
Datum	numeric_div (PG_FUNCTION_ARGS)
Numeric	numeric_div_opt_error (Numeric num1, Numeric num2, bool *have_error)
Datum	numeric_div_trunc (PG_FUNCTION_ARGS)
Datum	numeric_mod (PG_FUNCTION_ARGS)
Numeric	numeric_mod_opt_error (Numeric num1, Numeric num2, bool *have_error)
Datum	numeric_inc (PG_FUNCTION_ARGS)
Datum	numeric_smaller (PG_FUNCTION_ARGS)
Datum	numeric_larger (PG_FUNCTION_ARGS)
Datum	numeric_gcd (PG_FUNCTION_ARGS)
Datum	numeric_lcm (PG_FUNCTION_ARGS)
Datum	numeric_fac (PG_FUNCTION_ARGS)
Datum	numeric_sqrt (PG_FUNCTION_ARGS)
Datum	numeric_exp (PG_FUNCTION_ARGS)
Datum	numeric_ln (PG_FUNCTION_ARGS)
Datum	numeric_log (PG_FUNCTION_ARGS)
Datum	numeric_power (PG_FUNCTION_ARGS)
Datum	numeric_scale (PG_FUNCTION_ARGS)
static int	get_min_scale (NumericVar *var)
Datum	numeric_min_scale (PG_FUNCTION_ARGS)
Datum	numeric_trim_scale (PG_FUNCTION_ARGS)
Numeric	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)
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 404 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 477 of file numeric.c.

digitbuf_free

#define digitbuf_free

(

buf

)

Value:

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

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

dump_var

#define dump_var	(		s,
			v
	)

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

makePolyNumAggState

#define makePolyNumAggState   makeNumericAggState

Definition at line 5467 of file numeric.c.

makePolyNumAggStateCurrentContext

#define makePolyNumAggStateCurrentContext   makeNumericAggStateCurrentContext

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

NBASE

#define NBASE   10000

Definition at line 96 of file numeric.c.

NUMERIC_ABBREV_BITS

#define NUMERIC_ABBREV_BITS   (SIZEOF_DATUM * BITS_PER_BYTE)

Definition at line 395 of file numeric.c.

NUMERIC_ABBREV_NAN

#define NUMERIC_ABBREV_NAN   NumericAbbrevGetDatum(PG_INT32_MIN)

Definition at line 405 of file numeric.c.

NUMERIC_ABBREV_NINF

#define NUMERIC_ABBREV_NINF   NumericAbbrevGetDatum(PG_INT32_MAX)

Definition at line 407 of file numeric.c.

NUMERIC_ABBREV_PINF

#define NUMERIC_ABBREV_PINF   NumericAbbrevGetDatum(-PG_INT32_MAX)

Definition at line 406 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 491 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 487 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 243 of file numeric.c.

NUMERIC_DSCALE_MASK

#define NUMERIC_DSCALE_MASK   0x3FFF

Definition at line 234 of file numeric.c.

NUMERIC_DSCALE_MAX

#define NUMERIC_DSCALE_MAX   NUMERIC_DSCALE_MASK

Definition at line 235 of file numeric.c.

NUMERIC_EXT_FLAGBITS

#define NUMERIC_EXT_FLAGBITS

(

n

)

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

Definition at line 203 of file numeric.c.

NUMERIC_EXT_SIGN_MASK

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

Definition at line 197 of file numeric.c.

NUMERIC_FLAGBITS

#define NUMERIC_FLAGBITS

(

n

)

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

Definition at line 171 of file numeric.c.

NUMERIC_HDRSZ

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

Definition at line 175 of file numeric.c.

NUMERIC_HDRSZ_SHORT

#define NUMERIC_HDRSZ_SHORT   (VARHDRSZ + sizeof(uint16))

Definition at line 176 of file numeric.c.

NUMERIC_HEADER_IS_SHORT

#define NUMERIC_HEADER_IS_SHORT

(

n

)

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

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

NUMERIC_INF_SIGN_MASK

#define NUMERIC_INF_SIGN_MASK   0x2000

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

NUMERIC_IS_NAN

#define NUMERIC_IS_NAN

(

n

)

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

Definition at line 204 of file numeric.c.

NUMERIC_IS_NINF

#define NUMERIC_IS_NINF

(

n

)

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

Definition at line 206 of file numeric.c.

NUMERIC_IS_PINF

#define NUMERIC_IS_PINF

(

n

)

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

Definition at line 205 of file numeric.c.

NUMERIC_IS_SHORT

#define NUMERIC_IS_SHORT

(

n

)

(NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)

Definition at line 172 of file numeric.c.

NUMERIC_IS_SPECIAL

#define NUMERIC_IS_SPECIAL

(

n

)

(NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)

Definition at line 173 of file numeric.c.

NUMERIC_NAN

#define NUMERIC_NAN   0xC000

Definition at line 198 of file numeric.c.

NUMERIC_NDIGITS

#define NUMERIC_NDIGITS

(

num

)

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

Definition at line 489 of file numeric.c.

NUMERIC_NEG

#define NUMERIC_NEG   0x4000

Definition at line 167 of file numeric.c.

NUMERIC_NINF

#define NUMERIC_NINF   0xF000

Definition at line 200 of file numeric.c.

NUMERIC_PINF

#define NUMERIC_PINF   0xD000

Definition at line 199 of file numeric.c.

NUMERIC_POS

#define NUMERIC_POS   0x0000

Definition at line 166 of file numeric.c.

NUMERIC_SHORT

#define NUMERIC_SHORT   0x8000

Definition at line 168 of file numeric.c.

NUMERIC_SHORT_DSCALE_MASK

#define NUMERIC_SHORT_DSCALE_MASK   0x1F80

Definition at line 215 of file numeric.c.

NUMERIC_SHORT_DSCALE_MAX

#define NUMERIC_SHORT_DSCALE_MAX    (NUMERIC_SHORT_DSCALE_MASK >> NUMERIC_SHORT_DSCALE_SHIFT)

Definition at line 217 of file numeric.c.

NUMERIC_SHORT_DSCALE_SHIFT

#define NUMERIC_SHORT_DSCALE_SHIFT   7

Definition at line 216 of file numeric.c.

NUMERIC_SHORT_SIGN_MASK

#define NUMERIC_SHORT_SIGN_MASK   0x2000

Definition at line 214 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MASK

#define NUMERIC_SHORT_WEIGHT_MASK   0x003F

Definition at line 220 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MAX

#define NUMERIC_SHORT_WEIGHT_MAX   NUMERIC_SHORT_WEIGHT_MASK

Definition at line 221 of file numeric.c.

NUMERIC_SHORT_WEIGHT_MIN

#define NUMERIC_SHORT_WEIGHT_MIN   (-(NUMERIC_SHORT_WEIGHT_MASK+1))

Definition at line 222 of file numeric.c.

NUMERIC_SHORT_WEIGHT_SIGN_MASK

#define NUMERIC_SHORT_WEIGHT_SIGN_MASK   0x0040

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

NUMERIC_SIGN_MASK

#define NUMERIC_SIGN_MASK   0xC000

Definition at line 165 of file numeric.c.

NUMERIC_SPECIAL

#define NUMERIC_SPECIAL   0xC000

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

NumericAbbrevGetDatum

#define NumericAbbrevGetDatum

(

X

)

((Datum) (X))

Definition at line 403 of file numeric.c.

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 5466 of file numeric.c.

Function Documentation

accum_sum_add()

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

static

Definition at line 11729 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 11777 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 12007 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 11990 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 11939 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 11850 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 11713 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 11337 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 8353 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(), 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 6875 of file numeric.c.

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

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

Referenced by div_var(), div_var_fast(), int64_to_numericvar(), mul_var(), numeric_recv(), numericvar_deserialize(), 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 7829 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 7914 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 9867 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 11259 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 11273 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 2504 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 8295 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(), compute_bucket(), estimate_ln_dweight(), floor_var(), generate_series_step_numeric(), in_range_numeric_numeric(), ln_var(), numeric_power(), numeric_stddev_internal(), power_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 8310 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, bool  reversed_bounds, NumericVar *  result_var  )

static

Definition at line 1916 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);
 
    if (!reversed_bounds)
    {
        sub_var(&operand_var, &bound1_var, &operand_var);
        sub_var(&bound2_var, &bound1_var, &bound2_var);
    }
    else
    {
        sub_var(&bound1_var, &operand_var, &operand_var);
        sub_var(&bound1_var, &bound2_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,
            select_div_scale(&operand_var, &bound2_var), true);
 
    /*
     * Roundoff in the division could give us a quotient exactly equal to
     * "count", which is too large.  Clamp so that we do not emit a result
     * larger than "count".
     */
    if (cmp_var(result_var, count_var) >= 0)
        set_var_from_var(count_var, result_var);
    else
    {
        add_var(result_var, &const_one, result_var);
        floor_var(result_var, result_var);
    }
 
    free_var(&bound1_var);
    free_var(&bound2_var);
    free_var(&operand_var);
}

References add_var(), cmp_var(), const_one, div_var(), NumericVar::dscale, floor_var(), free_var(), init_var_from_num(), mul_var(), select_div_scale(), set_var_from_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 9797 of file numeric.c.

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

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

Referenced by sqrt_var().

div_var()

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

static

Definition at line 8799 of file numeric.c.

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

References alloc_var(), Assert(), DEC_DIGITS, NumericVar::digits, div_var_int(), NumericVar::dscale, ereport, errcode(), errmsg(), ERROR, HALF_NBASE, i, j, Max, NBASE, NumericVar::ndigits, NUMERIC_NEG, NUMERIC_POS, palloc0(), pfree(), round_var(), NumericVar::sign, strip_var(), trunc_var(), NumericVar::weight, and zero_var().

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

div_var_fast()

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

static

Definition at line 9107 of file numeric.c.

{
    int         div_ndigits;
    int         load_ndigits;
    int         res_sign;
    int         res_weight;
    int        *div;
    int         qdigit;
    int         carry;
    int         maxdiv;
    int         newdig;
    NumericDigit *res_digits;
    double      fdividend,
                fdivisor,
                fdivisorinverse,
                fquotient;
    int         qi;
    int         i;
 
    /* copy these values into local vars for speed in inner loop */
    int         var1ndigits = var1->ndigits;
    int         var2ndigits = var2->ndigits;
    NumericDigit *var1digits = var1->digits;
    NumericDigit *var2digits = var2->digits;
 
    /*
     * First of all division by zero check; we must not be handed an
     * unnormalized divisor.
     */
    if (var2ndigits == 0 || var2digits[0] == 0)
        ereport(ERROR,
                (errcode(ERRCODE_DIVISION_BY_ZERO),
                 errmsg("division by zero")));
 
    /*
     * If the divisor has just one or two digits, delegate to div_var_int(),
     * which uses fast short division.
     *
     * Similarly, on platforms with 128-bit integer support, delegate to
     * div_var_int64() for divisors with three or four digits.
     */
    if (var2ndigits <= 2)
    {
        int         idivisor;
        int         idivisor_weight;
 
        idivisor = var2->digits[0];
        idivisor_weight = var2->weight;
        if (var2ndigits == 2)
        {
            idivisor = idivisor * NBASE + var2->digits[1];
            idivisor_weight--;
        }
        if (var2->sign == NUMERIC_NEG)
            idivisor = -idivisor;
 
        div_var_int(var1, idivisor, idivisor_weight, result, rscale, round);
        return;
    }
#ifdef HAVE_INT128
    if (var2ndigits <= 4)
    {
        int64       idivisor;
        int         idivisor_weight;
 
        idivisor = var2->digits[0];
        idivisor_weight = var2->weight;
        for (i = 1; i < var2ndigits; i++)
        {
            idivisor = idivisor * NBASE + var2->digits[i];
            idivisor_weight--;
        }
        if (var2->sign == NUMERIC_NEG)
            idivisor = -idivisor;
 
        div_var_int64(var1, idivisor, idivisor_weight, result, rscale, round);
        return;
    }
#endif
 
    /*
     * Otherwise, perform full long division.
     */
 
    /* Result zero check */
    if (var1ndigits == 0)
    {
        zero_var(result);
        result->dscale = rscale;
        return;
    }
 
    /*
     * Determine the result sign, weight and number of digits to calculate
     */
    if (var1->sign == var2->sign)
        res_sign = NUMERIC_POS;
    else
        res_sign = NUMERIC_NEG;
    res_weight = var1->weight - var2->weight + 1;
    /* The number of accurate result digits we need to produce: */
    div_ndigits = res_weight + 1 + (rscale + DEC_DIGITS - 1) / DEC_DIGITS;
    /* Add guard digits for roundoff error */
    div_ndigits += DIV_GUARD_DIGITS;
    if (div_ndigits < DIV_GUARD_DIGITS)
        div_ndigits = DIV_GUARD_DIGITS;
 
    /*
     * We do the arithmetic in an array "div[]" of signed int's.  Since
     * INT_MAX is noticeably larger than NBASE*NBASE, this gives us headroom
     * to avoid normalizing carries immediately.
     *
     * We start with div[] containing one zero digit followed by the
     * dividend's digits (plus appended zeroes to reach the desired precision
     * including guard digits).  Each step of the main loop computes an
     * (approximate) quotient digit and stores it into div[], removing one
     * position of dividend space.  A final pass of carry propagation takes
     * care of any mistaken quotient digits.
     *
     * Note that div[] doesn't necessarily contain all of the digits from the
     * dividend --- the desired precision plus guard digits might be less than
     * the dividend's precision.  This happens, for example, in the square
     * root algorithm, where we typically divide a 2N-digit number by an
     * N-digit number, and only require a result with N digits of precision.
     */
    div = (int *) palloc0((div_ndigits + 1) * sizeof(int));
    load_ndigits = Min(div_ndigits, var1ndigits);
    for (i = 0; i < load_ndigits; i++)
        div[i + 1] = var1digits[i];
 
    /*
     * We estimate each quotient digit using floating-point arithmetic, taking
     * the first four digits of the (current) dividend and divisor.  This must
     * be float to avoid overflow.  The quotient digits will generally be off
     * by no more than one from the exact answer.
     */
    fdivisor = (double) var2digits[0];
    for (i = 1; i < 4; i++)
    {
        fdivisor *= NBASE;
        if (i < var2ndigits)
            fdivisor += (double) var2digits[i];
    }
    fdivisorinverse = 1.0 / fdivisor;
 
    /*
     * maxdiv tracks the maximum possible absolute value of any div[] entry;
     * when this threatens to exceed INT_MAX, we take the time to propagate
     * carries.  Furthermore, we need to ensure that overflow doesn't occur
     * during the carry propagation passes either.  The carry values may have
     * an absolute value as high as INT_MAX/NBASE + 1, so really we must
     * normalize when digits threaten to exceed INT_MAX - INT_MAX/NBASE - 1.
     *
     * To avoid overflow in maxdiv itself, it represents the max absolute
     * value divided by NBASE-1, ie, at the top of the loop it is known that
     * no div[] entry has an absolute value exceeding maxdiv * (NBASE-1).
     *
     * Actually, though, that holds good only for div[] entries after div[qi];
     * the adjustment done at the bottom of the loop may cause div[qi + 1] to
     * exceed the maxdiv limit, so that div[qi] in the next iteration is
     * beyond the limit.  This does not cause problems, as explained below.
     */
    maxdiv = 1;
 
    /*
     * Outer loop computes next quotient digit, which will go into div[qi]
     */
    for (qi = 0; qi < div_ndigits; qi++)
    {
        /* Approximate the current dividend value */
        fdividend = (double) div[qi];
        for (i = 1; i < 4; i++)
        {
            fdividend *= NBASE;
            if (qi + i <= div_ndigits)
                fdividend += (double) div[qi + i];
        }
        /* Compute the (approximate) quotient digit */
        fquotient = fdividend * fdivisorinverse;
        qdigit = (fquotient >= 0.0) ? ((int) fquotient) :
            (((int) fquotient) - 1);    /* truncate towards -infinity */
 
        if (qdigit != 0)
        {
            /* Do we need to normalize now? */
            maxdiv += abs(qdigit);
            if (maxdiv > (INT_MAX - INT_MAX / NBASE - 1) / (NBASE - 1))
            {
                /*
                 * Yes, do it.  Note that if var2ndigits is much smaller than
                 * div_ndigits, we can save a significant amount of effort
                 * here by noting that we only need to normalise those div[]
                 * entries touched where prior iterations subtracted multiples
                 * of the divisor.
                 */
                carry = 0;
                for (i = Min(qi + var2ndigits - 2, div_ndigits); i > qi; i--)
                {
                    newdig = div[i] + carry;
                    if (newdig < 0)
                    {
                        carry = -((-newdig - 1) / NBASE) - 1;
                        newdig -= carry * NBASE;
                    }
                    else if (newdig >= NBASE)
                    {
                        carry = newdig / NBASE;
                        newdig -= carry * NBASE;
                    }
                    else
                        carry = 0;
                    div[i] = newdig;
                }
                newdig = div[qi] + carry;
                div[qi] = newdig;
 
                /*
                 * All the div[] digits except possibly div[qi] are now in the
                 * range 0..NBASE-1.  We do not need to consider div[qi] in
                 * the maxdiv value anymore, so we can reset maxdiv to 1.
                 */
                maxdiv = 1;
 
                /*
                 * Recompute the quotient digit since new info may have
                 * propagated into the top four dividend digits
                 */
                fdividend = (double) div[qi];
                for (i = 1; i < 4; i++)
                {
                    fdividend *= NBASE;
                    if (qi + i <= div_ndigits)
                        fdividend += (double) div[qi + i];
                }
                /* Compute the (approximate) quotient digit */
                fquotient = fdividend * fdivisorinverse;
                qdigit = (fquotient >= 0.0) ? ((int) fquotient) :
                    (((int) fquotient) - 1);    /* truncate towards -infinity */
                maxdiv += abs(qdigit);
            }
 
            /*
             * Subtract off the appropriate multiple of the divisor.
             *
             * The digits beyond div[qi] cannot overflow, because we know they
             * will fall within the maxdiv limit.  As for div[qi] itself, note
             * that qdigit is approximately trunc(div[qi] / vardigits[0]),
             * which would make the new value simply div[qi] mod vardigits[0].
             * The lower-order terms in qdigit can change this result by not
             * more than about twice INT_MAX/NBASE, so overflow is impossible.
             *
             * This inner loop is the performance bottleneck for division, so
             * code it in the same way as the inner loop of mul_var() so that
             * it can be auto-vectorized.  We cast qdigit to NumericDigit
             * before multiplying to allow the compiler to generate more
             * efficient code (using 16-bit multiplication), which is safe
             * since we know that the quotient digit is off by at most one, so
             * there is no overflow risk.
             */
            if (qdigit != 0)
            {
                int         istop = Min(var2ndigits, div_ndigits - qi + 1);
                int        *div_qi = &div[qi];
 
                for (i = 0; i < istop; i++)
                    div_qi[i] -= ((NumericDigit) qdigit) * var2digits[i];
            }
        }
 
        /*
         * The dividend digit we are about to replace might still be nonzero.
         * Fold it into the next digit position.
         *
         * There is no risk of overflow here, although proving that requires
         * some care.  Much as with the argument for div[qi] not overflowing,
         * if we consider the first two terms in the numerator and denominator
         * of qdigit, we can see that the final value of div[qi + 1] will be
         * approximately a remainder mod (vardigits[0]*NBASE + vardigits[1]).
         * Accounting for the lower-order terms is a bit complicated but ends
         * up adding not much more than INT_MAX/NBASE to the possible range.
         * Thus, div[qi + 1] cannot overflow here, and in its role as div[qi]
         * in the next loop iteration, it can't be large enough to cause
         * overflow in the carry propagation step (if any), either.
         *
         * But having said that: div[qi] can be more than INT_MAX/NBASE, as
         * noted above, which means that the product div[qi] * NBASE *can*
         * overflow.  When that happens, adding it to div[qi + 1] will always
         * cause a canceling overflow so that the end result is correct.  We
         * could avoid the intermediate overflow by doing the multiplication
         * and addition in int64 arithmetic, but so far there appears no need.
         */
        div[qi + 1] += div[qi] * NBASE;
 
        div[qi] = qdigit;
    }
 
    /*
     * Approximate and store the last quotient digit (div[div_ndigits])
     */
    fdividend = (double) div[qi];
    for (i = 1; i < 4; i++)
        fdividend *= NBASE;
    fquotient = fdividend * fdivisorinverse;
    qdigit = (fquotient >= 0.0) ? ((int) fquotient) :
        (((int) fquotient) - 1);    /* truncate towards -infinity */
    div[qi] = qdigit;
 
    /*
     * Because the quotient digits might be off by one, some of them might be
     * -1 or NBASE at this point.  The represented value is correct in a
     * mathematical sense, but it doesn't look right.  We do a final carry
     * propagation pass to normalize the digits, which we combine with storing
     * the result digits into the output.  Note that this is still done at
     * full precision w/guard digits.
     */
    alloc_var(result, div_ndigits + 1);
    res_digits = result->digits;
    carry = 0;
    for (i = div_ndigits; i >= 0; i--)
    {
        newdig = div[i] + carry;
        if (newdig < 0)
        {
            carry = -((-newdig - 1) / NBASE) - 1;
            newdig -= carry * NBASE;
        }
        else if (newdig >= NBASE)
        {
            carry = newdig / NBASE;
            newdig -= carry * NBASE;
        }
        else
            carry = 0;
        res_digits[i] = newdig;
    }
    Assert(carry == 0);
 
    pfree(div);
 
    /*
     * Finally, round the result to the requested precision.
     */
    result->weight = res_weight;
    result->sign = res_sign;
 
    /* Round to target rscale (and set result->dscale) */
    if (round)
        round_var(result, rscale);
    else
        trunc_var(result, rscale);
 
    /* Strip leading and trailing zeroes */
    strip_var(result);
}

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

Referenced by div_mod_var(), ln_var(), log_var(), and power_var_int().

div_var_int()

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

static

Definition at line 9471 of file numeric.c.

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

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

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

do_numeric_accum()

static void do_numeric_accum ( NumericAggState *  state, Numeric  newval  )

static

Definition at line 4779 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 4849 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 7685 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 10593 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 10464 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 4609 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.

float8_numeric()

Datum float8_numeric

(

PG_FUNCTION_ARGS

)

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

floor_var()

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

static

Definition at line 9891 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 compute_bucket(), and numeric_floor().

free_var()

static void free_var ( NumericVar *  var )

static

Definition at line 6891 of file numeric.c.

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

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

Referenced by accum_sum_combine(), ceil_var(), compute_bucket(), div_mod_var(), estimate_ln_dweight(), exp_var(), float4_numeric(), float8_numeric(), floor_var(), gcd_var(), get_str_from_var_sci(), in_range_numeric_numeric(), int64_div_fast_to_numeric(), int64_to_numeric(), int8_avg_deserialize(), int8_avg_serialize(), ln_var(), log_var(), mod_var(), numeric(), numeric_add_opt_error(), numeric_avg(), numeric_avg_deserialize(), numeric_avg_serialize(), numeric_ceil(), numeric_deserialize(), numeric_div_opt_error(), numeric_div_trunc(), numeric_exp(), numeric_fac(), numeric_floor(), numeric_gcd(), numeric_in(), numeric_inc(), numeric_lcm(), numeric_ln(), numeric_log(), numeric_min_scale(), numeric_mod_opt_error(), numeric_mul_opt_error(), numeric_poly_avg(), numeric_poly_deserialize(), numeric_poly_serialize(), numeric_poly_sum(), numeric_power(), numeric_recv(), numeric_round(), numeric_serialize(), numeric_sqrt(), numeric_stddev_internal(), numeric_sub_opt_error(), numeric_sum(), numeric_trim_scale(), numeric_trunc(), numericvar_to_int64(), numericvar_to_uint64(), power_var(), power_var_int(), 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 9914 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 1685 of file numeric.c.

{
    return generate_series_step_numeric(fcinfo);
}

References generate_series_step_numeric().

generate_series_step_numeric()

Datum generate_series_step_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 1691 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 4135 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 7416 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, generate_unaccent_rules::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 7569 of file numeric.c.

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

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

Referenced by numeric_out_sci().

hash_numeric()

Datum hash_numeric

(

PG_FUNCTION_ARGS

)

Definition at line 2696 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 2776 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 2561 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 7373 of file numeric.c.

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

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

Referenced by compute_bucket(), do_numeric_accum(), do_numeric_discard(), generate_series_step_numeric(), in_range_numeric_numeric(), numeric_abbrev_convert(), numeric_add_opt_error(), numeric_ceil(), numeric_div_opt_error(), numeric_div_trunc(), numeric_exp(), numeric_float8_no_overflow(), numeric_floor(), numeric_gcd(), numeric_inc(), numeric_int2(), numeric_int4_opt_error(), numeric_int8(), 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(), and numeric_trim_scale().

int2_accum()

Datum int2_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5472 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 5896 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 6579 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 6666 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 4466 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.

int2_sum()

Datum int2_sum

(

PG_FUNCTION_ARGS

)

Definition at line 6430 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 6749 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 5495 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 5921 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 6607 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 6694 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 6635 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 4338 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.

int4_sum()

Datum int4_sum

(

PG_FUNCTION_ARGS

)

Definition at line 6479 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 4253 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 4232 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 8026 of file numeric.c.

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

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

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

int8_accum()

Datum int8_accum

(

PG_FUNCTION_ARGS

)

Definition at line 5518 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 5946 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 6722 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 5714 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 5967 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 5741 of file numeric.c.

{
    PolyNumAggState *state1;
    PolyNumAggState *state2;
    MemoryContext agg_context;
    MemoryContext old_context;
 
    if (!AggCheckCallContext(fcinfo, &agg_context))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    state1 = PG_ARGISNULL(0) ? NULL : (PolyNumAggState *) PG_GETARG_POINTER(0);
    state2 = PG_ARGISNULL(1) ? NULL : (PolyNumAggState *) PG_GETARG_POINTER(1);
 
    if (state2 == NULL)
        PG_RETURN_POINTER(state1);
 
    /* manually copy all fields from state2 to state1 */
    if (state1 == NULL)
    {
        old_context = MemoryContextSwitchTo(agg_context);
 
        state1 = makePolyNumAggState(fcinfo, false);
        state1->N = state2->N;
 
#ifdef HAVE_INT128
        state1->sumX = state2->sumX;
#else
        accum_sum_copy(&state1->sumX, &state2->sumX);
#endif
        MemoryContextSwitchTo(old_context);
 
        PG_RETURN_POINTER(state1);
    }
 
    if (state2->N > 0)
    {
        state1->N += state2->N;
 
#ifdef HAVE_INT128
        state1->sumX += state2->sumX;
#else
        /* The rest of this needs to work in the aggregate context */
        old_context = MemoryContextSwitchTo(agg_context);
 
        /* Accumulate sums */
        accum_sum_combine(&state1->sumX, &state2->sumX);
 
        MemoryContextSwitchTo(old_context);
#endif
 
    }
    PG_RETURN_POINTER(state1);
}

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

int8_avg_deserialize()

Datum int8_avg_deserialize

(

PG_FUNCTION_ARGS

)

Definition at line 5850 of file numeric.c.

{
    bytea      *sstate;
    PolyNumAggState *result;
    StringInfoData buf;
    NumericVar  tmp_var;
 
    if (!AggCheckCallContext(fcinfo, NULL))
        elog(ERROR, "aggregate function called in non-aggregate context");
 
    sstate = PG_GETARG_BYTEA_PP(0);
 
    init_var(&tmp_var);
 
    /*
     * Initialize a StringInfo so that we can "receive" it using the standard
     * recv-function infrastructure.
     */
    initReadOnlyStringInfo(&buf, VARDATA_ANY(sstate),
                           VARSIZE_ANY_EXHDR(sstate));
 
    result = makePolyNumAggStateCurrentContext(false);
 
    /* N */
    result->N = pq_getmsgint64(&buf);
 
    /* sumX */
    numericvar_deserialize(&buf, &tmp_var);
#ifdef HAVE_INT128
    numericvar_to_int128(&tmp_var, &result->sumX);
#else
    accum_sum_add(&result->sumX, &tmp_var);
#endif
 
    pq_getmsgend(&buf);
 
    free_var(&tmp_var);
 
    PG_RETURN_POINTER(result);
}

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

int8_avg_serialize()

Datum int8_avg_serialize

(

PG_FUNCTION_ARGS

)

Definition at line 5801 of file numeric.c.

{