#include "fmgr.h"

Include dependency graph for numeric.h:

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

Macros
#define	NUMERIC_MAX_PRECISION 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	DatumGetNumeric(X) ((Numeric) PG_DETOAST_DATUM(X))

#define	DatumGetNumericCopy(X) ((Numeric) PG_DETOAST_DATUM_COPY(X))

#define	NumericGetDatum(X) PointerGetDatum(X)

#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 NumericData *	Numeric

Functions
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	numeric_add_opt_error (Numeric num1, Numeric num2, bool *have_error)

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

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

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

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

int32	numeric_int4_opt_error (Numeric num, bool *error)

Macro Definition Documentation

◆ DatumGetNumeric

#define DatumGetNumeric ( X ) ((Numeric) PG_DETOAST_DATUM(X))

◆ DatumGetNumericCopy

#define DatumGetNumericCopy ( X ) ((Numeric) PG_DETOAST_DATUM_COPY(X))

Definition at line 50 of file numeric.h.

Referenced by jsonb_numeric().

◆ NUMERIC_MAX_DISPLAY_SCALE

#define NUMERIC_MAX_DISPLAY_SCALE NUMERIC_MAX_PRECISION

Definition at line 29 of file numeric.h.

Referenced by log_var(), numeric_exp(), numeric_ln(), numeric_sqrt(), power_var(), power_var_int(), and select_div_scale().

◆ NUMERIC_MAX_PRECISION

#define NUMERIC_MAX_PRECISION 1000

Definition at line 24 of file numeric.h.

Referenced by numerictypmodin().

◆ NUMERIC_MAX_RESULT_SCALE

#define NUMERIC_MAX_RESULT_SCALE (NUMERIC_MAX_PRECISION * 2)

Definition at line 32 of file numeric.h.

Referenced by exp_var(), numeric_exp(), numeric_round(), numeric_trunc(), and power_var().

◆ NUMERIC_MIN_DISPLAY_SCALE

#define NUMERIC_MIN_DISPLAY_SCALE 0

Definition at line 30 of file numeric.h.

Referenced by exp_var(), log_var(), numeric_exp(), numeric_ln(), numeric_sqrt(), power_var(), power_var_int(), and select_div_scale().

◆ NUMERIC_MIN_SIG_DIGITS

#define NUMERIC_MIN_SIG_DIGITS 16

Definition at line 39 of file numeric.h.

Referenced by log_var(), numeric_exp(), numeric_ln(), numeric_sqrt(), power_var(), and select_div_scale().

◆ NumericGetDatum

#define NumericGetDatum ( X ) PointerGetDatum(X)

Definition at line 51 of file numeric.h.

Referenced by cash_numeric(), compareNumeric(), executeItemOptUnwrapTarget(), executeNumericItemMethod(), executeUnaryArithmExpr(), gbt_numeric_penalty(), generate_series_step_numeric(), getArrayIndex(), gin_numeric_cmp(), int8_avg(), int8_avg_serialize(), int8_sum(), iterate_jsonb_values(), jsonb_agg_transfn(), jsonb_float4(), jsonb_float8(), jsonb_int2(), jsonb_int4(), jsonb_int8(), jsonb_numeric(), jsonb_object_agg_transfn(), JsonbHashScalarValue(), JsonbHashScalarValueExtended(), JsonbValue_to_SV(), numeric_absolute(), numeric_avg(), numeric_avg_serialize(), numeric_cash(), numeric_float4(), numeric_float8(), numeric_half_rounded(), numeric_is_less(), numeric_poly_avg(), numeric_poly_serialize(), numeric_serialize(), numeric_shift_right(), numeric_to_char(), numeric_to_cstring(), numeric_to_number(), pg_lsn_mii(), pg_lsn_pli(), pg_size_bytes(), PLyObject_FromJsonbValue(), and printJsonPathItem().

◆ PG_GETARG_NUMERIC

#define PG_GETARG_NUMERIC ( n ) DatumGetNumeric(PG_GETARG_DATUM(n))

Definition at line 52 of file numeric.h.

Referenced by generate_series_step_numeric(), hash_numeric(), hash_numeric_extended(), in_range_numeric_numeric(), int8_sum(), numeric(), numeric_abs(), numeric_accum(), numeric_accum_inv(), numeric_add(), numeric_avg_accum(), numeric_ceil(), numeric_cmp(), numeric_div(), numeric_div_trunc(), numeric_eq(), numeric_exp(), numeric_float4(), numeric_float8(), numeric_float8_no_overflow(), numeric_floor(), numeric_gcd(), numeric_ge(), numeric_gt(), numeric_inc(), numeric_int2(), numeric_int4(), numeric_int8(), numeric_larger(), numeric_lcm(), numeric_le(), numeric_ln(), numeric_log(), numeric_lt(), numeric_min_scale(), numeric_mod(), numeric_mul(), numeric_ne(), numeric_out(), numeric_pg_lsn(), numeric_power(), numeric_round(), numeric_scale(), numeric_send(), numeric_sign(), numeric_smaller(), numeric_sqrt(), numeric_sub(), numeric_to_char(), numeric_trim_scale(), numeric_trunc(), numeric_uminus(), numeric_uplus(), pg_lsn_mii(), pg_lsn_pli(), pg_size_pretty_numeric(), and width_bucket_numeric().

◆ PG_GETARG_NUMERIC_COPY

#define PG_GETARG_NUMERIC_COPY ( n ) DatumGetNumericCopy(PG_GETARG_DATUM(n))

Definition at line 53 of file numeric.h.

◆ PG_RETURN_NUMERIC

#define PG_RETURN_NUMERIC ( x ) return NumericGetDatum(x)

Definition at line 54 of file numeric.h.

Referenced by float4_numeric(), float8_numeric(), int2_numeric(), int4_numeric(), int8_numeric(), int8_sum(), jsonb_numeric(), numeric(), numeric_abs(), numeric_add(), numeric_avg(), numeric_ceil(), numeric_div(), numeric_div_trunc(), numeric_exp(), numeric_fac(), numeric_floor(), numeric_gcd(), numeric_in(), numeric_inc(), numeric_larger(), numeric_lcm(), numeric_ln(), numeric_log(), numeric_mod(), numeric_mul(), numeric_poly_stddev_pop(), numeric_poly_stddev_samp(), numeric_poly_sum(), numeric_poly_var_pop(), numeric_poly_var_samp(), numeric_power(), numeric_recv(), numeric_round(), numeric_sign(), numeric_smaller(), numeric_sqrt(), numeric_stddev_pop(), numeric_stddev_samp(), numeric_sub(), numeric_sum(), numeric_trim_scale(), numeric_trunc(), numeric_uminus(), numeric_uplus(), numeric_var_pop(), numeric_var_samp(), and pg_wal_lsn_diff().

Typedef Documentation

◆ Numeric

typedef struct NumericData* Numeric

Definition at line 43 of file numeric.h.

Function Documentation

◆ int64_to_numeric()

Numeric int64_to_numeric ( int64 val )

Definition at line 4079 of file numeric.c.

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

Referenced by cash_numeric(), executeItemOptUnwrapTarget(), executeKeyValueMethod(), 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(), numeric_avg(), numeric_cash(), numeric_half_rounded(), numeric_poly_avg(), numeric_shift_right(), numeric_to_char(), numeric_to_number(), pg_size_bytes(), pg_size_pretty_numeric(), and SV_to_JsonbValue().

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

◆ numeric_add_opt_error()

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

Definition at line 2730 of file numeric.c.

References add_var(), Assert, free_var(), init_var, init_var_from_num(), make_result(), make_result_opt_error(), NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, and NUMERIC_IS_SPECIAL.

Referenced by executeItemOptUnwrapTarget(), and numeric_add().

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

◆ numeric_div_opt_error()

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

Definition at line 3000 of file numeric.c.

References Assert, NumericVar::digits, div_var(), ereport, errcode(), errmsg(), ERROR, free_var(), init_var, init_var_from_num(), make_result(), make_result_opt_error(), NumericVar::ndigits, NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numeric_sign_internal(), and select_div_scale().

Referenced by executeItemOptUnwrapTarget(), and numeric_div().

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

◆ numeric_int4_opt_error()

int32 numeric_int4_opt_error	(	Numeric	num,
		bool *	error
	)

Definition at line 4104 of file numeric.c.

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

Referenced by getArrayIndex(), and numeric_int4().

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

◆ numeric_is_inf()

bool numeric_is_inf ( Numeric num )

Definition at line 785 of file numeric.c.

References NUMERIC_IS_INF.

Referenced by PLyNumber_ToJsonbValue().

 {
     return NUMERIC_IS_INF(num);
 }

◆ numeric_is_nan()

bool numeric_is_nan ( Numeric num )

Definition at line 774 of file numeric.c.

References NUMERIC_IS_NAN.

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

 {
     return NUMERIC_IS_NAN(num);
 }

◆ numeric_maximum_size()

int32 numeric_maximum_size ( int32 typmod )

Definition at line 820 of file numeric.c.

References DEC_DIGITS, NUMERIC_HDRSZ, and VARHDRSZ.

Referenced by type_maximum_size().

 {
     int         precision;
     int         numeric_digits;
 
     if (typmod < (int32) (VARHDRSZ))
         return -1;
 
     /* precision (ie, max # of digits) is in upper bits of typmod */
     precision = ((typmod - VARHDRSZ) >> 16) & 0xffff;
 
     /*
      * 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));
 }

◆ numeric_mod_opt_error()

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

Definition at line 3224 of file numeric.c.

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

Referenced by executeItemOptUnwrapTarget(), and numeric_mod().

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

◆ numeric_mul_opt_error()

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

Definition at line 2886 of file numeric.c.

References Assert, NumericVar::dscale, free_var(), init_var, init_var_from_num(), make_result(), make_result_opt_error(), mul_var(), NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, and numeric_sign_internal().

Referenced by executeItemOptUnwrapTarget(), and numeric_mul().

 {
     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)).
      */
     init_var_from_num(num1, &arg1);
     init_var_from_num(num2, &arg2);
 
     init_var(&result);
     mul_var(&arg1, &arg2, &result, arg1.dscale + arg2.dscale);
 
     res = make_result_opt_error(&result, have_error);
 
     free_var(&result);
 
     return res;
 }

◆ numeric_normalize()

char* numeric_normalize ( Numeric num )

Definition at line 893 of file numeric.c.

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

Referenced by make_scalar_key().

 {
     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;
 }

◆ numeric_out_sci()

char* numeric_out_sci	(	Numeric	num,
		int	scale
	)

Definition at line 859 of file numeric.c.

References get_str_from_var_sci(), init_var_from_num(), NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, pstrdup(), and generate_unaccent_rules::str.

Referenced by int8_to_char(), and numeric_to_char().

 {
     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;
 }

◆ numeric_sub_opt_error()

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

Definition at line 2808 of file numeric.c.

References Assert, free_var(), init_var, init_var_from_num(), make_result(), make_result_opt_error(), NUMERIC_IS_NAN, NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, and sub_var().

Referenced by executeItemOptUnwrapTarget(), and numeric_sub().

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

Macros

Typedefs

Functions