numeric.h File Reference

#include "common/pg_prng.h"
#include "fmgr.h"

Include dependency graph for numeric.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	NUMERIC_MAX_PRECISION   1000
#define	NUMERIC_MIN_SCALE   (-1000)
#define	NUMERIC_MAX_SCALE   1000
#define	NUMERIC_MAX_DISPLAY_SCALE   NUMERIC_MAX_PRECISION
#define	NUMERIC_MIN_DISPLAY_SCALE   0
#define	NUMERIC_MAX_RESULT_SCALE   (NUMERIC_MAX_PRECISION * 2)
#define	NUMERIC_MIN_SIG_DIGITS   16
#define	PG_GETARG_NUMERIC(n)   DatumGetNumeric(PG_GETARG_DATUM(n))
#define	PG_GETARG_NUMERIC_COPY(n)   DatumGetNumericCopy(PG_GETARG_DATUM(n))
#define	PG_RETURN_NUMERIC(x)   return NumericGetDatum(x)

Typedefs
typedef struct Node	Node
typedef struct NumericData *	Numeric

Functions
static Numeric	DatumGetNumeric (Datum X)
static Numeric	DatumGetNumericCopy (Datum X)
static Datum	NumericGetDatum (Numeric X)
bool	numeric_is_nan (Numeric num)
bool	numeric_is_inf (Numeric num)
int32	numeric_maximum_size (int32 typmod)
char *	numeric_out_sci (Numeric num, int scale)
char *	numeric_normalize (Numeric num)
Numeric	int64_to_numeric (int64 val)
Numeric	int64_div_fast_to_numeric (int64 val1, int log10val2)
Numeric	numeric_add_safe (Numeric num1, Numeric num2, Node *escontext)
Numeric	numeric_sub_safe (Numeric num1, Numeric num2, Node *escontext)
Numeric	numeric_mul_safe (Numeric num1, Numeric num2, Node *escontext)
Numeric	numeric_div_safe (Numeric num1, Numeric num2, Node *escontext)
Numeric	numeric_mod_safe (Numeric num1, Numeric num2, Node *escontext)
int32	numeric_int4_safe (Numeric num, Node *escontext)
int64	numeric_int8_safe (Numeric num, Node *escontext)
int32	make_numeric_typmod_safe (int32 precision, int32 scale, Node *escontext)
Numeric	random_numeric (pg_prng_state *state, Numeric rmin, Numeric rmax)

Macro Definition Documentation

NUMERIC_MAX_DISPLAY_SCALE

#define NUMERIC_MAX_DISPLAY_SCALE   NUMERIC_MAX_PRECISION

Definition at line 43 of file numeric.h.

NUMERIC_MAX_PRECISION

#define NUMERIC_MAX_PRECISION   1000

Definition at line 35 of file numeric.h.

NUMERIC_MAX_RESULT_SCALE

#define NUMERIC_MAX_RESULT_SCALE   (NUMERIC_MAX_PRECISION * 2)

Definition at line 46 of file numeric.h.

NUMERIC_MAX_SCALE

#define NUMERIC_MAX_SCALE   1000

Definition at line 38 of file numeric.h.

NUMERIC_MIN_DISPLAY_SCALE

#define NUMERIC_MIN_DISPLAY_SCALE   0

Definition at line 44 of file numeric.h.

NUMERIC_MIN_SCALE

#define NUMERIC_MIN_SCALE   (-1000)

Definition at line 37 of file numeric.h.

NUMERIC_MIN_SIG_DIGITS

#define NUMERIC_MIN_SIG_DIGITS   16

Definition at line 53 of file numeric.h.

PG_GETARG_NUMERIC

#define PG_GETARG_NUMERIC

(

n

)

DatumGetNumeric(PG_GETARG_DATUM(n))

Definition at line 81 of file numeric.h.

PG_GETARG_NUMERIC_COPY

#define PG_GETARG_NUMERIC_COPY

(

n

)

DatumGetNumericCopy(PG_GETARG_DATUM(n))

Definition at line 82 of file numeric.h.

PG_RETURN_NUMERIC

#define PG_RETURN_NUMERIC

(

x

)

return NumericGetDatum(x)

Definition at line 83 of file numeric.h.

Typedef Documentation

Node

typedef struct Node Node

Definition at line 21 of file numeric.h.

Numeric

typedef struct NumericData* Numeric

Definition at line 57 of file numeric.h.

Function Documentation

DatumGetNumeric()

static Numeric DatumGetNumeric ( Datum  X )

inlinestatic

Definition at line 64 of file numeric.h.

{
    return (Numeric) PG_DETOAST_DATUM(X);
}

References fb(), and PG_DETOAST_DATUM.

Referenced by copyScalarSubstructure(), datum_to_jsonb_internal(), executeItemOptUnwrapTarget(), executeNumericItemMethod(), executeUnaryArithmExpr(), extract_date(), gbt_numeric_consistent(), gbt_numeric_penalty(), generate_series_numeric_support(), getArrayIndex(), hstore_to_jsonb_loose(), jsonb_in_scalar(), JsonbValueInitNumericDatum(), numeric_absolute(), numeric_fast_cmp(), numeric_half_rounded(), numeric_to_char(), numeric_to_number(), numeric_truncated_divide(), pg_size_bytes(), PLyNumber_ToJsonbValue(), SV_to_JsonbValue(), timestamp_part_common(), and timestamptz_part_common().

DatumGetNumericCopy()

static Numeric DatumGetNumericCopy ( Datum  X )

inlinestatic

Definition at line 70 of file numeric.h.

{
    return (Numeric) PG_DETOAST_DATUM_COPY(X);
}

References fb(), and PG_DETOAST_DATUM_COPY.

Referenced by jsonb_numeric().

int64_div_fast_to_numeric()

Numeric int64_div_fast_to_numeric ( int64  val1, int  log10val2  )

extern

Definition at line 4291 of file numeric.c.

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

References DEC_DIGITS, fb(), free_var(), init_var, int128_add_int64_mul_int64(), int128_to_numericvar(), int64_to_int128(), int64_to_numericvar(), lengthof, make_result(), pg_mul_s64_overflow(), result, StaticAssertDecl, and unlikely.

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 )

extern

Definition at line 4270 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(), result, and val.

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

make_numeric_typmod_safe()

int32 make_numeric_typmod_safe ( int32  precision, int32  scale, Node *  escontext  )

extern

Definition at line 1315 of file numeric.c.

{
    if (precision < 1 || precision > NUMERIC_MAX_PRECISION)
        ereturn(escontext, -1,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("NUMERIC precision %d must be between 1 and %d",
                        precision, NUMERIC_MAX_PRECISION)));
    if (scale < NUMERIC_MIN_SCALE || scale > NUMERIC_MAX_SCALE)
        ereturn(escontext, -1,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("NUMERIC scale %d must be between %d and %d",
                        scale, NUMERIC_MIN_SCALE, NUMERIC_MAX_SCALE)));
 
    return make_numeric_typmod(precision, scale);
}

References ereturn, errcode(), errmsg, fb(), make_numeric_typmod(), NUMERIC_MAX_PRECISION, NUMERIC_MAX_SCALE, NUMERIC_MIN_SCALE, and scale.

Referenced by executeItemOptUnwrapTarget(), and numerictypmodin().

numeric_add_safe()

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

extern

Definition at line 2889 of file numeric.c.

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

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

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

numeric_div_safe()

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

extern

Definition at line 3163 of file numeric.c.

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

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

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

numeric_int4_safe()

int32 numeric_int4_safe ( Numeric  num, Node *  escontext  )

extern

Definition at line 4375 of file numeric.c.

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

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

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

numeric_int8_safe()

int64 numeric_int8_safe ( Numeric  num, Node *  escontext  )

extern

Definition at line 4451 of file numeric.c.

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

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

Referenced by executeItemOptUnwrapTarget(), numeric_cash(), and numeric_int8().

numeric_is_inf()

bool numeric_is_inf ( Numeric  num )

extern

Definition at line 845 of file numeric.c.

{
    return NUMERIC_IS_INF(num);
}

References NUMERIC_IS_INF.

Referenced by datum_to_jsonb_internal(), executeItemOptUnwrapTarget(), and PLyNumber_ToJsonbValue().

numeric_is_nan()

bool numeric_is_nan ( Numeric  num )

extern

Definition at line 834 of file numeric.c.

{
    return NUMERIC_IS_NAN(num);
}

References NUMERIC_IS_NAN.

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

numeric_maximum_size()

int32 numeric_maximum_size ( int32  typmod )

extern

Definition at line 936 of file numeric.c.

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

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

Referenced by type_maximum_size().

numeric_mod_safe()

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

extern

Definition at line 3366 of file numeric.c.

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

References const_nan, duplicate_numeric(), ereturn, errcode(), errmsg, fb(), free_var(), init_var, init_var_from_num(), make_result(), make_result_safe(), mod_var(), NUMERIC_IS_INF, NUMERIC_IS_NAN, NUMERIC_IS_SPECIAL, numeric_sign_internal(), and result.

Referenced by executeItemOptUnwrapTarget(), and numeric_mod().

numeric_mul_safe()

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

extern

Definition at line 3044 of file numeric.c.

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

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

Referenced by executeItemOptUnwrapTarget(), numeric_cash(), and numeric_mul().

numeric_normalize()

char * numeric_normalize ( Numeric  num )

extern

Definition at line 1009 of file numeric.c.

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

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

Referenced by make_scalar_key().

numeric_out_sci()

char * numeric_out_sci ( Numeric  num, int  scale  )

extern

Definition at line 975 of file numeric.c.

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

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

Referenced by int8_to_char(), and numeric_to_char().

numeric_sub_safe()

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

extern

Definition at line 2965 of file numeric.c.

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

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

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

NumericGetDatum()

static Datum NumericGetDatum ( Numeric  X )

inlinestatic

Definition at line 76 of file numeric.h.

{
    return PointerGetDatum(X);
}

References fb(), and PointerGetDatum.

Referenced by cash_numeric(), compareNumeric(), copyScalarSubstructure(), ExecGetJsonValueItemString(), executeItemOptUnwrapTarget(), executeNumericItemMethod(), executeUnaryArithmExpr(), gbt_numeric_penalty(), generate_series_step_numeric(), getArrayIndex(), gin_numeric_cmp(), int8_avg(), int8_sum(), iterate_jsonb_values(), jsonb_float4(), jsonb_float8(), jsonb_int2(), jsonb_int4(), jsonb_int8(), jsonb_numeric(), JsonbHashScalarValue(), JsonbHashScalarValueExtended(), JsonbValue_to_SV(), numeric_absolute(), numeric_avg(), numeric_float4(), numeric_float8(), numeric_half_rounded(), numeric_is_less(), numeric_poly_avg(), numeric_to_char(), numeric_to_cstring(), numeric_to_number(), numeric_truncated_divide(), pg_lsn_mii(), pg_lsn_pli(), pg_size_bytes(), PLyObject_FromJsonbValue(), printJsonPathItem(), timestamp_part_common(), and timestamptz_part_common().

random_numeric()

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

extern

Definition at line 4215 of file numeric.c.

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

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

Referenced by numeric_random().