/src/postgres/src/backend/utils/adt/numeric.c

Source
/*-------------------------------------------------------------------------
 *
 * numeric.c
 *    An exact numeric data type for the Postgres database system
 *
 * Original coding 1998, Jan Wieck.  Heavily revised 2003, Tom Lane.
 *
 * Many of the algorithmic ideas are borrowed from David M. Smith's "FM"
 * multiple-precision math library, most recently published as Algorithm
 * 786: Multiple-Precision Complex Arithmetic and Functions, ACM
 * Transactions on Mathematical Software, Vol. 24, No. 4, December 1998,
 * pages 359-367.
 *
 * Copyright (c) 1998-2026, PostgreSQL Global Development Group
 *
 * IDENTIFICATION
 *    src/backend/utils/adt/numeric.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include <ctype.h>
#include <float.h>
#include <limits.h>
#include <math.h>

#include "common/hashfn.h"
#include "common/int.h"
#include "common/int128.h"
#include "funcapi.h"
#include "lib/hyperloglog.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/nodeFuncs.h"
#include "nodes/supportnodes.h"
#include "optimizer/optimizer.h"
#include "utils/array.h"
#include "utils/builtins.h"
#include "utils/float.h"
#include "utils/guc.h"
#include "utils/numeric.h"
#include "utils/pg_lsn.h"
#include "utils/sortsupport.h"

/* ----------
 * Uncomment the following to enable compilation of dump_numeric()
 * and dump_var() and to get a dump of any result produced by make_result().
 * ----------
 */
/* #define NUMERIC_DEBUG */


/* ----------
 * Local data types
 *
 * Numeric values are represented in a base-NBASE floating point format.
 * Each "digit" ranges from 0 to NBASE-1.  The type NumericDigit is signed
 * and wide enough to store a digit.  We assume that NBASE*NBASE can fit in
 * an int.  Although the purely calculational routines could handle any even
 * NBASE that's less than sqrt(INT_MAX), in practice we are only interested
 * in NBASE a power of ten, so that I/O conversions and decimal rounding
 * are easy.  Also, it's actually more efficient if NBASE is rather less than
 * sqrt(INT_MAX), so that there is "headroom" for mul_var and div_var to
 * postpone processing carries.
 *
 * Values of NBASE other than 10000 are considered of historical interest only
 * and are no longer supported in any sense; no mechanism exists for the client
 * to discover the base, so every client supporting binary mode expects the
 * base-10000 format.  If you plan to change this, also note the numeric
 * abbreviation code, which assumes NBASE=10000.
 * ----------
 */

#if 0
#define NBASE   10
#define HALF_NBASE  5
#define DEC_DIGITS  1     /* decimal digits per NBASE digit */
#define MUL_GUARD_DIGITS  4 /* these are measured in NBASE digits */
#define DIV_GUARD_DIGITS  8

typedef signed char NumericDigit;
#endif

#if 0
#define NBASE   100
#define HALF_NBASE  50
#define DEC_DIGITS  2     /* decimal digits per NBASE digit */
#define MUL_GUARD_DIGITS  3 /* these are measured in NBASE digits */
#define DIV_GUARD_DIGITS  6

typedef signed char NumericDigit;
#endif

#if 1
#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

typedef int16 NumericDigit;
#endif

#define NBASE_SQR (NBASE * NBASE)

/*
 * The Numeric type as stored on disk.
 *
 * If the high bits of the first word of a NumericChoice (n_header, or
 * n_short.n_header, or n_long.n_sign_dscale) are NUMERIC_SHORT, then the
 * numeric follows the NumericShort format; if they are NUMERIC_POS or
 * NUMERIC_NEG, it follows the NumericLong format. If they are NUMERIC_SPECIAL,
 * the value is a NaN or Infinity.  We currently always store SPECIAL values
 * using just two bytes (i.e. only n_header), but previous releases used only
 * the NumericLong format, so we might find 4-byte NaNs (though not infinities)
 * on disk if a database has been migrated using pg_upgrade.  In either case,
 * the low-order bits of a special value's header are reserved and currently
 * should always be set to zero.
 *
 * In the NumericShort format, the remaining 14 bits of the header word
 * (n_short.n_header) are allocated as follows: 1 for sign (positive or
 * negative), 6 for dynamic scale, and 7 for weight.  In practice, most
 * commonly-encountered values can be represented this way.
 *
 * In the NumericLong format, the remaining 14 bits of the header word
 * (n_long.n_sign_dscale) represent the display scale; and the weight is
 * stored separately in n_weight.
 *
 * NOTE: by convention, values in the packed form have been stripped of
 * all leading and trailing zero digits (where a "digit" is of base NBASE).
 * In particular, if the value is zero, there will be no digits at all!
 * The weight is arbitrary in that case, but we normally set it to zero.
 */

struct NumericShort
{
  uint16    n_header;   /* Sign + display scale + weight */
  NumericDigit n_data[FLEXIBLE_ARRAY_MEMBER]; /* Digits */
};

struct NumericLong
{
  uint16    n_sign_dscale;  /* Sign + display scale */
  int16   n_weight;   /* Weight of 1st digit  */
  NumericDigit n_data[FLEXIBLE_ARRAY_MEMBER]; /* Digits */
};

union NumericChoice
{
  uint16    n_header;   /* Header word */
  struct NumericLong n_long;  /* Long form (4-byte header) */
  struct NumericShort n_short;  /* Short form (2-byte header) */
};

struct NumericData
{
  int32   vl_len_;    /* varlena header (do not touch directly!) */
  union NumericChoice choice; /* choice of format */
};


/*
 * Interpretation of high bits.
 */

#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))

/*
 * If the flag bits are NUMERIC_SHORT or NUMERIC_SPECIAL, we want the short
 * header; otherwise, we want the long one.  Instead of testing against each
 * value, we can just look at the high bit, for a slight efficiency gain.
 */
#define NUMERIC_HEADER_IS_SHORT(n)  (((n)->choice.n_header & 0x8000) != 0)
#define NUMERIC_HEADER_SIZE(n) \
  (VARHDRSZ + sizeof(uint16) + \
   (NUMERIC_HEADER_IS_SHORT(n) ? 0 : sizeof(int16)))

/*
 * Definitions for special values (NaN, positive infinity, negative infinity).
 *
 * The two bits after the NUMERIC_SPECIAL bits are 00 for NaN, 01 for positive
 * infinity, 11 for negative infinity.  (This makes the sign bit match where
 * it is in a short-format value, though we make no use of that at present.)
 * We could mask off the remaining bits before testing the active bits, but
 * currently those bits must be zeroes, so masking would just add cycles.
 */
#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)

/*
 * Short format definitions.
 */

#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))

/*
 * Extract sign, display scale, weight.  These macros extract field values
 * suitable for the NumericVar format from the Numeric (on-disk) format.
 *
 * Note that we don't trouble to ensure that dscale and weight read as zero
 * for an infinity; however, that doesn't matter since we never convert
 * "special" numerics to NumericVar form.  Only the constants defined below
 * (const_nan, etc) ever represent a non-finite value as a NumericVar.
 */

#define NUMERIC_DSCALE_MASK     0x3FFF
#define NUMERIC_DSCALE_MAX      NUMERIC_DSCALE_MASK

#define NUMERIC_SIGN(n) \
  (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)))
#define NUMERIC_DSCALE(n) (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))
#define NUMERIC_WEIGHT(n) (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))

/*
 * Maximum weight of a stored Numeric value (based on the use of int16 for the
 * weight in NumericLong).  Note that intermediate values held in NumericVar
 * and NumericSumAccum variables may have much larger weights.
 */
#define NUMERIC_WEIGHT_MAX      PG_INT16_MAX

/* ----------
 * NumericVar is the format we use for arithmetic.  The digit-array part
 * is the same as the NumericData storage format, but the header is more
 * complex.
 *
 * The value represented by a NumericVar is determined by the sign, weight,
 * ndigits, and digits[] array.  If it is a "special" value (NaN or Inf)
 * then only the sign field matters; ndigits should be zero, and the weight
 * and dscale fields are ignored.
 *
 * Note: the first digit of a NumericVar's value is assumed to be multiplied
 * by NBASE ** weight.  Another way to say it is that there are weight+1
 * digits before the decimal point.  It is possible to have weight < 0.
 *
 * buf points at the physical start of the palloc'd digit buffer for the
 * NumericVar.  digits points at the first digit in actual use (the one
 * with the specified weight).  We normally leave an unused digit or two
 * (preset to zeroes) between buf and digits, so that there is room to store
 * a carry out of the top digit without reallocating space.  We just need to
 * decrement digits (and increment weight) to make room for the carry digit.
 * (There is no such extra space in a numeric value stored in the database,
 * only in a NumericVar in memory.)
 *
 * If buf is NULL then the digit buffer isn't actually palloc'd and should
 * not be freed --- see the constants below for an example.
 *
 * dscale, or display scale, is the nominal precision expressed as number
 * of digits after the decimal point (it must always be >= 0 at present).
 * dscale may be more than the number of physically stored fractional digits,
 * implying that we have suppressed storage of significant trailing zeroes.
 * It should never be less than the number of stored digits, since that would
 * imply hiding digits that are present.  NOTE that dscale is always expressed
 * in *decimal* digits, and so it may correspond to a fractional number of
 * base-NBASE digits --- divide by DEC_DIGITS to convert to NBASE digits.
 *
 * rscale, or result scale, is the target precision for a computation.
 * Like dscale it is expressed as number of *decimal* digits after the decimal
 * point, and is always >= 0 at present.
 * Note that rscale is not stored in variables --- it's figured on-the-fly
 * from the dscales of the inputs.
 *
 * While we consistently use "weight" to refer to the base-NBASE weight of
 * a numeric value, it is convenient in some scale-related calculations to
 * make use of the base-10 weight (ie, the approximate log10 of the value).
 * To avoid confusion, such a decimal-units weight is called a "dweight".
 *
 * NB: All the variable-level functions are written in a style that makes it
 * possible to give one and the same variable as argument and destination.
 * This is feasible because the digit buffer is separate from the variable.
 * ----------
 */
typedef struct NumericVar
{
  int     ndigits;    /* # of digits in digits[] - can be 0! */
  int     weight;     /* weight of first digit */
  int     sign;     /* NUMERIC_POS, _NEG, _NAN, _PINF, or _NINF */
  int     dscale;     /* display scale */
  NumericDigit *buf;      /* start of palloc'd space for digits[] */
  NumericDigit *digits;   /* base-NBASE digits */
} NumericVar;


/* ----------
 * Data for generate_series
 * ----------
 */
typedef struct
{
  NumericVar  current;
  NumericVar  stop;
  NumericVar  step;
} generate_series_numeric_fctx;


/* ----------
 * Sort support.
 * ----------
 */
typedef struct
{
  void     *buf;      /* buffer for short varlenas */
  int64   input_count;  /* number of non-null values seen */
  bool    estimating;   /* true if estimating cardinality */

  hyperLogLogState abbr_card; /* cardinality estimator */
} NumericSortSupport;


/* ----------
 * Fast sum accumulator.
 *
 * NumericSumAccum is used to implement SUM(), and other standard aggregates
 * that track the sum of input values.  It uses 32-bit integers to store the
 * digits, instead of the normal 16-bit integers (with NBASE=10000).  This
 * way, we can safely accumulate up to NBASE - 1 values without propagating
 * carry, before risking overflow of any of the digits.  'num_uncarried'
 * tracks how many values have been accumulated without propagating carry.
 *
 * Positive and negative values are accumulated separately, in 'pos_digits'
 * and 'neg_digits'.  This is simpler and faster than deciding whether to add
 * or subtract from the current value, for each new value (see sub_var() for
 * the logic we avoid by doing this).  Both buffers are of same size, and
 * have the same weight and scale.  In accum_sum_final(), the positive and
 * negative sums are added together to produce the final result.
 *
 * When a new value has a larger ndigits or weight than the accumulator
 * currently does, the accumulator is enlarged to accommodate the new value.
 * We normally have one zero digit reserved for carry propagation, and that
 * is indicated by the 'have_carry_space' flag.  When accum_sum_carry() uses
 * up the reserved digit, it clears the 'have_carry_space' flag.  The next
 * call to accum_sum_add() will enlarge the buffer, to make room for the
 * extra digit, and set the flag again.
 *
 * To initialize a new accumulator, simply reset all fields to zeros.
 *
 * The accumulator does not handle NaNs.
 * ----------
 */
typedef struct NumericSumAccum
{
  int     ndigits;
  int     weight;
  int     dscale;
  int     num_uncarried;
  bool    have_carry_space;
  int32    *pos_digits;
  int32    *neg_digits;
} NumericSumAccum;


/*
 * We define our own macros for packing and unpacking abbreviated-key
 * representations, just to have a notational indication that that's
 * what we're doing.  Now that sizeof(Datum) is always 8, we can rely
 * on fitting an int64 into Datum.
 *
 * The range of abbreviations for finite values is from +PG_INT64_MAX
 * to -PG_INT64_MAX.  NaN has the abbreviation PG_INT64_MIN, and we
 * define the sort ordering to make that work out properly (see further
 * comments below).  PINF and NINF share the abbreviations of the largest
 * and smallest finite abbreviation classes.
 */
#define NumericAbbrevGetDatum(X) Int64GetDatum(X)
#define DatumGetNumericAbbrev(X) DatumGetInt64(X)
#define NUMERIC_ABBREV_NAN     NumericAbbrevGetDatum(PG_INT64_MIN)
#define NUMERIC_ABBREV_PINF    NumericAbbrevGetDatum(-PG_INT64_MAX)
#define NUMERIC_ABBREV_NINF    NumericAbbrevGetDatum(PG_INT64_MAX)


/* ----------
 * Some preinitialized constants
 * ----------
 */
static const NumericDigit const_zero_data[1] = {0};
static const NumericVar const_zero =
{0, 0, NUMERIC_POS, 0, NULL, unconstify_constexpr(NumericDigit *, const_zero_data)};

static const NumericDigit const_one_data[1] = {1};
static const NumericVar const_one =
{1, 0, NUMERIC_POS, 0, NULL, unconstify_constexpr(NumericDigit *, const_one_data)};

static const NumericVar const_minus_one =
{1, 0, NUMERIC_NEG, 0, NULL, unconstify_constexpr(NumericDigit *, const_one_data)};

static const NumericDigit const_two_data[1] = {2};
static const NumericVar const_two =
{1, 0, NUMERIC_POS, 0, NULL, unconstify_constexpr(NumericDigit *, const_two_data)};

#if DEC_DIGITS == 4
static const NumericDigit const_zero_point_nine_data[1] = {9000};
#elif DEC_DIGITS == 2
static const NumericDigit const_zero_point_nine_data[1] = {90};
#elif DEC_DIGITS == 1
static const NumericDigit const_zero_point_nine_data[1] = {9};
#endif
static const NumericVar const_zero_point_nine =
{1, -1, NUMERIC_POS, 1, NULL, unconstify_constexpr(NumericDigit *, const_zero_point_nine_data)};

#if DEC_DIGITS == 4
static const NumericDigit const_one_point_one_data[2] = {1, 1000};
#elif DEC_DIGITS == 2
static const NumericDigit const_one_point_one_data[2] = {1, 10};
#elif DEC_DIGITS == 1
static const NumericDigit const_one_point_one_data[2] = {1, 1};
#endif
static const NumericVar const_one_point_one =
{2, 0, NUMERIC_POS, 1, NULL, unconstify_constexpr(NumericDigit *, const_one_point_one_data)};

static const NumericVar const_nan =
{0, 0, NUMERIC_NAN, 0, NULL, NULL};

static const NumericVar const_pinf =
{0, 0, NUMERIC_PINF, 0, NULL, NULL};

static const NumericVar const_ninf =
{0, 0, NUMERIC_NINF, 0, NULL, NULL};

#if DEC_DIGITS == 4
static const int round_powers[4] = {0, 1000, 100, 10};
#endif


/* ----------
 * Local functions
 * ----------
 */

#ifdef NUMERIC_DEBUG
static void dump_numeric(const char *str, Numeric num);
static void dump_var(const char *str, NumericVar *var);
#else
#define dump_numeric(s,n)
#define dump_var(s,v)
#endif

#define digitbuf_alloc(ndigits)  \
  (palloc_array(NumericDigit, (ndigits)))
#define digitbuf_free(buf)  \
  do { \
     if ((buf) != NULL) \
       pfree(buf); \
  } while (0)

#define init_var(v)   memset(v, 0, sizeof(NumericVar))

#define NUMERIC_DIGITS(num) (NUMERIC_HEADER_IS_SHORT(num) ? \
  (num)->choice.n_short.n_data : (num)->choice.n_long.n_data)
#define NUMERIC_NDIGITS(num) \
  ((VARSIZE(num) - NUMERIC_HEADER_SIZE(num)) / sizeof(NumericDigit))
#define NUMERIC_CAN_BE_SHORT(scale,weight) \
  ((scale) <= NUMERIC_SHORT_DSCALE_MAX && \
  (weight) <= NUMERIC_SHORT_WEIGHT_MAX && \
  (weight) >= NUMERIC_SHORT_WEIGHT_MIN)

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_safe(const NumericVar *var, Node *escontext);

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 void int128_to_numericvar(INT128 val, NumericVar *var);
static double numericvar_to_double_no_overflow(const NumericVar *var);

static Datum numeric_abbrev_convert(Datum original_datum, SortSupport ssup);
static bool numeric_abbrev_abort(int memtupcount, SortSupport ssup);
static int  numeric_fast_cmp(Datum x, Datum y, SortSupport ssup);
static int  numeric_cmp_abbrev(Datum x, Datum y, SortSupport ssup);

static Datum numeric_abbrev_convert_var(const NumericVar *var,
                    NumericSortSupport *nss);

static int  cmp_numerics(Numeric num1, Numeric num2);
static int  cmp_var(const NumericVar *var1, const NumericVar *var2);
static int  cmp_var_common(const NumericDigit *var1digits, int var1ndigits,
               int var1weight, int var1sign,
               const NumericDigit *var2digits, int var2ndigits,
               int var2weight, int var2sign);
static void add_var(const NumericVar *var1, const NumericVar *var2,
          NumericVar *result);
static void sub_var(const NumericVar *var1, const NumericVar *var2,
          NumericVar *result);
static void mul_var(const NumericVar *var1, const NumericVar *var2,
          NumericVar *result,
          int rscale);
static void mul_var_short(const NumericVar *var1, const NumericVar *var2,
              NumericVar *result);
static void div_var(const NumericVar *var1, const NumericVar *var2,
          NumericVar *result, int rscale, bool round, bool exact);
static void div_var_int(const NumericVar *var, int ival, int ival_weight,
            NumericVar *result, int rscale, bool round);
#ifdef HAVE_INT128
static void div_var_int64(const NumericVar *var, int64 ival, int ival_weight,
              NumericVar *result, int rscale, bool round);
#endif
static int  select_div_scale(const NumericVar *var1, const NumericVar *var2);
static void mod_var(const NumericVar *var1, const NumericVar *var2,
          NumericVar *result);
static void div_mod_var(const NumericVar *var1, const NumericVar *var2,
            NumericVar *quot, NumericVar *rem);
static void ceil_var(const NumericVar *var, NumericVar *result);
static void floor_var(const NumericVar *var, NumericVar *result);

static void gcd_var(const NumericVar *var1, const NumericVar *var2,
          NumericVar *result);
static void sqrt_var(const NumericVar *arg, NumericVar *result, int rscale);
static void exp_var(const NumericVar *arg, NumericVar *result, int rscale);
static int  estimate_ln_dweight(const NumericVar *var);
static void ln_var(const NumericVar *arg, NumericVar *result, int rscale);
static void log_var(const NumericVar *base, const NumericVar *num,
          NumericVar *result);
static void power_var(const NumericVar *base, const NumericVar *exp,
            NumericVar *result);
static void power_var_int(const NumericVar *base, int exp, int exp_dscale,
              NumericVar *result);
static void power_ten_int(int exp, NumericVar *result);
static void random_var(pg_prng_state *state, const NumericVar *rmin,
             const NumericVar *rmax, NumericVar *result);

static int  cmp_abs(const NumericVar *var1, const NumericVar *var2);
static int  cmp_abs_common(const NumericDigit *var1digits, int var1ndigits,
               int var1weight,
               const NumericDigit *var2digits, int var2ndigits,
               int var2weight);
static void add_abs(const NumericVar *var1, const NumericVar *var2,
          NumericVar *result);
static void sub_abs(const NumericVar *var1, const NumericVar *var2,
          NumericVar *result);
static void round_var(NumericVar *var, int rscale);
static void trunc_var(NumericVar *var, int rscale);
static void strip_var(NumericVar *var);
static void compute_bucket(Numeric operand, Numeric bound1, Numeric bound2,
               const NumericVar *count_var,
               NumericVar *result_var);

static void accum_sum_add(NumericSumAccum *accum, const NumericVar *val);
static void accum_sum_rescale(NumericSumAccum *accum, const NumericVar *val);
static void accum_sum_carry(NumericSumAccum *accum);
static void accum_sum_reset(NumericSumAccum *accum);
static void accum_sum_final(NumericSumAccum *accum, NumericVar *result);
static void accum_sum_copy(NumericSumAccum *dst, NumericSumAccum *src);
static void accum_sum_combine(NumericSumAccum *accum, NumericSumAccum *accum2);


/* ----------------------------------------------------------------------
 *
 * Input-, output- and rounding-functions
 *
 * ----------------------------------------------------------------------
 */


/*
 * numeric_in() -
 *
 *  Input function for numeric data type
 */
Datum
numeric_in(PG_FUNCTION_ARGS)
{
  char     *str = PG_GETARG_CSTRING(0);
#ifdef NOT_USED
  Oid     typelem = PG_GETARG_OID(1);
#endif
  int32   typmod = PG_GETARG_INT32(2);
  Node     *escontext = fcinfo->context;
  Numeric   res;
  const char *cp;
  const char *numstart;
  int     sign;

  /* Skip leading spaces */
  cp = str;
  while (*cp)
  {
    if (!isspace((unsigned char) *cp))
      break;
    cp++;
  }

  /*
   * Process the number's sign. This duplicates logic in set_var_from_str(),
   * but it's worth doing here, since it simplifies the handling of
   * infinities and non-decimal integers.
   */
  numstart = cp;
  sign = NUMERIC_POS;

  if (*cp == '+')
    cp++;
  else if (*cp == '-')
  {
    sign = NUMERIC_NEG;
    cp++;
  }

  /*
   * Check for NaN and infinities.  We recognize the same strings allowed by
   * float8in().
   *
   * Since all other legal inputs have a digit or a decimal point after the
   * sign, we need only check for NaN/infinity if that's not the case.
   */
  if (!isdigit((unsigned char) *cp) && *cp != '.')
  {
    /*
     * The number must be NaN or infinity; anything else can only be a
     * syntax error. Note that NaN mustn't have a sign.
     */
    if (pg_strncasecmp(numstart, "NaN", 3) == 0)
    {
      res = make_result(&const_nan);
      cp = numstart + 3;
    }
    else if (pg_strncasecmp(cp, "Infinity", 8) == 0)
    {
      res = make_result(sign == NUMERIC_POS ? &const_pinf : &const_ninf);
      cp += 8;
    }
    else if (pg_strncasecmp(cp, "inf", 3) == 0)
    {
      res = make_result(sign == NUMERIC_POS ? &const_pinf : &const_ninf);
      cp += 3;
    }
    else
      goto invalid_syntax;

    /*
     * Check for trailing junk; there should be nothing left but spaces.
     *
     * We intentionally do this check before applying the typmod because
     * we would like to throw any trailing-junk syntax error before any
     * semantic error resulting from apply_typmod_special().
     */
    while (*cp)
    {
      if (!isspace((unsigned char) *cp))
        goto invalid_syntax;
      cp++;
    }

    if (!apply_typmod_special(res, typmod, escontext))
      PG_RETURN_NULL();
  }
  else
  {
    /*
     * We have a normal numeric value, which may be a non-decimal integer
     * or a regular decimal number.
     */
    NumericVar  value;
    int     base;

    init_var(&value);

    /*
     * Determine the number's base by looking for a non-decimal prefix
     * indicator ("0x", "0o", or "0b").
     */
    if (cp[0] == '0')
    {
      switch (cp[1])
      {
        case 'x':
        case 'X':
          base = 16;
          break;
        case 'o':
        case 'O':
          base = 8;
          break;
        case 'b':
        case 'B':
          base = 2;
          break;
        default:
          base = 10;
      }
    }
    else
      base = 10;

    /* Parse the rest of the number and apply the sign */
    if (base == 10)
    {
      if (!set_var_from_str(str, cp, &value, &cp, escontext))
        PG_RETURN_NULL();
      value.sign = sign;
    }
    else
    {
      if (!set_var_from_non_decimal_integer_str(str, cp + 2, sign, base,
                            &value, &cp, escontext))
        PG_RETURN_NULL();
    }

    /*
     * Should be nothing left but spaces. As above, throw any typmod error
     * after finishing syntax check.
     */
    while (*cp)
    {
      if (!isspace((unsigned char) *cp))
        goto invalid_syntax;
      cp++;
    }

    if (!apply_typmod(&value, typmod, escontext))
      PG_RETURN_NULL();

    res = make_result_safe(&value, escontext);

    free_var(&value);
  }

  PG_RETURN_NUMERIC(res);

invalid_syntax:
  ereturn(escontext, (Datum) 0,
      (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
       errmsg("invalid input syntax for type %s: \"%s\"",
          "numeric", str)));
}


/*
 * numeric_out() -
 *
 *  Output function for numeric data type
 */
Datum
numeric_out(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  NumericVar  x;
  char     *str;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num))
  {
    if (NUMERIC_IS_PINF(num))
      PG_RETURN_CSTRING(pstrdup("Infinity"));
    else if (NUMERIC_IS_NINF(num))
      PG_RETURN_CSTRING(pstrdup("-Infinity"));
    else
      PG_RETURN_CSTRING(pstrdup("NaN"));
  }

  /*
   * Get the number in the variable format.
   */
  init_var_from_num(num, &x);

  str = get_str_from_var(&x);

  PG_RETURN_CSTRING(str);
}

/*
 * numeric_is_nan() -
 *
 *  Is Numeric value a NaN?
 */
bool
numeric_is_nan(Numeric num)
{
  return NUMERIC_IS_NAN(num);
}

/*
 * numeric_is_inf() -
 *
 *  Is Numeric value an infinity?
 */
bool
numeric_is_inf(Numeric num)
{
  return NUMERIC_IS_INF(num);
}

/*
 * numeric_is_integral() -
 *
 *  Is Numeric value integral?
 */
static bool
numeric_is_integral(Numeric num)
{
  NumericVar  arg;

  /* Reject NaN, but infinities are considered integral */
  if (NUMERIC_IS_SPECIAL(num))
  {
    if (NUMERIC_IS_NAN(num))
      return false;
    return true;
  }

  /* Integral if there are no digits to the right of the decimal point */
  init_var_from_num(num, &arg);

  return (arg.ndigits == 0 || arg.ndigits <= arg.weight + 1);
}

/*
 * make_numeric_typmod() -
 *
 *  Pack numeric precision and scale values into a typmod.  The upper 16 bits
 *  are used for the precision (though actually not all these bits are needed,
 *  since the maximum allowed precision is 1000).  The lower 16 bits are for
 *  the scale, but since the scale is constrained to the range [-1000, 1000],
 *  we use just the lower 11 of those 16 bits, and leave the remaining 5 bits
 *  unset, for possible future use.
 *
 *  For purely historical reasons VARHDRSZ is then added to the result, thus
 *  the unused space in the upper 16 bits is not all as freely available as it
 *  might seem.  (We can't let the result overflow to a negative int32, as
 *  other parts of the system would interpret that as not-a-valid-typmod.)
 */
static inline int32
make_numeric_typmod(int precision, int scale)
{
  return ((precision << 16) | (scale & 0x7ff)) + VARHDRSZ;
}

/*
 * Because of the offset, valid numeric typmods are at least VARHDRSZ
 */
static inline bool
is_valid_numeric_typmod(int32 typmod)
{
  return typmod >= (int32) VARHDRSZ;
}

/*
 * numeric_typmod_precision() -
 *
 *  Extract the precision from a numeric typmod --- see make_numeric_typmod().
 */
static inline int
numeric_typmod_precision(int32 typmod)
{
  return ((typmod - VARHDRSZ) >> 16) & 0xffff;
}

/*
 * numeric_typmod_scale() -
 *
 *  Extract the scale from a numeric typmod --- see make_numeric_typmod().
 *
 *  Note that the scale may be negative, so we must do sign extension when
 *  unpacking it.  We do this using the bit hack (x^1024)-1024, which sign
 *  extends an 11-bit two's complement number x.
 */
static inline int
numeric_typmod_scale(int32 typmod)
{
  return (((typmod - VARHDRSZ) & 0x7ff) ^ 1024) - 1024;
}

/*
 * numeric_maximum_size() -
 *
 *  Maximum size of a numeric with given typmod, or -1 if unlimited/unknown.
 */
int32
numeric_maximum_size(int32 typmod)
{
  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));
}

/*
 * numeric_out_sci() -
 *
 *  Output function for numeric data type in scientific notation.
 */
char *
numeric_out_sci(Numeric num, int scale)
{
  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_normalize() -
 *
 *  Output function for numeric data type, suppressing insignificant trailing
 *  zeroes and then any trailing decimal point.  The intent of this is to
 *  produce strings that are equal if and only if the input numeric values
 *  compare equal.
 */
char *
numeric_normalize(Numeric num)
{
  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_recv      - converts external binary format to numeric
 *
 * External format is a sequence of int16's:
 * ndigits, weight, sign, dscale, NumericDigits.
 */
Datum
numeric_recv(PG_FUNCTION_ARGS)
{
  StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);

#ifdef NOT_USED
  Oid     typelem = PG_GETARG_OID(1);
#endif
  int32   typmod = PG_GETARG_INT32(2);
  NumericVar  value;
  Numeric   res;
  int     len,
        i;

  init_var(&value);

  len = (uint16) pq_getmsgint(buf, sizeof(uint16));

  alloc_var(&value, len);

  value.weight = (int16) pq_getmsgint(buf, sizeof(int16));
  /* we allow any int16 for weight --- OK? */

  value.sign = (uint16) pq_getmsgint(buf, sizeof(uint16));
  if (!(value.sign == NUMERIC_POS ||
      value.sign == NUMERIC_NEG ||
      value.sign == NUMERIC_NAN ||
      value.sign == NUMERIC_PINF ||
      value.sign == NUMERIC_NINF))
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
         errmsg("invalid sign in external \"numeric\" value")));

  value.dscale = (uint16) pq_getmsgint(buf, sizeof(uint16));
  if ((value.dscale & NUMERIC_DSCALE_MASK) != value.dscale)
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
         errmsg("invalid scale in external \"numeric\" value")));

  for (i = 0; i < len; i++)
  {
    NumericDigit d = pq_getmsgint(buf, sizeof(NumericDigit));

    if (d < 0 || d >= NBASE)
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
           errmsg("invalid digit in external \"numeric\" value")));
    value.digits[i] = d;
  }

  /*
   * If the given dscale would hide any digits, truncate those digits away.
   * We could alternatively throw an error, but that would take a bunch of
   * extra code (about as much as trunc_var involves), and it might cause
   * client compatibility issues.  Be careful not to apply trunc_var to
   * special values, as it could do the wrong thing; we don't need it
   * anyway, since make_result will ignore all but the sign field.
   *
   * After doing that, be sure to check the typmod restriction.
   */
  if (value.sign == NUMERIC_POS ||
    value.sign == NUMERIC_NEG)
  {
    trunc_var(&value, value.dscale);

    (void) apply_typmod(&value, typmod, NULL);

    res = make_result(&value);
  }
  else
  {
    /* apply_typmod_special wants us to make the Numeric first */
    res = make_result(&value);

    (void) apply_typmod_special(res, typmod, NULL);
  }

  free_var(&value);

  PG_RETURN_NUMERIC(res);
}

/*
 *    numeric_send      - converts numeric to binary format
 */
Datum
numeric_send(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  NumericVar  x;
  StringInfoData buf;
  int     i;

  init_var_from_num(num, &x);

  pq_begintypsend(&buf);

  pq_sendint16(&buf, x.ndigits);
  pq_sendint16(&buf, x.weight);
  pq_sendint16(&buf, x.sign);
  pq_sendint16(&buf, x.dscale);
  for (i = 0; i < x.ndigits; i++)
    pq_sendint16(&buf, x.digits[i]);

  PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}


/*
 * numeric_support()
 *
 * Planner support function for the numeric() length coercion function.
 *
 * Flatten calls that solely represent increases in allowable precision.
 * Scale changes mutate every datum, so they are unoptimizable.  Some values,
 * e.g. 1E-1001, can only fit into an unconstrained numeric, so a change from
 * an unconstrained numeric to any constrained numeric is also unoptimizable.
 */
Datum
numeric_support(PG_FUNCTION_ARGS)
{
  Node     *rawreq = (Node *) PG_GETARG_POINTER(0);
  Node     *ret = NULL;

  if (IsA(rawreq, SupportRequestSimplify))
  {
    SupportRequestSimplify *req = (SupportRequestSimplify *) rawreq;
    FuncExpr   *expr = req->fcall;
    Node     *typmod;

    Assert(list_length(expr->args) >= 2);

    typmod = (Node *) lsecond(expr->args);

    if (IsA(typmod, Const) && !((Const *) typmod)->constisnull)
    {
      Node     *source = (Node *) linitial(expr->args);
      int32   old_typmod = exprTypmod(source);
      int32   new_typmod = DatumGetInt32(((Const *) typmod)->constvalue);
      int32   old_scale = numeric_typmod_scale(old_typmod);
      int32   new_scale = numeric_typmod_scale(new_typmod);
      int32   old_precision = numeric_typmod_precision(old_typmod);
      int32   new_precision = numeric_typmod_precision(new_typmod);

      /*
       * If new_typmod is invalid, the destination is unconstrained;
       * that's always OK.  If old_typmod is valid, the source is
       * constrained, and we're OK if the scale is unchanged and the
       * precision is not decreasing.  See further notes in function
       * header comment.
       */
      if (!is_valid_numeric_typmod(new_typmod) ||
        (is_valid_numeric_typmod(old_typmod) &&
         new_scale == old_scale && new_precision >= old_precision))
        ret = relabel_to_typmod(source, new_typmod);
    }
  }

  PG_RETURN_POINTER(ret);
}

/*
 * numeric() -
 *
 *  This is a special function called by the Postgres database system
 *  before a value is stored in a tuple's attribute. The precision and
 *  scale of the attribute have to be applied on the value.
 */
Datum
numeric   (PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  int32   typmod = PG_GETARG_INT32(1);
  Numeric   new;
  int     precision;
  int     scale;
  int     ddigits;
  int     maxdigits;
  int     dscale;
  NumericVar  var;

  /*
   * Handle NaN and infinities: if apply_typmod_special doesn't complain,
   * just return a copy of the input.
   */
  if (NUMERIC_IS_SPECIAL(num))
  {
    if (!apply_typmod_special(num, typmod, fcinfo->context))
      PG_RETURN_NULL();
    PG_RETURN_NUMERIC(duplicate_numeric(num));
  }

  /*
   * If the value isn't a valid type modifier, simply return a copy of the
   * input value
   */
  if (!is_valid_numeric_typmod(typmod))
    PG_RETURN_NUMERIC(duplicate_numeric(num));

  /*
   * Get the precision and scale out of the typmod value
   */
  precision = numeric_typmod_precision(typmod);
  scale = numeric_typmod_scale(typmod);
  maxdigits = precision - scale;

  /* The target display scale is non-negative */
  dscale = Max(scale, 0);

  /*
   * If the number is certainly in bounds and due to the target scale no
   * rounding could be necessary, just make a copy of the input and modify
   * its scale fields, unless the larger scale forces us to abandon the
   * short representation.  (Note we assume the existing dscale is
   * honest...)
   */
  ddigits = (NUMERIC_WEIGHT(num) + 1) * DEC_DIGITS;
  if (ddigits <= maxdigits && scale >= NUMERIC_DSCALE(num)
    && (NUMERIC_CAN_BE_SHORT(dscale, NUMERIC_WEIGHT(num))
      || !NUMERIC_IS_SHORT(num)))
  {
    new = duplicate_numeric(num);
    if (NUMERIC_IS_SHORT(num))
      new->choice.n_short.n_header =
        (num->choice.n_short.n_header & ~NUMERIC_SHORT_DSCALE_MASK)
        | (dscale << NUMERIC_SHORT_DSCALE_SHIFT);
    else
      new->choice.n_long.n_sign_dscale = NUMERIC_SIGN(new) |
        ((uint16) dscale & NUMERIC_DSCALE_MASK);
    PG_RETURN_NUMERIC(new);
  }

  /*
   * We really need to fiddle with things - unpack the number into a
   * variable and let apply_typmod() do it.
   */
  init_var(&var);

  set_var_from_num(num, &var);
  if (!apply_typmod(&var, typmod, fcinfo->context))
    PG_RETURN_NULL();
  new = make_result_safe(&var, fcinfo->context);

  free_var(&var);

  PG_RETURN_NUMERIC(new);
}

/*
 * make_numeric_typmod_safe() -
 *
 *  Validate a numeric precision/scale and pack them into a typmod value,
 *  with soft error handling.
 */
int32
make_numeric_typmod_safe(int32 precision, int32 scale, Node *escontext)
{
  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);
}

Datum
numerictypmodin(PG_FUNCTION_ARGS)
{
  ArrayType  *ta = PG_GETARG_ARRAYTYPE_P(0);
  int32    *tl;
  int     n;
  int32   typmod;

  tl = ArrayGetIntegerTypmods(ta, &n);

  if (n == 2)
    typmod = make_numeric_typmod_safe(tl[0], tl[1], NULL);
  else if (n == 1)
  {
    /* scale defaults to zero */
    typmod = make_numeric_typmod_safe(tl[0], 0, NULL);
  }
  else
  {
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
         errmsg("invalid NUMERIC type modifier")));
    typmod = 0;       /* keep compiler quiet */
  }

  PG_RETURN_INT32(typmod);
}

Datum
numerictypmodout(PG_FUNCTION_ARGS)
{
  int32   typmod = PG_GETARG_INT32(0);
  char     *res = (char *) palloc(64);

  if (is_valid_numeric_typmod(typmod))
    snprintf(res, 64, "(%d,%d)",
         numeric_typmod_precision(typmod),
         numeric_typmod_scale(typmod));
  else
    *res = '\0';

  PG_RETURN_CSTRING(res);
}


/* ----------------------------------------------------------------------
 *
 * Sign manipulation, rounding and the like
 *
 * ----------------------------------------------------------------------
 */

Datum
numeric_abs(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  Numeric   res;

  /*
   * Do it the easy way directly on the packed format
   */
  res = duplicate_numeric(num);

  if (NUMERIC_IS_SHORT(num))
    res->choice.n_short.n_header =
      num->choice.n_short.n_header & ~NUMERIC_SHORT_SIGN_MASK;
  else if (NUMERIC_IS_SPECIAL(num))
  {
    /* This changes -Inf to Inf, and doesn't affect NaN */
    res->choice.n_short.n_header =
      num->choice.n_short.n_header & ~NUMERIC_INF_SIGN_MASK;
  }
  else
    res->choice.n_long.n_sign_dscale = NUMERIC_POS | NUMERIC_DSCALE(num);

  PG_RETURN_NUMERIC(res);
}


Datum
numeric_uminus(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  Numeric   res;

  /*
   * Do it the easy way directly on the packed format
   */
  res = duplicate_numeric(num);

  if (NUMERIC_IS_SPECIAL(num))
  {
    /* Flip the sign, if it's Inf or -Inf */
    if (!NUMERIC_IS_NAN(num))
      res->choice.n_short.n_header =
        num->choice.n_short.n_header ^ NUMERIC_INF_SIGN_MASK;
  }

  /*
   * The packed format is known to be totally zero digit trimmed always. So
   * once we've eliminated specials, we can identify a zero by the fact that
   * there are no digits at all. Do nothing to a zero.
   */
  else if (NUMERIC_NDIGITS(num) != 0)
  {
    /* Else, flip the sign */
    if (NUMERIC_IS_SHORT(num))
      res->choice.n_short.n_header =
        num->choice.n_short.n_header ^ NUMERIC_SHORT_SIGN_MASK;
    else if (NUMERIC_SIGN(num) == NUMERIC_POS)
      res->choice.n_long.n_sign_dscale =
        NUMERIC_NEG | NUMERIC_DSCALE(num);
    else
      res->choice.n_long.n_sign_dscale =
        NUMERIC_POS | NUMERIC_DSCALE(num);
  }

  PG_RETURN_NUMERIC(res);
}


Datum
numeric_uplus(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);

  PG_RETURN_NUMERIC(duplicate_numeric(num));
}


/*
 * numeric_sign_internal() -
 *
 * Returns -1 if the argument is less than 0, 0 if the argument is equal
 * to 0, and 1 if the argument is greater than zero.  Caller must have
 * taken care of the NaN case, but we can handle infinities here.
 */
static int
numeric_sign_internal(Numeric num)
{
  if (NUMERIC_IS_SPECIAL(num))
  {
    Assert(!NUMERIC_IS_NAN(num));
    /* Must be Inf or -Inf */
    if (NUMERIC_IS_PINF(num))
      return 1;
    else
      return -1;
  }

  /*
   * The packed format is known to be totally zero digit trimmed always. So
   * once we've eliminated specials, we can identify a zero by the fact that
   * there are no digits at all.
   */
  else if (NUMERIC_NDIGITS(num) == 0)
    return 0;
  else if (NUMERIC_SIGN(num) == NUMERIC_NEG)
    return -1;
  else
    return 1;
}

/*
 * numeric_sign() -
 *
 * returns -1 if the argument is less than 0, 0 if the argument is equal
 * to 0, and 1 if the argument is greater than zero.
 */
Datum
numeric_sign(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);

  /*
   * Handle NaN (infinities can be handled normally)
   */
  if (NUMERIC_IS_NAN(num))
    PG_RETURN_NUMERIC(make_result(&const_nan));

  switch (numeric_sign_internal(num))
  {
    case 0:
      PG_RETURN_NUMERIC(make_result(&const_zero));
    case 1:
      PG_RETURN_NUMERIC(make_result(&const_one));
    case -1:
      PG_RETURN_NUMERIC(make_result(&const_minus_one));
  }

  Assert(false);
  return (Datum) 0;
}


/*
 * numeric_round() -
 *
 *  Round a value to have 'scale' digits after the decimal point.
 *  We allow negative 'scale', implying rounding before the decimal
 *  point --- Oracle interprets rounding that way.
 */
Datum
numeric_round(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  int32   scale = PG_GETARG_INT32(1);
  Numeric   res;
  NumericVar  arg;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num))
    PG_RETURN_NUMERIC(duplicate_numeric(num));

  /*
   * Limit the scale value to avoid possible overflow in calculations.
   *
   * These limits are based on the maximum number of digits a Numeric value
   * can have before and after the decimal point, but we must allow for one
   * extra digit before the decimal point, in case the most significant
   * digit rounds up; we must check if that causes Numeric overflow.
   */
  scale = Max(scale, -(NUMERIC_WEIGHT_MAX + 1) * DEC_DIGITS - 1);
  scale = Min(scale, NUMERIC_DSCALE_MAX);

  /*
   * Unpack the argument and round it at the proper digit position
   */
  init_var(&arg);
  set_var_from_num(num, &arg);

  round_var(&arg, scale);

  /* We don't allow negative output dscale */
  if (scale < 0)
    arg.dscale = 0;

  /*
   * Return the rounded result
   */
  res = make_result(&arg);

  free_var(&arg);
  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_trunc() -
 *
 *  Truncate a value to have 'scale' digits after the decimal point.
 *  We allow negative 'scale', implying a truncation before the decimal
 *  point --- Oracle interprets truncation that way.
 */
Datum
numeric_trunc(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  int32   scale = PG_GETARG_INT32(1);
  Numeric   res;
  NumericVar  arg;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num))
    PG_RETURN_NUMERIC(duplicate_numeric(num));

  /*
   * Limit the scale value to avoid possible overflow in calculations.
   *
   * These limits are based on the maximum number of digits a Numeric value
   * can have before and after the decimal point.
   */
  scale = Max(scale, -(NUMERIC_WEIGHT_MAX + 1) * DEC_DIGITS);
  scale = Min(scale, NUMERIC_DSCALE_MAX);

  /*
   * Unpack the argument and truncate it at the proper digit position
   */
  init_var(&arg);
  set_var_from_num(num, &arg);

  trunc_var(&arg, scale);

  /* We don't allow negative output dscale */
  if (scale < 0)
    arg.dscale = 0;

  /*
   * Return the truncated result
   */
  res = make_result(&arg);

  free_var(&arg);
  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_ceil() -
 *
 *  Return the smallest integer greater than or equal to the argument
 */
Datum
numeric_ceil(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  Numeric   res;
  NumericVar  result;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num))
    PG_RETURN_NUMERIC(duplicate_numeric(num));

  init_var_from_num(num, &result);
  ceil_var(&result, &result);

  res = make_result(&result);
  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_floor() -
 *
 *  Return the largest integer equal to or less than the argument
 */
Datum
numeric_floor(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  Numeric   res;
  NumericVar  result;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num))
    PG_RETURN_NUMERIC(duplicate_numeric(num));

  init_var_from_num(num, &result);
  floor_var(&result, &result);

  res = make_result(&result);
  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


/*
 * generate_series_numeric() -
 *
 *  Generate series of numeric.
 */
Datum
generate_series_numeric(PG_FUNCTION_ARGS)
{
  return generate_series_step_numeric(fcinfo);
}

Datum
generate_series_step_numeric(PG_FUNCTION_ARGS)
{
  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 = palloc_object(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);
}

/*
 * Planner support function for generate_series(numeric, numeric [, numeric])
 */
Datum
generate_series_numeric_support(PG_FUNCTION_ARGS)
{
  Node     *rawreq = (Node *) PG_GETARG_POINTER(0);
  Node     *ret = NULL;

  if (IsA(rawreq, SupportRequestRows))
  {
    /* Try to estimate the number of rows returned */
    SupportRequestRows *req = (SupportRequestRows *) rawreq;

    if (is_funcclause(req->node)) /* be paranoid */
    {
      List     *args = ((FuncExpr *) req->node)->args;
      Node     *arg1,
             *arg2,
             *arg3;

      /* We can use estimated argument values here */
      arg1 = estimate_expression_value(req->root, linitial(args));
      arg2 = estimate_expression_value(req->root, lsecond(args));
      if (list_length(args) >= 3)
        arg3 = estimate_expression_value(req->root, lthird(args));
      else
        arg3 = NULL;

      /*
       * If any argument is constant NULL, we can safely assume that
       * zero rows are returned.  Otherwise, if they're all non-NULL
       * constants, we can calculate the number of rows that will be
       * returned.
       */
      if ((IsA(arg1, Const) &&
         ((Const *) arg1)->constisnull) ||
        (IsA(arg2, Const) &&
         ((Const *) arg2)->constisnull) ||
        (arg3 != NULL && IsA(arg3, Const) &&
         ((Const *) arg3)->constisnull))
      {
        req->rows = 0;
        ret = (Node *) req;
      }
      else if (IsA(arg1, Const) &&
           IsA(arg2, Const) &&
           (arg3 == NULL || IsA(arg3, Const)))
      {
        Numeric   start_num;
        Numeric   stop_num;
        NumericVar  step = const_one;

        /*
         * If any argument is NaN or infinity, generate_series() will
         * error out, so we needn't produce an estimate.
         */
        start_num = DatumGetNumeric(((Const *) arg1)->constvalue);
        stop_num = DatumGetNumeric(((Const *) arg2)->constvalue);

        if (NUMERIC_IS_SPECIAL(start_num) ||
          NUMERIC_IS_SPECIAL(stop_num))
          PG_RETURN_POINTER(NULL);

        if (arg3)
        {
          Numeric   step_num;

          step_num = DatumGetNumeric(((Const *) arg3)->constvalue);

          if (NUMERIC_IS_SPECIAL(step_num))
            PG_RETURN_POINTER(NULL);

          init_var_from_num(step_num, &step);
        }

        /*
         * The number of rows that will be returned is given by
         * floor((stop - start) / step) + 1, if the sign of step
         * matches the sign of stop - start.  Otherwise, no rows will
         * be returned.
         */
        if (cmp_var(&step, &const_zero) != 0)
        {
          NumericVar  start;
          NumericVar  stop;
          NumericVar  res;

          init_var_from_num(start_num, &start);
          init_var_from_num(stop_num, &stop);

          init_var(&res);
          sub_var(&stop, &start, &res);

          if (step.sign != res.sign)
          {
            /* no rows will be returned */
            req->rows = 0;
            ret = (Node *) req;
          }
          else
          {
            if (arg3)
              div_var(&res, &step, &res, 0, false, false);
            else
              trunc_var(&res, 0); /* step = 1 */

            req->rows = numericvar_to_double_no_overflow(&res) + 1;
            ret = (Node *) req;
          }

          free_var(&res);
        }
      }
    }
  }

  PG_RETURN_POINTER(ret);
}


/*
 * Implements the numeric version of the width_bucket() function
 * defined by SQL2003. See also width_bucket_float8().
 *
 * 'bound1' and 'bound2' are the lower and upper bounds of the
 * histogram's range, respectively. 'count' is the number of buckets
 * in the histogram. width_bucket() returns an integer indicating the
 * bucket number that 'operand' belongs to in an equiwidth histogram
 * with the specified characteristics. An operand smaller than the
 * lower bound is assigned to bucket 0. An operand greater than or equal
 * to the upper bound is assigned to an additional bucket (with number
 * count+1). We don't allow the histogram bounds to be NaN or +/- infinity,
 * but we do allow those values for the operand (taking NaN to be larger
 * than any other value, as we do in comparisons).
 */
Datum
width_bucket_numeric(PG_FUNCTION_ARGS)
{
  Numeric   operand = PG_GETARG_NUMERIC(0);
  Numeric   bound1 = PG_GETARG_NUMERIC(1);
  Numeric   bound2 = PG_GETARG_NUMERIC(2);
  int32   count = PG_GETARG_INT32(3);
  NumericVar  count_var;
  NumericVar  result_var;
  int32   result;

  if (count <= 0)
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
         errmsg("count must be greater than zero")));

  if (NUMERIC_IS_SPECIAL(bound1) || NUMERIC_IS_SPECIAL(bound2))
  {
    if (NUMERIC_IS_NAN(bound1) || NUMERIC_IS_NAN(bound2))
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
           errmsg("lower and upper bounds cannot be NaN")));

    if (NUMERIC_IS_INF(bound1) || NUMERIC_IS_INF(bound2))
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
           errmsg("lower and upper bounds must be finite")));
  }

  init_var(&result_var);
  init_var(&count_var);

  /* Convert 'count' to a numeric, for ease of use later */
  int64_to_numericvar((int64) count, &count_var);

  switch (cmp_numerics(bound1, bound2))
  {
    case 0:
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_ARGUMENT_FOR_WIDTH_BUCKET_FUNCTION),
           errmsg("lower bound cannot equal upper bound")));
      break;

      /* bound1 < bound2 */
    case -1:
      if (cmp_numerics(operand, bound1) < 0)
        set_var_from_var(&const_zero, &result_var);
      else if (cmp_numerics(operand, bound2) >= 0)
        add_var(&count_var, &const_one, &result_var);
      else
        compute_bucket(operand, bound1, bound2, &count_var,
                 &result_var);
      break;

      /* bound1 > bound2 */
    case 1:
      if (cmp_numerics(operand, bound1) > 0)
        set_var_from_var(&const_zero, &result_var);
      else if (cmp_numerics(operand, bound2) <= 0)
        add_var(&count_var, &const_one, &result_var);
      else
        compute_bucket(operand, bound1, bound2, &count_var,
                 &result_var);
      break;
  }

  /* if result exceeds the range of a legal int4, we ereport here */
  if (!numericvar_to_int32(&result_var, &result))
    ereport(ERROR,
        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
         errmsg("integer out of range")));

  free_var(&count_var);
  free_var(&result_var);

  PG_RETURN_INT32(result);
}

/*
 * 'operand' is inside the bucket range, so determine the correct
 * bucket for it to go in. The calculations performed by this function
 * are derived directly from the SQL2003 spec. Note however that we
 * multiply by count before dividing, to avoid unnecessary roundoff error.
 */
static void
compute_bucket(Numeric operand, Numeric bound1, Numeric bound2,
         const NumericVar *count_var, NumericVar *result_var)
{
  NumericVar  bound1_var;
  NumericVar  bound2_var;
  NumericVar  operand_var;

  init_var_from_num(bound1, &bound1_var);
  init_var_from_num(bound2, &bound2_var);
  init_var_from_num(operand, &operand_var);

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

  mul_var(&operand_var, count_var, &operand_var,
      operand_var.dscale + count_var->dscale);
  div_var(&operand_var, &bound2_var, result_var, 0, false, true);
  add_var(result_var, &const_one, result_var);

  free_var(&bound1_var);
  free_var(&bound2_var);
  free_var(&operand_var);
}

/* ----------------------------------------------------------------------
 *
 * Comparison functions
 *
 * Note: btree indexes need these routines not to leak memory; therefore,
 * be careful to free working copies of toasted datums.  Most places don't
 * need to be so careful.
 *
 * Sort support:
 *
 * We implement the sortsupport strategy routine in order to get the benefit of
 * abbreviation. The ordinary numeric comparison can be quite slow as a result
 * of palloc/pfree cycles (due to detoasting packed values for alignment);
 * while this could be worked on itself, the abbreviation strategy gives more
 * speedup in many common cases.
 *
 * The abbreviated format is an int64. The representation is negated relative
 * to the original value, because we use the largest negative value for NaN,
 * which sorts higher than other values. We convert the absolute value of the
 * numeric to a 63-bit positive value, and then negate it if the original
 * number was positive.
 *
 * We abort the abbreviation process if the abbreviation cardinality is below
 * 0.01% of the row count (1 per 10k non-null rows).  The actual break-even
 * point is somewhat below that, perhaps 1 per 30k (at 1 per 100k there's a
 * very small penalty), but we don't want to build up too many abbreviated
 * values before first testing for abort, so we take the slightly pessimistic
 * number.  We make no attempt to estimate the cardinality of the real values,
 * since it plays no part in the cost model here (if the abbreviation is equal,
 * the cost of comparing equal and unequal underlying values is comparable).
 * We discontinue even checking for abort (saving us the hashing overhead) if
 * the estimated cardinality gets to 100k; that would be enough to support many
 * billions of rows while doing no worse than breaking even.
 *
 * ----------------------------------------------------------------------
 */

/*
 * Sort support strategy routine.
 */
Datum
numeric_sortsupport(PG_FUNCTION_ARGS)
{
  SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);

  ssup->comparator = numeric_fast_cmp;

  if (ssup->abbreviate)
  {
    NumericSortSupport *nss;
    MemoryContext oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);

    nss = palloc_object(NumericSortSupport);

    /*
     * palloc a buffer for handling unaligned packed values in addition to
     * the support struct
     */
    nss->buf = palloc(VARATT_SHORT_MAX + VARHDRSZ + 1);

    nss->input_count = 0;
    nss->estimating = true;
    initHyperLogLog(&nss->abbr_card, 10);

    ssup->ssup_extra = nss;

    ssup->abbrev_full_comparator = ssup->comparator;
    ssup->comparator = numeric_cmp_abbrev;
    ssup->abbrev_converter = numeric_abbrev_convert;
    ssup->abbrev_abort = numeric_abbrev_abort;

    MemoryContextSwitchTo(oldcontext);
  }

  PG_RETURN_VOID();
}

/*
 * Abbreviate a numeric datum, handling NaNs and detoasting
 * (must not leak memory!)
 */
static Datum
numeric_abbrev_convert(Datum original_datum, SortSupport ssup)
{
  NumericSortSupport *nss = ssup->ssup_extra;
  void     *original_varatt = PG_DETOAST_DATUM_PACKED(original_datum);
  Numeric   value;
  Datum   result;

  nss->input_count += 1;

  /*
   * This is to handle packed datums without needing a palloc/pfree cycle;
   * we keep and reuse a buffer large enough to handle any short datum.
   */
  if (VARATT_IS_SHORT(original_varatt))
  {
    void     *buf = nss->buf;
    Size    sz = VARSIZE_SHORT(original_varatt) - VARHDRSZ_SHORT;

    Assert(sz <= VARATT_SHORT_MAX - VARHDRSZ_SHORT);

    SET_VARSIZE(buf, VARHDRSZ + sz);
    memcpy(VARDATA(buf), VARDATA_SHORT(original_varatt), sz);

    value = (Numeric) buf;
  }
  else
    value = (Numeric) original_varatt;

  if (NUMERIC_IS_SPECIAL(value))
  {
    if (NUMERIC_IS_PINF(value))
      result = NUMERIC_ABBREV_PINF;
    else if (NUMERIC_IS_NINF(value))
      result = NUMERIC_ABBREV_NINF;
    else
      result = NUMERIC_ABBREV_NAN;
  }
  else
  {
    NumericVar  var;

    init_var_from_num(value, &var);

    result = numeric_abbrev_convert_var(&var, nss);
  }

  /* should happen only for external/compressed toasts */
  if (original_varatt != DatumGetPointer(original_datum))
    pfree(original_varatt);

  return result;
}

/*
 * Consider whether to abort abbreviation.
 *
 * We pay no attention to the cardinality of the non-abbreviated data. There is
 * no reason to do so: unlike text, we have no fast check for equal values, so
 * we pay the full overhead whenever the abbreviations are equal regardless of
 * whether the underlying values are also equal.
 */
static bool
numeric_abbrev_abort(int memtupcount, SortSupport ssup)
{
  NumericSortSupport *nss = ssup->ssup_extra;
  double    abbr_card;

  if (memtupcount < 10000 || nss->input_count < 10000 || !nss->estimating)
    return false;

  abbr_card = estimateHyperLogLog(&nss->abbr_card);

  /*
   * If we have >100k distinct values, then even if we were sorting many
   * billion rows we'd likely still break even, and the penalty of undoing
   * that many rows of abbrevs would probably not be worth it. Stop even
   * counting at that point.
   */
  if (abbr_card > 100000.0)
  {
    if (trace_sort)
      elog(LOG,
         "numeric_abbrev: estimation ends at cardinality %f"
         " after " INT64_FORMAT " values (%d rows)",
         abbr_card, nss->input_count, memtupcount);
    nss->estimating = false;
    return false;
  }

  /*
   * Target minimum cardinality is 1 per ~10k of non-null inputs.  (The
   * break even point is somewhere between one per 100k rows, where
   * abbreviation has a very slight penalty, and 1 per 10k where it wins by
   * a measurable percentage.)  We use the relatively pessimistic 10k
   * threshold, and add a 0.5 row fudge factor, because it allows us to
   * abort earlier on genuinely pathological data where we've had exactly
   * one abbreviated value in the first 10k (non-null) rows.
   */
  if (abbr_card < nss->input_count / 10000.0 + 0.5)
  {
    if (trace_sort)
      elog(LOG,
         "numeric_abbrev: aborting abbreviation at cardinality %f"
         " below threshold %f after " INT64_FORMAT " values (%d rows)",
         abbr_card, nss->input_count / 10000.0 + 0.5,
         nss->input_count, memtupcount);
    return true;
  }

  if (trace_sort)
    elog(LOG,
       "numeric_abbrev: cardinality %f"
       " after " INT64_FORMAT " values (%d rows)",
       abbr_card, nss->input_count, memtupcount);

  return false;
}

/*
 * Non-fmgr interface to the comparison routine to allow sortsupport to elide
 * the fmgr call.  The saving here is small given how slow numeric comparisons
 * are, but it is a required part of the sort support API when abbreviations
 * are performed.
 *
 * Two palloc/pfree cycles could be saved here by using persistent buffers for
 * aligning short-varlena inputs, but this has not so far been considered to
 * be worth the effort.
 */
static int
numeric_fast_cmp(Datum x, Datum y, SortSupport ssup)
{
  Numeric   nx = DatumGetNumeric(x);
  Numeric   ny = DatumGetNumeric(y);
  int     result;

  result = cmp_numerics(nx, ny);

  if (nx != DatumGetPointer(x))
    pfree(nx);
  if (ny != DatumGetPointer(y))
    pfree(ny);

  return result;
}

/*
 * Compare abbreviations of values. (Abbreviations may be equal where the true
 * values differ, but if the abbreviations differ, they must reflect the
 * ordering of the true values.)
 */
static int
numeric_cmp_abbrev(Datum x, Datum y, SortSupport ssup)
{
  /*
   * NOTE WELL: this is intentionally backwards, because the abbreviation is
   * negated relative to the original value, to handle NaN/infinity cases.
   */
  if (DatumGetNumericAbbrev(x) < DatumGetNumericAbbrev(y))
    return 1;
  if (DatumGetNumericAbbrev(x) > DatumGetNumericAbbrev(y))
    return -1;
  return 0;
}

/*
 * Abbreviate a NumericVar into the 64-bit sortsupport size.
 *
 * The 31-bit value is constructed as:
 *
 *  0 + 7bits digit weight + 24 bits digit value
 *
 * where the digit weight is in single decimal digits, not digit words, and
 * stored in excess-44 representation[1]. The 24-bit digit value is the 7 most
 * significant decimal digits of the value converted to binary. Values whose
 * weights would fall outside the representable range are rounded off to zero
 * (which is also used to represent actual zeros) or to 0x7FFFFFFF (which
 * otherwise cannot occur). Abbreviation therefore fails to gain any advantage
 * where values are outside the range 10^-44 to 10^83, which is not considered
 * to be a serious limitation, or when values are of the same magnitude and
 * equal in the first 7 decimal digits, which is considered to be an
 * unavoidable limitation given the available bits. (Stealing three more bits
 * to compare another digit would narrow the range of representable weights by
 * a factor of 8, which starts to look like a real limiting factor.)
 *
 * (The value 44 for the excess is essentially arbitrary)
 *
 * The 63-bit value is constructed as:
 *
 *  0 + 7bits weight + 4 x 14-bit packed digit words
 *
 * The weight in this case is again stored in excess-44, but this time it is
 * the original weight in digit words (i.e. powers of 10000). The first four
 * digit words of the value (if present; trailing zeros are assumed as needed)
 * are packed into 14 bits each to form the rest of the value. Again,
 * out-of-range values are rounded off to 0 or 0x7FFFFFFFFFFFFFFF. The
 * representable range in this case is 10^-176 to 10^332, which is considered
 * to be good enough for all practical purposes, and comparison of 4 words
 * means that at least 13 decimal digits are compared, which is considered to
 * be a reasonable compromise between effectiveness and efficiency in computing
 * the abbreviation.
 *
 * (The value 44 for the excess is even more arbitrary here, it was chosen just
 * to match the value used in the 31-bit case)
 *
 * [1] - Excess-k representation means that the value is offset by adding 'k'
 * and then treated as unsigned, so the smallest representable value is stored
 * with all bits zero. This allows simple comparisons to work on the composite
 * value.
 */
static Datum
numeric_abbrev_convert_var(const NumericVar *var, NumericSortSupport *nss)
{
  int     ndigits = var->ndigits;
  int     weight = var->weight;
  int64   result;

  if (ndigits == 0 || weight < -44)
  {
    result = 0;
  }
  else if (weight > 83)
  {
    result = PG_INT64_MAX;
  }
  else
  {
    result = ((int64) (weight + 44) << 56);

    switch (ndigits)
    {
      default:
        result |= ((int64) var->digits[3]);
        pg_fallthrough;
      case 3:
        result |= ((int64) var->digits[2]) << 14;
        pg_fallthrough;
      case 2:
        result |= ((int64) var->digits[1]) << 28;
        pg_fallthrough;
      case 1:
        result |= ((int64) var->digits[0]) << 42;
        break;
    }
  }

  /* the abbrev is negated relative to the original */
  if (var->sign == NUMERIC_POS)
    result = -result;

  if (nss->estimating)
    addHyperLogLog(&nss->abbr_card,
             (uint32) murmurhash64((uint64) result));

  return NumericAbbrevGetDatum(result);
}


/*
 * Ordinary (non-sortsupport) comparisons follow.
 */

Datum
numeric_cmp(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  int     result;

  result = cmp_numerics(num1, num2);

  PG_FREE_IF_COPY(num1, 0);
  PG_FREE_IF_COPY(num2, 1);

  PG_RETURN_INT32(result);
}


Datum
numeric_eq(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  bool    result;

  result = cmp_numerics(num1, num2) == 0;

  PG_FREE_IF_COPY(num1, 0);
  PG_FREE_IF_COPY(num2, 1);

  PG_RETURN_BOOL(result);
}

Datum
numeric_ne(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  bool    result;

  result = cmp_numerics(num1, num2) != 0;

  PG_FREE_IF_COPY(num1, 0);
  PG_FREE_IF_COPY(num2, 1);

  PG_RETURN_BOOL(result);
}

Datum
numeric_gt(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  bool    result;

  result = cmp_numerics(num1, num2) > 0;

  PG_FREE_IF_COPY(num1, 0);
  PG_FREE_IF_COPY(num2, 1);

  PG_RETURN_BOOL(result);
}

Datum
numeric_ge(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  bool    result;

  result = cmp_numerics(num1, num2) >= 0;

  PG_FREE_IF_COPY(num1, 0);
  PG_FREE_IF_COPY(num2, 1);

  PG_RETURN_BOOL(result);
}

Datum
numeric_lt(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  bool    result;

  result = cmp_numerics(num1, num2) < 0;

  PG_FREE_IF_COPY(num1, 0);
  PG_FREE_IF_COPY(num2, 1);

  PG_RETURN_BOOL(result);
}

Datum
numeric_le(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  bool    result;

  result = cmp_numerics(num1, num2) <= 0;

  PG_FREE_IF_COPY(num1, 0);
  PG_FREE_IF_COPY(num2, 1);

  PG_RETURN_BOOL(result);
}

static int
cmp_numerics(Numeric num1, Numeric num2)
{
  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;
}

/*
 * in_range support function for numeric.
 */
Datum
in_range_numeric_numeric(PG_FUNCTION_ARGS)
{
  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);
}

Datum
hash_numeric(PG_FUNCTION_ARGS)
{
  Numeric   key = PG_GETARG_NUMERIC(0);
  uint32    digit_hash;
  uint32    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_bytes((unsigned char *) (NUMERIC_DIGITS(key)
                         + start_offset),
              hash_len * sizeof(NumericDigit));

  /* Mix in the weight, via XOR */
  result = digit_hash ^ weight;

  PG_RETURN_UINT32(result);
}

/*
 * Returns 64-bit value by hashing a value to a 64-bit value, with a seed.
 * Otherwise, similar to hash_numeric.
 */
Datum
hash_numeric_extended(PG_FUNCTION_ARGS)
{
  Numeric   key = PG_GETARG_NUMERIC(0);
  uint64    seed = PG_GETARG_INT64(1);
  uint64    digit_hash;
  uint64    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_bytes_extended((unsigned char *) (NUMERIC_DIGITS(key)
                            + start_offset),
                   hash_len * sizeof(NumericDigit),
                   seed);

  result = digit_hash ^ weight;

  PG_RETURN_UINT64(result);
}


/* ----------------------------------------------------------------------
 *
 * Basic arithmetic functions
 *
 * ----------------------------------------------------------------------
 */


/*
 * numeric_add() -
 *
 *  Add two numerics
 */
Datum
numeric_add(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  Numeric   res;

  res = numeric_add_safe(num1, num2, NULL);

  PG_RETURN_NUMERIC(res);
}

/*
 * numeric_add_safe() -
 *
 *  Internal version of numeric_add() with support for soft error reporting.
 */
Numeric
numeric_add_safe(Numeric num1, Numeric num2, Node *escontext)
{
  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;
}


/*
 * numeric_sub() -
 *
 *  Subtract one numeric from another
 */
Datum
numeric_sub(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  Numeric   res;

  res = numeric_sub_safe(num1, num2, NULL);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_sub_safe() -
 *
 *  Internal version of numeric_sub() with support for soft error reporting.
 */
Numeric
numeric_sub_safe(Numeric num1, Numeric num2, Node *escontext)
{
  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;
}


/*
 * numeric_mul() -
 *
 *  Calculate the product of two numerics
 */
Datum
numeric_mul(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  Numeric   res;

  res = numeric_mul_safe(num1, num2, fcinfo->context);

  if (unlikely(SOFT_ERROR_OCCURRED(fcinfo->context)))
    PG_RETURN_NULL();

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_mul_safe() -
 *
 *  Internal version of numeric_mul() with support for soft error reporting.
 */
Numeric
numeric_mul_safe(Numeric num1, Numeric num2, Node *escontext)
{
  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;
}


/*
 * numeric_div() -
 *
 *  Divide one numeric into another
 */
Datum
numeric_div(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  Numeric   res;

  res = numeric_div_safe(num1, num2, NULL);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_div_safe() -
 *
 *  Internal version of numeric_div() with support for soft error reporting.
 */
Numeric
numeric_div_safe(Numeric num1, Numeric num2, Node *escontext)
{
  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"));
}


/*
 * numeric_div_trunc() -
 *
 *  Divide one numeric into another, truncating the result to an integer
 */
Datum
numeric_div_trunc(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  NumericVar  arg1;
  NumericVar  arg2;
  NumericVar  result;
  Numeric   res;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
  {
    if (NUMERIC_IS_NAN(num1) || NUMERIC_IS_NAN(num2))
      PG_RETURN_NUMERIC(make_result(&const_nan));
    if (NUMERIC_IS_PINF(num1))
    {
      if (NUMERIC_IS_SPECIAL(num2))
        PG_RETURN_NUMERIC(make_result(&const_nan)); /* Inf / [-]Inf */
      switch (numeric_sign_internal(num2))
      {
        case 0:
          ereport(ERROR,
              (errcode(ERRCODE_DIVISION_BY_ZERO),
               errmsg("division by zero")));
          break;
        case 1:
          PG_RETURN_NUMERIC(make_result(&const_pinf));
        case -1:
          PG_RETURN_NUMERIC(make_result(&const_ninf));
      }
      Assert(false);
    }
    if (NUMERIC_IS_NINF(num1))
    {
      if (NUMERIC_IS_SPECIAL(num2))
        PG_RETURN_NUMERIC(make_result(&const_nan)); /* -Inf / [-]Inf */
      switch (numeric_sign_internal(num2))
      {
        case 0:
          ereport(ERROR,
              (errcode(ERRCODE_DIVISION_BY_ZERO),
               errmsg("division by zero")));
          break;
        case 1:
          PG_RETURN_NUMERIC(make_result(&const_ninf));
        case -1:
          PG_RETURN_NUMERIC(make_result(&const_pinf));
      }
      Assert(false);
    }
    /* by here, num1 must be finite, so num2 is not */

    /*
     * POSIX would have us return zero or minus zero if num1 is zero, and
     * otherwise throw an underflow error.  But the numeric type doesn't
     * really do underflow, so let's just return zero.
     */
    PG_RETURN_NUMERIC(make_result(&const_zero));
  }

  /*
   * Unpack the arguments
   */
  init_var_from_num(num1, &arg1);
  init_var_from_num(num2, &arg2);

  init_var(&result);

  /*
   * Do the divide and return the result
   */
  div_var(&arg1, &arg2, &result, 0, false, true);

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_mod() -
 *
 *  Calculate the modulo of two numerics
 */
Datum
numeric_mod(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  Numeric   res;

  res = numeric_mod_safe(num1, num2, NULL);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_mod_safe() -
 *
 *  Internal version of numeric_mod() with support for soft error reporting.
 */
Numeric
numeric_mod_safe(Numeric num1, Numeric num2, Node *escontext)
{
  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"));
}


/*
 * numeric_inc() -
 *
 *  Increment a number by one
 */
Datum
numeric_inc(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  NumericVar  arg;
  Numeric   res;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num))
    PG_RETURN_NUMERIC(duplicate_numeric(num));

  /*
   * Compute the result and return it
   */
  init_var_from_num(num, &arg);

  add_var(&arg, &const_one, &arg);

  res = make_result(&arg);

  free_var(&arg);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_smaller() -
 *
 *  Return the smaller of two numbers
 */
Datum
numeric_smaller(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);

  /*
   * Use cmp_numerics so that this will agree with the comparison operators,
   * particularly as regards comparisons involving NaN.
   */
  if (cmp_numerics(num1, num2) < 0)
    PG_RETURN_NUMERIC(num1);
  else
    PG_RETURN_NUMERIC(num2);
}


/*
 * numeric_larger() -
 *
 *  Return the larger of two numbers
 */
Datum
numeric_larger(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);

  /*
   * Use cmp_numerics so that this will agree with the comparison operators,
   * particularly as regards comparisons involving NaN.
   */
  if (cmp_numerics(num1, num2) > 0)
    PG_RETURN_NUMERIC(num1);
  else
    PG_RETURN_NUMERIC(num2);
}


/* ----------------------------------------------------------------------
 *
 * Advanced math functions
 *
 * ----------------------------------------------------------------------
 */

/*
 * numeric_gcd() -
 *
 *  Calculate the greatest common divisor of two numerics
 */
Datum
numeric_gcd(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  NumericVar  arg1;
  NumericVar  arg2;
  NumericVar  result;
  Numeric   res;

  /*
   * Handle NaN and infinities: we consider the result to be NaN in all such
   * cases.
   */
  if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
    PG_RETURN_NUMERIC(make_result(&const_nan));

  /*
   * Unpack the arguments
   */
  init_var_from_num(num1, &arg1);
  init_var_from_num(num2, &arg2);

  init_var(&result);

  /*
   * Find the GCD and return the result
   */
  gcd_var(&arg1, &arg2, &result);

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_lcm() -
 *
 *  Calculate the least common multiple of two numerics
 */
Datum
numeric_lcm(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  NumericVar  arg1;
  NumericVar  arg2;
  NumericVar  result;
  Numeric   res;

  /*
   * Handle NaN and infinities: we consider the result to be NaN in all such
   * cases.
   */
  if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
    PG_RETURN_NUMERIC(make_result(&const_nan));

  /*
   * Unpack the arguments
   */
  init_var_from_num(num1, &arg1);
  init_var_from_num(num2, &arg2);

  init_var(&result);

  /*
   * Compute the result using lcm(x, y) = abs(x / gcd(x, y) * y), returning
   * zero if either input is zero.
   *
   * Note that the division is guaranteed to be exact, returning an integer
   * result, so the LCM is an integral multiple of both x and y.  A display
   * scale of Min(x.dscale, y.dscale) would be sufficient to represent it,
   * but as with other numeric functions, we choose to return a result whose
   * display scale is no smaller than either input.
   */
  if (arg1.ndigits == 0 || arg2.ndigits == 0)
    set_var_from_var(&const_zero, &result);
  else
  {
    gcd_var(&arg1, &arg2, &result);
    div_var(&arg1, &result, &result, 0, false, true);
    mul_var(&arg2, &result, &result, arg2.dscale);
    result.sign = NUMERIC_POS;
  }

  result.dscale = Max(arg1.dscale, arg2.dscale);

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_fac()
 *
 * Compute factorial
 */
Datum
numeric_fac(PG_FUNCTION_ARGS)
{
  int64   num = PG_GETARG_INT64(0);
  Numeric   res;
  NumericVar  fact;
  NumericVar  result;

  if (num < 0)
    ereport(ERROR,
        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
         errmsg("factorial of a negative number is undefined")));
  if (num <= 1)
  {
    res = make_result(&const_one);
    PG_RETURN_NUMERIC(res);
  }
  /* Fail immediately if the result would overflow */
  if (num > 32177)
    ereport(ERROR,
        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
         errmsg("value overflows numeric format")));

  init_var(&fact);
  init_var(&result);

  int64_to_numericvar(num, &result);

  for (num = num - 1; num > 1; num--)
  {
    /* this loop can take awhile, so allow it to be interrupted */
    CHECK_FOR_INTERRUPTS();

    int64_to_numericvar(num, &fact);

    mul_var(&result, &fact, &result, 0);
  }

  res = make_result(&result);

  free_var(&fact);
  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_sqrt() -
 *
 *  Compute the square root of a numeric.
 */
Datum
numeric_sqrt(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  Numeric   res;
  NumericVar  arg;
  NumericVar  result;
  int     sweight;
  int     rscale;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num))
  {
    /* error should match that in sqrt_var() */
    if (NUMERIC_IS_NINF(num))
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
           errmsg("cannot take square root of a negative number")));
    /* For NAN or PINF, just duplicate the input */
    PG_RETURN_NUMERIC(duplicate_numeric(num));
  }

  /*
   * Unpack the argument and determine the result scale.  We choose a scale
   * to give at least NUMERIC_MIN_SIG_DIGITS significant digits; but in any
   * case not less than the input's dscale.
   */
  init_var_from_num(num, &arg);

  init_var(&result);

  /*
   * Assume the input was normalized, so arg.weight is accurate.  The result
   * then has at least sweight = floor(arg.weight * DEC_DIGITS / 2 + 1)
   * digits before the decimal point.  When DEC_DIGITS is even, we can save
   * a few cycles, since the division is exact and there is no need to round
   * towards negative infinity.
   */
#if DEC_DIGITS == ((DEC_DIGITS / 2) * 2)
  sweight = arg.weight * DEC_DIGITS / 2 + 1;
#else
  if (arg.weight >= 0)
    sweight = arg.weight * DEC_DIGITS / 2 + 1;
  else
    sweight = 1 - (1 - arg.weight * DEC_DIGITS) / 2;
#endif

  rscale = NUMERIC_MIN_SIG_DIGITS - sweight;
  rscale = Max(rscale, arg.dscale);
  rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
  rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);

  /*
   * Let sqrt_var() do the calculation and return the result.
   */
  sqrt_var(&arg, &result, rscale);

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_exp() -
 *
 *  Raise e to the power of x
 */
Datum
numeric_exp(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  Numeric   res;
  NumericVar  arg;
  NumericVar  result;
  int     rscale;
  double    val;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num))
  {
    /* Per POSIX, exp(-Inf) is zero */
    if (NUMERIC_IS_NINF(num))
      PG_RETURN_NUMERIC(make_result(&const_zero));
    /* For NAN or PINF, just duplicate the input */
    PG_RETURN_NUMERIC(duplicate_numeric(num));
  }

  /*
   * Unpack the argument and determine the result scale.  We choose a scale
   * to give at least NUMERIC_MIN_SIG_DIGITS significant digits; but in any
   * case not less than the input's dscale.
   */
  init_var_from_num(num, &arg);

  init_var(&result);

  /* convert input to float8, ignoring overflow */
  val = numericvar_to_double_no_overflow(&arg);

  /*
   * log10(result) = num * log10(e), so this is approximately the decimal
   * weight of the result:
   */
  val *= 0.434294481903252;

  /* limit to something that won't cause integer overflow */
  val = Max(val, -NUMERIC_MAX_RESULT_SCALE);
  val = Min(val, NUMERIC_MAX_RESULT_SCALE);

  rscale = NUMERIC_MIN_SIG_DIGITS - (int) val;
  rscale = Max(rscale, arg.dscale);
  rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
  rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);

  /*
   * Let exp_var() do the calculation and return the result.
   */
  exp_var(&arg, &result, rscale);

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_ln() -
 *
 *  Compute the natural logarithm of x
 */
Datum
numeric_ln(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  Numeric   res;
  NumericVar  arg;
  NumericVar  result;
  int     ln_dweight;
  int     rscale;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num))
  {
    if (NUMERIC_IS_NINF(num))
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
           errmsg("cannot take logarithm of a negative number")));
    /* For NAN or PINF, just duplicate the input */
    PG_RETURN_NUMERIC(duplicate_numeric(num));
  }

  init_var_from_num(num, &arg);
  init_var(&result);

  /* Estimated dweight of logarithm */
  ln_dweight = estimate_ln_dweight(&arg);

  rscale = NUMERIC_MIN_SIG_DIGITS - ln_dweight;
  rscale = Max(rscale, arg.dscale);
  rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
  rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);

  ln_var(&arg, &result, rscale);

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_log() -
 *
 *  Compute the logarithm of x in a given base
 */
Datum
numeric_log(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  Numeric   res;
  NumericVar  arg1;
  NumericVar  arg2;
  NumericVar  result;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
  {
    int     sign1,
          sign2;

    if (NUMERIC_IS_NAN(num1) || NUMERIC_IS_NAN(num2))
      PG_RETURN_NUMERIC(make_result(&const_nan));
    /* fail on negative inputs including -Inf, as log_var would */
    sign1 = numeric_sign_internal(num1);
    sign2 = numeric_sign_internal(num2);
    if (sign1 < 0 || sign2 < 0)
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
           errmsg("cannot take logarithm of a negative number")));
    /* fail on zero inputs, as log_var would */
    if (sign1 == 0 || sign2 == 0)
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
           errmsg("cannot take logarithm of zero")));
    if (NUMERIC_IS_PINF(num1))
    {
      /* log(Inf, Inf) reduces to Inf/Inf, so it's NaN */
      if (NUMERIC_IS_PINF(num2))
        PG_RETURN_NUMERIC(make_result(&const_nan));
      /* log(Inf, finite-positive) is zero (we don't throw underflow) */
      PG_RETURN_NUMERIC(make_result(&const_zero));
    }
    Assert(NUMERIC_IS_PINF(num2));

    /*
     * For a finite-positive base, log(base, Inf) = Inf / ln(base), so the
     * sign depends on whether base is more or less than 1.  If base = 1,
     * fall through and let log_var report the error.
     */
    init_var_from_num(num1, &arg1);
    sign1 = cmp_var(&arg1, &const_one);
    if (sign1 < 0)
      PG_RETURN_NUMERIC(make_result(&const_ninf));
    if (sign1 > 0)
      PG_RETURN_NUMERIC(make_result(&const_pinf));
  }

  /*
   * Initialize things
   */
  init_var_from_num(num1, &arg1);
  init_var_from_num(num2, &arg2);
  init_var(&result);

  /*
   * Call log_var() to compute and return the result; note it handles scale
   * selection itself.
   */
  log_var(&arg1, &arg2, &result);

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


/*
 * numeric_power() -
 *
 *  Raise x to the power of y
 */
Datum
numeric_power(PG_FUNCTION_ARGS)
{
  Numeric   num1 = PG_GETARG_NUMERIC(0);
  Numeric   num2 = PG_GETARG_NUMERIC(1);
  Numeric   res;
  NumericVar  arg1;
  NumericVar  arg2;
  NumericVar  result;
  int     sign1,
        sign2;

  /*
   * Handle NaN and infinities
   */
  if (NUMERIC_IS_SPECIAL(num1) || NUMERIC_IS_SPECIAL(num2))
  {
    /*
     * We follow the POSIX spec for pow(3), which says that NaN ^ 0 = 1,
     * and 1 ^ NaN = 1, while all other cases with NaN inputs yield NaN
     * (with no error).
     */
    if (NUMERIC_IS_NAN(num1))
    {
      if (!NUMERIC_IS_SPECIAL(num2))
      {
        init_var_from_num(num2, &arg2);
        if (cmp_var(&arg2, &const_zero) == 0)
          PG_RETURN_NUMERIC(make_result(&const_one));
      }
      PG_RETURN_NUMERIC(make_result(&const_nan));
    }
    if (NUMERIC_IS_NAN(num2))
    {
      if (!NUMERIC_IS_SPECIAL(num1))
      {
        init_var_from_num(num1, &arg1);
        if (cmp_var(&arg1, &const_one) == 0)
          PG_RETURN_NUMERIC(make_result(&const_one));
      }
      PG_RETURN_NUMERIC(make_result(&const_nan));
    }
    /* At least one input is infinite, but error rules still apply */
    sign1 = numeric_sign_internal(num1);
    sign2 = numeric_sign_internal(num2);
    if (sign1 == 0 && sign2 < 0)
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
           errmsg("zero raised to a negative power is undefined")));
    if (sign1 < 0 && !numeric_is_integral(num2))
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
           errmsg("a negative number raised to a non-integer power yields a complex result")));

    /*
     * POSIX gives this series of rules for pow(3) with infinite inputs:
     *
     * For any value of y, if x is +1, 1.0 shall be returned.
     */
    if (!NUMERIC_IS_SPECIAL(num1))
    {
      init_var_from_num(num1, &arg1);
      if (cmp_var(&arg1, &const_one) == 0)
        PG_RETURN_NUMERIC(make_result(&const_one));
    }

    /*
     * For any value of x, if y is [-]0, 1.0 shall be returned.
     */
    if (sign2 == 0)
      PG_RETURN_NUMERIC(make_result(&const_one));

    /*
     * For any odd integer value of y > 0, if x is [-]0, [-]0 shall be
     * returned.  For y > 0 and not an odd integer, if x is [-]0, +0 shall
     * be returned.  (Since we don't deal in minus zero, we need not
     * distinguish these two cases.)
     */
    if (sign1 == 0 && sign2 > 0)
      PG_RETURN_NUMERIC(make_result(&const_zero));

    /*
     * If x is -1, and y is [-]Inf, 1.0 shall be returned.
     *
     * For |x| < 1, if y is -Inf, +Inf shall be returned.
     *
     * For |x| > 1, if y is -Inf, +0 shall be returned.
     *
     * For |x| < 1, if y is +Inf, +0 shall be returned.
     *
     * For |x| > 1, if y is +Inf, +Inf shall be returned.
     */
    if (NUMERIC_IS_INF(num2))
    {
      bool    abs_x_gt_one;

      if (NUMERIC_IS_SPECIAL(num1))
        abs_x_gt_one = true; /* x is either Inf or -Inf */
      else
      {
        init_var_from_num(num1, &arg1);
        if (cmp_var(&arg1, &const_minus_one) == 0)
          PG_RETURN_NUMERIC(make_result(&const_one));
        arg1.sign = NUMERIC_POS; /* now arg1 = abs(x) */
        abs_x_gt_one = (cmp_var(&arg1, &const_one) > 0);
      }
      if (abs_x_gt_one == (sign2 > 0))
        PG_RETURN_NUMERIC(make_result(&const_pinf));
      else
        PG_RETURN_NUMERIC(make_result(&const_zero));
    }

    /*
     * For y < 0, if x is +Inf, +0 shall be returned.
     *
     * For y > 0, if x is +Inf, +Inf shall be returned.
     */
    if (NUMERIC_IS_PINF(num1))
    {
      if (sign2 > 0)
        PG_RETURN_NUMERIC(make_result(&const_pinf));
      else
        PG_RETURN_NUMERIC(make_result(&const_zero));
    }

    Assert(NUMERIC_IS_NINF(num1));

    /*
     * For y an odd integer < 0, if x is -Inf, -0 shall be returned.  For
     * y < 0 and not an odd integer, if x is -Inf, +0 shall be returned.
     * (Again, we need not distinguish these two cases.)
     */
    if (sign2 < 0)
      PG_RETURN_NUMERIC(make_result(&const_zero));

    /*
     * For y an odd integer > 0, if x is -Inf, -Inf shall be returned. For
     * y > 0 and not an odd integer, if x is -Inf, +Inf shall be returned.
     */
    init_var_from_num(num2, &arg2);
    if (arg2.ndigits > 0 && arg2.ndigits == arg2.weight + 1 &&
      (arg2.digits[arg2.ndigits - 1] & 1))
      PG_RETURN_NUMERIC(make_result(&const_ninf));
    else
      PG_RETURN_NUMERIC(make_result(&const_pinf));
  }

  /*
   * The SQL spec requires that we emit a particular SQLSTATE error code for
   * certain error conditions.  Specifically, we don't return a
   * divide-by-zero error code for 0 ^ -1.  Raising a negative number to a
   * non-integer power must produce the same error code, but that case is
   * handled in power_var().
   */
  sign1 = numeric_sign_internal(num1);
  sign2 = numeric_sign_internal(num2);

  if (sign1 == 0 && sign2 < 0)
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
         errmsg("zero raised to a negative power is undefined")));

  /*
   * Initialize things
   */
  init_var(&result);
  init_var_from_num(num1, &arg1);
  init_var_from_num(num2, &arg2);

  /*
   * Call power_var() to compute and return the result; note it handles
   * scale selection itself.
   */
  power_var(&arg1, &arg2, &result);

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}

/*
 * numeric_scale() -
 *
 *  Returns the scale, i.e. the count of decimal digits in the fractional part
 */
Datum
numeric_scale(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);

  if (NUMERIC_IS_SPECIAL(num))
    PG_RETURN_NULL();

  PG_RETURN_INT32(NUMERIC_DSCALE(num));
}

/*
 * Calculate minimum scale for value.
 */
static int
get_min_scale(NumericVar *var)
{
  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;
}

/*
 * Returns minimum scale required to represent supplied value without loss.
 */
Datum
numeric_min_scale(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  NumericVar  arg;
  int     min_scale;

  if (NUMERIC_IS_SPECIAL(num))
    PG_RETURN_NULL();

  init_var_from_num(num, &arg);
  min_scale = get_min_scale(&arg);
  free_var(&arg);

  PG_RETURN_INT32(min_scale);
}

/*
 * Reduce scale of numeric value to represent supplied value without loss.
 */
Datum
numeric_trim_scale(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  Numeric   res;
  NumericVar  result;

  if (NUMERIC_IS_SPECIAL(num))
    PG_RETURN_NUMERIC(duplicate_numeric(num));

  init_var_from_num(num, &result);
  result.dscale = get_min_scale(&result);
  res = make_result(&result);
  free_var(&result);

  PG_RETURN_NUMERIC(res);
}

/*
 * Return a random numeric value in the range [rmin, rmax].
 */
Numeric
random_numeric(pg_prng_state *state, Numeric rmin, Numeric rmax)
{
  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;
}


/* ----------------------------------------------------------------------
 *
 * Type conversion functions
 *
 * ----------------------------------------------------------------------
 */

Numeric
int64_to_numeric(int64 val)
{
  Numeric   res;
  NumericVar  result;

  init_var(&result);

  int64_to_numericvar(val, &result);

  res = make_result(&result);

  free_var(&result);

  return res;
}

/*
 * Convert val1/(10**log10val2) to numeric.  This is much faster than normal
 * numeric division.
 */
Numeric
int64_div_fast_to_numeric(int64 val1, int log10val2)
{
  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;
}

Datum
int4_numeric(PG_FUNCTION_ARGS)
{
  int32   val = PG_GETARG_INT32(0);

  PG_RETURN_NUMERIC(int64_to_numeric(val));
}

/*
 * Internal version of numeric_int4() with support for soft error reporting.
 */
int32
numeric_int4_safe(Numeric num, Node *escontext)
{
  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;
}

Datum
numeric_int4(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  int32   result;

  result = numeric_int4_safe(num, fcinfo->context);

  if (unlikely(SOFT_ERROR_OCCURRED(fcinfo->context)))
    PG_RETURN_NULL();

  PG_RETURN_INT32(result);
}

/*
 * Given a NumericVar, convert it to an int32. If the NumericVar
 * exceeds the range of an int32, false is returned, otherwise true is returned.
 * The input NumericVar is *not* free'd.
 */
static bool
numericvar_to_int32(const NumericVar *var, int32 *result)
{
  int64   val;

  if (!numericvar_to_int64(var, &val))
    return false;

  if (unlikely(val < PG_INT32_MIN) || unlikely(val > PG_INT32_MAX))
    return false;

  /* Down-convert to int4 */
  *result = (int32) val;

  return true;
}

Datum
int8_numeric(PG_FUNCTION_ARGS)
{
  int64   val = PG_GETARG_INT64(0);

  PG_RETURN_NUMERIC(int64_to_numeric(val));
}

/*
 * Internal version of numeric_int8() with support for soft error reporting.
 */
int64
numeric_int8_safe(Numeric num, Node *escontext)
{
  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;
}

Datum
numeric_int8(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  int64   result;

  result = numeric_int8_safe(num, fcinfo->context);

  if (unlikely(SOFT_ERROR_OCCURRED(fcinfo->context)))
    PG_RETURN_NULL();

  PG_RETURN_INT64(result);
}


Datum
int2_numeric(PG_FUNCTION_ARGS)
{
  int16   val = PG_GETARG_INT16(0);

  PG_RETURN_NUMERIC(int64_to_numeric(val));
}


Datum
numeric_int2(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  NumericVar  x;
  int64   val;
  int16   result;

  if (NUMERIC_IS_SPECIAL(num))
  {
    if (NUMERIC_IS_NAN(num))
      ereturn(fcinfo->context, (Datum) 0,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("cannot convert NaN to %s", "smallint")));
    else
      ereturn(fcinfo->context, (Datum) 0,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("cannot convert infinity to %s", "smallint")));
  }

  /* Convert to variable format and thence to int8 */
  init_var_from_num(num, &x);

  if (!numericvar_to_int64(&x, &val))
    ereturn(fcinfo->context, (Datum) 0,
        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
         errmsg("smallint out of range")));

  if (unlikely(val < PG_INT16_MIN) || unlikely(val > PG_INT16_MAX))
    ereturn(fcinfo->context, (Datum) 0,
        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
         errmsg("smallint out of range")));

  /* Down-convert to int2 */
  result = (int16) val;

  PG_RETURN_INT16(result);
}


Datum
float8_numeric(PG_FUNCTION_ARGS)
{
  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 */
  if (!set_var_from_str(buf, buf, &result, &endptr, fcinfo->context))
    PG_RETURN_NULL();

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


Datum
numeric_float8(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  char     *tmp;
  Datum   result;

  if (NUMERIC_IS_SPECIAL(num))
  {
    if (NUMERIC_IS_PINF(num))
      PG_RETURN_FLOAT8(get_float8_infinity());
    else if (NUMERIC_IS_NINF(num))
      PG_RETURN_FLOAT8(-get_float8_infinity());
    else
      PG_RETURN_FLOAT8(get_float8_nan());
  }

  tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
                        NumericGetDatum(num)));
  if (!DirectInputFunctionCallSafe(float8in, tmp,
                   InvalidOid, -1,
                   (Node *) fcinfo->context,
                   &result))
  {
    pfree(tmp);
    PG_RETURN_NULL();
  }

  PG_RETURN_DATUM(result);
}


/*
 * Convert numeric to float8; if out of range, return +/- HUGE_VAL
 *
 * (internal helper function, not directly callable from SQL)
 */
Datum
numeric_float8_no_overflow(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  double    val;

  if (NUMERIC_IS_SPECIAL(num))
  {
    if (NUMERIC_IS_PINF(num))
      val = HUGE_VAL;
    else if (NUMERIC_IS_NINF(num))
      val = -HUGE_VAL;
    else
      val = get_float8_nan();
  }
  else
  {
    NumericVar  x;

    init_var_from_num(num, &x);
    val = numericvar_to_double_no_overflow(&x);
  }

  PG_RETURN_FLOAT8(val);
}

Datum
float4_numeric(PG_FUNCTION_ARGS)
{
  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 */
  if (!set_var_from_str(buf, buf, &result, &endptr, fcinfo->context))
    PG_RETURN_NULL();

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}


Datum
numeric_float4(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  char     *tmp;
  Datum   result;

  if (NUMERIC_IS_SPECIAL(num))
  {
    if (NUMERIC_IS_PINF(num))
      PG_RETURN_FLOAT4(get_float4_infinity());
    else if (NUMERIC_IS_NINF(num))
      PG_RETURN_FLOAT4(-get_float4_infinity());
    else
      PG_RETURN_FLOAT4(get_float4_nan());
  }

  tmp = DatumGetCString(DirectFunctionCall1(numeric_out,
                        NumericGetDatum(num)));

  if (!DirectInputFunctionCallSafe(float4in, tmp,
                   InvalidOid, -1,
                   (Node *) fcinfo->context,
                   &result))
  {
    pfree(tmp);
    PG_RETURN_NULL();
  }

  pfree(tmp);

  PG_RETURN_DATUM(result);
}


Datum
numeric_pg_lsn(PG_FUNCTION_ARGS)
{
  Numeric   num = PG_GETARG_NUMERIC(0);
  NumericVar  x;
  XLogRecPtr  result;

  if (NUMERIC_IS_SPECIAL(num))
  {
    if (NUMERIC_IS_NAN(num))
      ereport(ERROR,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("cannot convert NaN to %s", "pg_lsn")));
    else
      ereport(ERROR,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("cannot convert infinity to %s", "pg_lsn")));
  }

  /* Convert to variable format and thence to pg_lsn */
  init_var_from_num(num, &x);

  if (!numericvar_to_uint64(&x, (uint64 *) &result))
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
         errmsg("pg_lsn out of range")));

  PG_RETURN_LSN(result);
}


/* ----------------------------------------------------------------------
 *
 * Aggregate functions
 *
 * The transition datatype for all these aggregates is declared as INTERNAL.
 * Actually, it's a pointer to a NumericAggState allocated in the aggregate
 * context.  The digit buffers for the NumericVars will be there too.
 *
 * For integer inputs, some aggregates use special-purpose 64-bit or 128-bit
 * integer based transition datatypes to speed up calculations.
 *
 * ----------------------------------------------------------------------
 */

typedef struct NumericAggState
{
  bool    calcSumX2;    /* if true, calculate sumX2 */
  MemoryContext agg_context;  /* context we're calculating in */
  int64   N;        /* count of processed numbers */
  NumericSumAccum sumX;   /* sum of processed numbers */
  NumericSumAccum sumX2;    /* sum of squares of processed numbers */
  int     maxScale;   /* maximum scale seen so far */
  int64   maxScaleCount;  /* number of values seen with maximum scale */
  /* These counts are *not* included in N!  Use NA_TOTAL_COUNT() as needed */
  int64   NaNcount;   /* count of NaN values */
  int64   pInfcount;    /* count of +Inf values */
  int64   nInfcount;    /* count of -Inf values */
} NumericAggState;

#define NA_TOTAL_COUNT(na) \
  ((na)->N + (na)->NaNcount + (na)->pInfcount + (na)->nInfcount)

/*
 * Prepare state data for a numeric aggregate function that needs to compute
 * sum, count and optionally sum of squares of the input.
 */
static NumericAggState *
makeNumericAggState(FunctionCallInfo fcinfo, bool calcSumX2)
{
  NumericAggState *state;
  MemoryContext agg_context;
  MemoryContext old_context;

  if (!AggCheckCallContext(fcinfo, &agg_context))
    elog(ERROR, "aggregate function called in non-aggregate context");

  old_context = MemoryContextSwitchTo(agg_context);

  state = palloc0_object(NumericAggState);
  state->calcSumX2 = calcSumX2;
  state->agg_context = agg_context;

  MemoryContextSwitchTo(old_context);

  return state;
}

/*
 * Like makeNumericAggState(), but allocate the state in the current memory
 * context.
 */
static NumericAggState *
makeNumericAggStateCurrentContext(bool calcSumX2)
{
  NumericAggState *state;

  state = palloc0_object(NumericAggState);
  state->calcSumX2 = calcSumX2;
  state->agg_context = CurrentMemoryContext;

  return state;
}

/*
 * Accumulate a new input value for numeric aggregate functions.
 */
static void
do_numeric_accum(NumericAggState *state, Numeric newval)
{
  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);
}

/*
 * Attempt to remove an input value from the aggregated state.
 *
 * If the value cannot be removed then the function will return false; the
 * possible reasons for failing are described below.
 *
 * If we aggregate the values 1.01 and 2 then the result will be 3.01.
 * If we are then asked to un-aggregate the 1.01 then we must fail as we
 * won't be able to tell what the new aggregated value's dscale should be.
 * We don't want to return 2.00 (dscale = 2), since the sum's dscale would
 * have been zero if we'd really aggregated only 2.
 *
 * Note: alternatively, we could count the number of inputs with each possible
 * dscale (up to some sane limit).  Not yet clear if it's worth the trouble.
 */
static bool
do_numeric_discard(NumericAggState *state, Numeric newval)
{
  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;
}

/*
 * Generic transition function for numeric aggregates that require sumX2.
 */
Datum
numeric_accum(PG_FUNCTION_ARGS)
{
  NumericAggState *state;

  state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);

  /* Create the state data on the first call */
  if (state == NULL)
    state = makeNumericAggState(fcinfo, true);

  if (!PG_ARGISNULL(1))
    do_numeric_accum(state, PG_GETARG_NUMERIC(1));

  PG_RETURN_POINTER(state);
}

/*
 * Generic combine function for numeric aggregates which require sumX2
 */
Datum
numeric_combine(PG_FUNCTION_ARGS)
{
  NumericAggState *state1;
  NumericAggState *state2;
  MemoryContext agg_context;
  MemoryContext old_context;

  if (!AggCheckCallContext(fcinfo, &agg_context))
    elog(ERROR, "aggregate function called in non-aggregate context");

  state1 = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
  state2 = PG_ARGISNULL(1) ? NULL : (NumericAggState *) PG_GETARG_POINTER(1);

  if (state2 == NULL)
  {
    /*
     * NULL state2 is easy, just return state1, which we know is already
     * in the agg_context
     */
    if (state1 == NULL)
      PG_RETURN_NULL();
    PG_RETURN_POINTER(state1);
  }

  /* manually copy all fields from state2 to state1 */
  if (state1 == NULL)
  {
    old_context = MemoryContextSwitchTo(agg_context);

    state1 = makeNumericAggStateCurrentContext(true);
    state1->N = state2->N;
    state1->NaNcount = state2->NaNcount;
    state1->pInfcount = state2->pInfcount;
    state1->nInfcount = state2->nInfcount;
    state1->maxScale = state2->maxScale;
    state1->maxScaleCount = state2->maxScaleCount;

    accum_sum_copy(&state1->sumX, &state2->sumX);
    accum_sum_copy(&state1->sumX2, &state2->sumX2);

    MemoryContextSwitchTo(old_context);

    PG_RETURN_POINTER(state1);
  }

  state1->N += state2->N;
  state1->NaNcount += state2->NaNcount;
  state1->pInfcount += state2->pInfcount;
  state1->nInfcount += state2->nInfcount;

  if (state2->N > 0)
  {
    /*
     * These are currently only needed for moving aggregates, but let's do
     * the right thing anyway...
     */
    if (state2->maxScale > state1->maxScale)
    {
      state1->maxScale = state2->maxScale;
      state1->maxScaleCount = state2->maxScaleCount;
    }
    else if (state2->maxScale == state1->maxScale)
      state1->maxScaleCount += state2->maxScaleCount;

    /* The rest of this needs to work in the aggregate context */
    old_context = MemoryContextSwitchTo(agg_context);

    /* Accumulate sums */
    accum_sum_combine(&state1->sumX, &state2->sumX);
    accum_sum_combine(&state1->sumX2, &state2->sumX2);

    MemoryContextSwitchTo(old_context);
  }
  PG_RETURN_POINTER(state1);
}

/*
 * Generic transition function for numeric aggregates that don't require sumX2.
 */
Datum
numeric_avg_accum(PG_FUNCTION_ARGS)
{
  NumericAggState *state;

  state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);

  /* Create the state data on the first call */
  if (state == NULL)
    state = makeNumericAggState(fcinfo, false);

  if (!PG_ARGISNULL(1))
    do_numeric_accum(state, PG_GETARG_NUMERIC(1));

  PG_RETURN_POINTER(state);
}

/*
 * Combine function for numeric aggregates which don't require sumX2
 */
Datum
numeric_avg_combine(PG_FUNCTION_ARGS)
{
  NumericAggState *state1;
  NumericAggState *state2;
  MemoryContext agg_context;
  MemoryContext old_context;

  if (!AggCheckCallContext(fcinfo, &agg_context))
    elog(ERROR, "aggregate function called in non-aggregate context");

  state1 = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);
  state2 = PG_ARGISNULL(1) ? NULL : (NumericAggState *) PG_GETARG_POINTER(1);

  if (state2 == NULL)
  {
    /*
     * NULL state2 is easy, just return state1, which we know is already
     * in the agg_context
     */
    if (state1 == NULL)
      PG_RETURN_NULL();
    PG_RETURN_POINTER(state1);
  }

  /* manually copy all fields from state2 to state1 */
  if (state1 == NULL)
  {
    old_context = MemoryContextSwitchTo(agg_context);

    state1 = makeNumericAggStateCurrentContext(false);
    state1->N = state2->N;
    state1->NaNcount = state2->NaNcount;
    state1->pInfcount = state2->pInfcount;
    state1->nInfcount = state2->nInfcount;
    state1->maxScale = state2->maxScale;
    state1->maxScaleCount = state2->maxScaleCount;

    accum_sum_copy(&state1->sumX, &state2->sumX);

    MemoryContextSwitchTo(old_context);

    PG_RETURN_POINTER(state1);
  }

  state1->N += state2->N;
  state1->NaNcount += state2->NaNcount;
  state1->pInfcount += state2->pInfcount;
  state1->nInfcount += state2->nInfcount;

  if (state2->N > 0)
  {
    /*
     * These are currently only needed for moving aggregates, but let's do
     * the right thing anyway...
     */
    if (state2->maxScale > state1->maxScale)
    {
      state1->maxScale = state2->maxScale;
      state1->maxScaleCount = state2->maxScaleCount;
    }
    else if (state2->maxScale == state1->maxScale)
      state1->maxScaleCount += state2->maxScaleCount;

    /* The rest of this needs to work in the aggregate context */
    old_context = MemoryContextSwitchTo(agg_context);

    /* Accumulate sums */
    accum_sum_combine(&state1->sumX, &state2->sumX);

    MemoryContextSwitchTo(old_context);
  }
  PG_RETURN_POINTER(state1);
}

/*
 * numeric_avg_serialize
 *    Serialize NumericAggState for numeric aggregates that don't require
 *    sumX2.
 */
Datum
numeric_avg_serialize(PG_FUNCTION_ARGS)
{
  NumericAggState *state;
  StringInfoData buf;
  bytea    *result;
  NumericVar  tmp_var;

  /* Ensure we disallow calling when not in aggregate context */
  if (!AggCheckCallContext(fcinfo, NULL))
    elog(ERROR, "aggregate function called in non-aggregate context");

  state = (NumericAggState *) PG_GETARG_POINTER(0);

  init_var(&tmp_var);

  pq_begintypsend(&buf);

  /* N */
  pq_sendint64(&buf, state->N);

  /* sumX */
  accum_sum_final(&state->sumX, &tmp_var);
  numericvar_serialize(&buf, &tmp_var);

  /* maxScale */
  pq_sendint32(&buf, state->maxScale);

  /* maxScaleCount */
  pq_sendint64(&buf, state->maxScaleCount);

  /* NaNcount */
  pq_sendint64(&buf, state->NaNcount);

  /* pInfcount */
  pq_sendint64(&buf, state->pInfcount);

  /* nInfcount */
  pq_sendint64(&buf, state->nInfcount);

  result = pq_endtypsend(&buf);

  free_var(&tmp_var);

  PG_RETURN_BYTEA_P(result);
}

/*
 * numeric_avg_deserialize
 *    Deserialize bytea into NumericAggState for numeric aggregates that
 *    don't require sumX2.
 */
Datum
numeric_avg_deserialize(PG_FUNCTION_ARGS)
{
  bytea    *sstate;
  NumericAggState *result;
  StringInfoData buf;
  NumericVar  tmp_var;

  if (!AggCheckCallContext(fcinfo, NULL))
    elog(ERROR, "aggregate function called in non-aggregate context");

  sstate = PG_GETARG_BYTEA_PP(0);

  init_var(&tmp_var);

  /*
   * Initialize a StringInfo so that we can "receive" it using the standard
   * recv-function infrastructure.
   */
  initReadOnlyStringInfo(&buf, VARDATA_ANY(sstate),
               VARSIZE_ANY_EXHDR(sstate));

  result = makeNumericAggStateCurrentContext(false);

  /* N */
  result->N = pq_getmsgint64(&buf);

  /* sumX */
  numericvar_deserialize(&buf, &tmp_var);
  accum_sum_add(&(result->sumX), &tmp_var);

  /* maxScale */
  result->maxScale = pq_getmsgint(&buf, 4);

  /* maxScaleCount */
  result->maxScaleCount = pq_getmsgint64(&buf);

  /* NaNcount */
  result->NaNcount = pq_getmsgint64(&buf);

  /* pInfcount */
  result->pInfcount = pq_getmsgint64(&buf);

  /* nInfcount */
  result->nInfcount = pq_getmsgint64(&buf);

  pq_getmsgend(&buf);

  free_var(&tmp_var);

  PG_RETURN_POINTER(result);
}

/*
 * numeric_serialize
 *    Serialization function for NumericAggState for numeric aggregates that
 *    require sumX2.
 */
Datum
numeric_serialize(PG_FUNCTION_ARGS)
{
  NumericAggState *state;
  StringInfoData buf;
  bytea    *result;
  NumericVar  tmp_var;

  /* Ensure we disallow calling when not in aggregate context */
  if (!AggCheckCallContext(fcinfo, NULL))
    elog(ERROR, "aggregate function called in non-aggregate context");

  state = (NumericAggState *) PG_GETARG_POINTER(0);

  init_var(&tmp_var);

  pq_begintypsend(&buf);

  /* N */
  pq_sendint64(&buf, state->N);

  /* sumX */
  accum_sum_final(&state->sumX, &tmp_var);
  numericvar_serialize(&buf, &tmp_var);

  /* sumX2 */
  accum_sum_final(&state->sumX2, &tmp_var);
  numericvar_serialize(&buf, &tmp_var);

  /* maxScale */
  pq_sendint32(&buf, state->maxScale);

  /* maxScaleCount */
  pq_sendint64(&buf, state->maxScaleCount);

  /* NaNcount */
  pq_sendint64(&buf, state->NaNcount);

  /* pInfcount */
  pq_sendint64(&buf, state->pInfcount);

  /* nInfcount */
  pq_sendint64(&buf, state->nInfcount);

  result = pq_endtypsend(&buf);

  free_var(&tmp_var);

  PG_RETURN_BYTEA_P(result);
}

/*
 * numeric_deserialize
 *    Deserialization function for NumericAggState for numeric aggregates that
 *    require sumX2.
 */
Datum
numeric_deserialize(PG_FUNCTION_ARGS)
{
  bytea    *sstate;
  NumericAggState *result;
  StringInfoData buf;
  NumericVar  tmp_var;

  if (!AggCheckCallContext(fcinfo, NULL))
    elog(ERROR, "aggregate function called in non-aggregate context");

  sstate = PG_GETARG_BYTEA_PP(0);

  init_var(&tmp_var);

  /*
   * Initialize a StringInfo so that we can "receive" it using the standard
   * recv-function infrastructure.
   */
  initReadOnlyStringInfo(&buf, VARDATA_ANY(sstate),
               VARSIZE_ANY_EXHDR(sstate));

  result = makeNumericAggStateCurrentContext(true);

  /* N */
  result->N = pq_getmsgint64(&buf);

  /* sumX */
  numericvar_deserialize(&buf, &tmp_var);
  accum_sum_add(&(result->sumX), &tmp_var);

  /* sumX2 */
  numericvar_deserialize(&buf, &tmp_var);
  accum_sum_add(&(result->sumX2), &tmp_var);

  /* maxScale */
  result->maxScale = pq_getmsgint(&buf, 4);

  /* maxScaleCount */
  result->maxScaleCount = pq_getmsgint64(&buf);

  /* NaNcount */
  result->NaNcount = pq_getmsgint64(&buf);

  /* pInfcount */
  result->pInfcount = pq_getmsgint64(&buf);

  /* nInfcount */
  result->nInfcount = pq_getmsgint64(&buf);

  pq_getmsgend(&buf);

  free_var(&tmp_var);

  PG_RETURN_POINTER(result);
}

/*
 * Generic inverse transition function for numeric aggregates
 * (with or without requirement for X^2).
 */
Datum
numeric_accum_inv(PG_FUNCTION_ARGS)
{
  NumericAggState *state;

  state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);

  /* Should not get here with no state */
  if (state == NULL)
    elog(ERROR, "numeric_accum_inv called with NULL state");

  if (!PG_ARGISNULL(1))
  {
    /* If we fail to perform the inverse transition, return NULL */
    if (!do_numeric_discard(state, PG_GETARG_NUMERIC(1)))
      PG_RETURN_NULL();
  }

  PG_RETURN_POINTER(state);
}


/*
 * Integer data types in general use Numeric accumulators to share code and
 * avoid risk of overflow.  However for performance reasons optimized
 * special-purpose accumulator routines are used when possible:
 *
 * For 16-bit and 32-bit inputs, N and sum(X) fit into 64-bit, so 64-bit
 * accumulators are used for SUM and AVG of these data types.
 *
 * For 16-bit and 32-bit inputs, sum(X^2) fits into 128-bit, so 128-bit
 * accumulators are used for STDDEV_POP, STDDEV_SAMP, VAR_POP, and VAR_SAMP of
 * these data types.
 *
 * For 64-bit inputs, sum(X) fits into 128-bit, so a 128-bit accumulator is
 * used for SUM(int8) and AVG(int8).
 */

typedef struct Int128AggState
{
  bool    calcSumX2;    /* if true, calculate sumX2 */
  int64   N;        /* count of processed numbers */
  INT128    sumX;     /* sum of processed numbers */
  INT128    sumX2;      /* sum of squares of processed numbers */
} Int128AggState;

/*
 * Prepare state data for a 128-bit aggregate function that needs to compute
 * sum, count and optionally sum of squares of the input.
 */
static Int128AggState *
makeInt128AggState(FunctionCallInfo fcinfo, bool calcSumX2)
{
  Int128AggState *state;
  MemoryContext agg_context;
  MemoryContext old_context;

  if (!AggCheckCallContext(fcinfo, &agg_context))
    elog(ERROR, "aggregate function called in non-aggregate context");

  old_context = MemoryContextSwitchTo(agg_context);

  state = palloc0_object(Int128AggState);
  state->calcSumX2 = calcSumX2;

  MemoryContextSwitchTo(old_context);

  return state;
}

/*
 * Like makeInt128AggState(), but allocate the state in the current memory
 * context.
 */
static Int128AggState *
makeInt128AggStateCurrentContext(bool calcSumX2)
{
  Int128AggState *state;

  state = palloc0_object(Int128AggState);
  state->calcSumX2 = calcSumX2;

  return state;
}

/*
 * Accumulate a new input value for 128-bit aggregate functions.
 */
static void
do_int128_accum(Int128AggState *state, int64 newval)
{
  if (state->calcSumX2)
    int128_add_int64_mul_int64(&state->sumX2, newval, newval);

  int128_add_int64(&state->sumX, newval);
  state->N++;
}

/*
 * Remove an input value from the aggregated state.
 */
static void
do_int128_discard(Int128AggState *state, int64 newval)
{
  if (state->calcSumX2)
    int128_sub_int64_mul_int64(&state->sumX2, newval, newval);

  int128_sub_int64(&state->sumX, newval);
  state->N--;
}

Datum
int2_accum(PG_FUNCTION_ARGS)
{
  Int128AggState *state;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);

  /* Create the state data on the first call */
  if (state == NULL)
    state = makeInt128AggState(fcinfo, true);

  if (!PG_ARGISNULL(1))
    do_int128_accum(state, PG_GETARG_INT16(1));

  PG_RETURN_POINTER(state);
}

Datum
int4_accum(PG_FUNCTION_ARGS)
{
  Int128AggState *state;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);

  /* Create the state data on the first call */
  if (state == NULL)
    state = makeInt128AggState(fcinfo, true);

  if (!PG_ARGISNULL(1))
    do_int128_accum(state, PG_GETARG_INT32(1));

  PG_RETURN_POINTER(state);
}

Datum
int8_accum(PG_FUNCTION_ARGS)
{
  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);
}

/*
 * Combine function for Int128AggState for aggregates which require sumX2
 */
Datum
numeric_poly_combine(PG_FUNCTION_ARGS)
{
  Int128AggState *state1;
  Int128AggState *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 : (Int128AggState *) PG_GETARG_POINTER(0);
  state2 = PG_ARGISNULL(1) ? NULL : (Int128AggState *) PG_GETARG_POINTER(1);

  if (state2 == NULL)
  {
    /*
     * NULL state2 is easy, just return state1, which we know is already
     * in the agg_context
     */
    if (state1 == NULL)
      PG_RETURN_NULL();
    PG_RETURN_POINTER(state1);
  }

  /* manually copy all fields from state2 to state1 */
  if (state1 == NULL)
  {
    old_context = MemoryContextSwitchTo(agg_context);

    state1 = makeInt128AggState(fcinfo, true);
    state1->N = state2->N;
    state1->sumX = state2->sumX;
    state1->sumX2 = state2->sumX2;

    MemoryContextSwitchTo(old_context);

    PG_RETURN_POINTER(state1);
  }

  if (state2->N > 0)
  {
    state1->N += state2->N;
    int128_add_int128(&state1->sumX, state2->sumX);
    int128_add_int128(&state1->sumX2, state2->sumX2);
  }
  PG_RETURN_POINTER(state1);
}

/*
 * int128_serialize - serialize a 128-bit integer to binary format
 */
static inline void
int128_serialize(StringInfo buf, INT128 val)
{
  pq_sendint64(buf, PG_INT128_HI_INT64(val));
  pq_sendint64(buf, PG_INT128_LO_UINT64(val));
}

/*
 * int128_deserialize - deserialize binary format to a 128-bit integer.
 */
static inline INT128
int128_deserialize(StringInfo buf)
{
  int64   hi = pq_getmsgint64(buf);
  uint64    lo = pq_getmsgint64(buf);

  return make_int128(hi, lo);
}

/*
 * numeric_poly_serialize
 *    Serialize Int128AggState into bytea for aggregate functions which
 *    require sumX2.
 */
Datum
numeric_poly_serialize(PG_FUNCTION_ARGS)
{
  Int128AggState *state;
  StringInfoData buf;
  bytea    *result;

  /* Ensure we disallow calling when not in aggregate context */
  if (!AggCheckCallContext(fcinfo, NULL))
    elog(ERROR, "aggregate function called in non-aggregate context");

  state = (Int128AggState *) PG_GETARG_POINTER(0);

  pq_begintypsend(&buf);

  /* N */
  pq_sendint64(&buf, state->N);

  /* sumX */
  int128_serialize(&buf, state->sumX);

  /* sumX2 */
  int128_serialize(&buf, state->sumX2);

  result = pq_endtypsend(&buf);

  PG_RETURN_BYTEA_P(result);
}

/*
 * numeric_poly_deserialize
 *    Deserialize Int128AggState from bytea for aggregate functions which
 *    require sumX2.
 */
Datum
numeric_poly_deserialize(PG_FUNCTION_ARGS)
{
  bytea    *sstate;
  Int128AggState *result;
  StringInfoData buf;

  if (!AggCheckCallContext(fcinfo, NULL))
    elog(ERROR, "aggregate function called in non-aggregate context");

  sstate = PG_GETARG_BYTEA_PP(0);

  /*
   * 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 = makeInt128AggStateCurrentContext(true);

  /* N */
  result->N = pq_getmsgint64(&buf);

  /* sumX */
  result->sumX = int128_deserialize(&buf);

  /* sumX2 */
  result->sumX2 = int128_deserialize(&buf);

  pq_getmsgend(&buf);

  PG_RETURN_POINTER(result);
}

/*
 * Transition function for int8 input when we don't need sumX2.
 */
Datum
int8_avg_accum(PG_FUNCTION_ARGS)
{
  Int128AggState *state;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);

  /* Create the state data on the first call */
  if (state == NULL)
    state = makeInt128AggState(fcinfo, false);

  if (!PG_ARGISNULL(1))
    do_int128_accum(state, PG_GETARG_INT64(1));

  PG_RETURN_POINTER(state);
}

/*
 * Combine function for Int128AggState for aggregates which don't require
 * sumX2
 */
Datum
int8_avg_combine(PG_FUNCTION_ARGS)
{
  Int128AggState *state1;
  Int128AggState *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 : (Int128AggState *) PG_GETARG_POINTER(0);
  state2 = PG_ARGISNULL(1) ? NULL : (Int128AggState *) PG_GETARG_POINTER(1);

  if (state2 == NULL)
  {
    /*
     * NULL state2 is easy, just return state1, which we know is already
     * in the agg_context
     */
    if (state1 == NULL)
      PG_RETURN_NULL();
    PG_RETURN_POINTER(state1);
  }

  /* manually copy all fields from state2 to state1 */
  if (state1 == NULL)
  {
    old_context = MemoryContextSwitchTo(agg_context);

    state1 = makeInt128AggState(fcinfo, false);
    state1->N = state2->N;
    state1->sumX = state2->sumX;

    MemoryContextSwitchTo(old_context);

    PG_RETURN_POINTER(state1);
  }

  if (state2->N > 0)
  {
    state1->N += state2->N;
    int128_add_int128(&state1->sumX, state2->sumX);
  }
  PG_RETURN_POINTER(state1);
}

/*
 * int8_avg_serialize
 *    Serialize Int128AggState into bytea for aggregate functions which
 *    don't require sumX2.
 */
Datum
int8_avg_serialize(PG_FUNCTION_ARGS)
{
  Int128AggState *state;
  StringInfoData buf;
  bytea    *result;

  /* Ensure we disallow calling when not in aggregate context */
  if (!AggCheckCallContext(fcinfo, NULL))
    elog(ERROR, "aggregate function called in non-aggregate context");

  state = (Int128AggState *) PG_GETARG_POINTER(0);

  pq_begintypsend(&buf);

  /* N */
  pq_sendint64(&buf, state->N);

  /* sumX */
  int128_serialize(&buf, state->sumX);

  result = pq_endtypsend(&buf);

  PG_RETURN_BYTEA_P(result);
}

/*
 * int8_avg_deserialize
 *    Deserialize Int128AggState from bytea for aggregate functions which
 *    don't require sumX2.
 */
Datum
int8_avg_deserialize(PG_FUNCTION_ARGS)
{
  bytea    *sstate;
  Int128AggState *result;
  StringInfoData buf;

  if (!AggCheckCallContext(fcinfo, NULL))
    elog(ERROR, "aggregate function called in non-aggregate context");

  sstate = PG_GETARG_BYTEA_PP(0);

  /*
   * 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 = makeInt128AggStateCurrentContext(false);

  /* N */
  result->N = pq_getmsgint64(&buf);

  /* sumX */
  result->sumX = int128_deserialize(&buf);

  pq_getmsgend(&buf);

  PG_RETURN_POINTER(result);
}

/*
 * Inverse transition functions to go with the above.
 */

Datum
int2_accum_inv(PG_FUNCTION_ARGS)
{
  Int128AggState *state;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) 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))
    do_int128_discard(state, PG_GETARG_INT16(1));

  PG_RETURN_POINTER(state);
}

Datum
int4_accum_inv(PG_FUNCTION_ARGS)
{
  Int128AggState *state;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) 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))
    do_int128_discard(state, PG_GETARG_INT32(1));

  PG_RETURN_POINTER(state);
}

Datum
int8_accum_inv(PG_FUNCTION_ARGS)
{
  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);
}

Datum
int8_avg_accum_inv(PG_FUNCTION_ARGS)
{
  Int128AggState *state;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) 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))
    do_int128_discard(state, PG_GETARG_INT64(1));

  PG_RETURN_POINTER(state);
}

Datum
numeric_poly_sum(PG_FUNCTION_ARGS)
{
  Int128AggState *state;
  Numeric   res;
  NumericVar  result;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);

  /* If there were no non-null inputs, return NULL */
  if (state == NULL || state->N == 0)
    PG_RETURN_NULL();

  init_var(&result);

  int128_to_numericvar(state->sumX, &result);

  res = make_result(&result);

  free_var(&result);

  PG_RETURN_NUMERIC(res);
}

Datum
numeric_poly_avg(PG_FUNCTION_ARGS)
{
  Int128AggState *state;
  NumericVar  result;
  Datum   countd,
        sumd;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);

  /* If there were no non-null inputs, return NULL */
  if (state == NULL || state->N == 0)
    PG_RETURN_NULL();

  init_var(&result);

  int128_to_numericvar(state->sumX, &result);

  countd = NumericGetDatum(int64_to_numeric(state->N));
  sumd = NumericGetDatum(make_result(&result));

  free_var(&result);

  PG_RETURN_DATUM(DirectFunctionCall2(numeric_div, sumd, countd));
}

Datum
numeric_avg(PG_FUNCTION_ARGS)
{
  NumericAggState *state;
  Datum   N_datum;
  Datum   sumX_datum;
  NumericVar  sumX_var;

  state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);

  /* If there were no non-null inputs, return NULL */
  if (state == NULL || NA_TOTAL_COUNT(state) == 0)
    PG_RETURN_NULL();

  if (state->NaNcount > 0) /* there was at least one NaN input */
    PG_RETURN_NUMERIC(make_result(&const_nan));

  /* adding plus and minus infinities gives NaN */
  if (state->pInfcount > 0 && state->nInfcount > 0)
    PG_RETURN_NUMERIC(make_result(&const_nan));
  if (state->pInfcount > 0)
    PG_RETURN_NUMERIC(make_result(&const_pinf));
  if (state->nInfcount > 0)
    PG_RETURN_NUMERIC(make_result(&const_ninf));

  N_datum = NumericGetDatum(int64_to_numeric(state->N));

  init_var(&sumX_var);
  accum_sum_final(&state->sumX, &sumX_var);
  sumX_datum = NumericGetDatum(make_result(&sumX_var));
  free_var(&sumX_var);

  PG_RETURN_DATUM(DirectFunctionCall2(numeric_div, sumX_datum, N_datum));
}

Datum
numeric_sum(PG_FUNCTION_ARGS)
{
  NumericAggState *state;
  NumericVar  sumX_var;
  Numeric   result;

  state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);

  /* If there were no non-null inputs, return NULL */
  if (state == NULL || NA_TOTAL_COUNT(state) == 0)
    PG_RETURN_NULL();

  if (state->NaNcount > 0) /* there was at least one NaN input */
    PG_RETURN_NUMERIC(make_result(&const_nan));

  /* adding plus and minus infinities gives NaN */
  if (state->pInfcount > 0 && state->nInfcount > 0)
    PG_RETURN_NUMERIC(make_result(&const_nan));
  if (state->pInfcount > 0)
    PG_RETURN_NUMERIC(make_result(&const_pinf));
  if (state->nInfcount > 0)
    PG_RETURN_NUMERIC(make_result(&const_ninf));

  init_var(&sumX_var);
  accum_sum_final(&state->sumX, &sumX_var);
  result = make_result(&sumX_var);
  free_var(&sumX_var);

  PG_RETURN_NUMERIC(result);
}

/*
 * Workhorse routine for the standard deviance and variance
 * aggregates. 'state' is aggregate's transition state.
 * 'variance' specifies whether we should calculate the
 * variance or the standard deviation. 'sample' indicates whether the
 * caller is interested in the sample or the population
 * variance/stddev.
 *
 * If appropriate variance statistic is undefined for the input,
 * *is_null is set to true and NULL is returned.
 */
static Numeric
numeric_stddev_internal(NumericAggState *state,
            bool variance, bool sample,
            bool *is_null)
{
  Numeric   res;
  NumericVar  vN,
        vsumX,
        vsumX2,
        vNminus1;
  int64   totCount;
  int     rscale;

  /*
   * Sample stddev and variance are undefined when N <= 1; population stddev
   * is undefined when N == 0.  Return NULL in either case (note that NaNs
   * and infinities count as normal inputs for this purpose).
   */
  if (state == NULL || (totCount = NA_TOTAL_COUNT(state)) == 0)
  {
    *is_null = true;
    return NULL;
  }

  if (sample && totCount <= 1)
  {
    *is_null = true;
    return NULL;
  }

  *is_null = false;

  /*
   * Deal with NaN and infinity cases.  By analogy to the behavior of the
   * float8 functions, any infinity input produces NaN output.
   */
  if (state->NaNcount > 0 || state->pInfcount > 0 || state->nInfcount > 0)
    return make_result(&const_nan);

  /* OK, normal calculation applies */
  init_var(&vN);
  init_var(&vsumX);
  init_var(&vsumX2);

  int64_to_numericvar(state->N, &vN);
  accum_sum_final(&(state->sumX), &vsumX);
  accum_sum_final(&(state->sumX2), &vsumX2);

  init_var(&vNminus1);
  sub_var(&vN, &const_one, &vNminus1);

  /* compute rscale for mul_var calls */
  rscale = vsumX.dscale * 2;

  mul_var(&vsumX, &vsumX, &vsumX, rscale);  /* vsumX = sumX * sumX */
  mul_var(&vN, &vsumX2, &vsumX2, rscale); /* vsumX2 = N * sumX2 */
  sub_var(&vsumX2, &vsumX, &vsumX2);  /* N * sumX2 - sumX * sumX */

  if (cmp_var(&vsumX2, &const_zero) <= 0)
  {
    /* Watch out for roundoff error producing a negative numerator */
    res = make_result(&const_zero);
  }
  else
  {
    if (sample)
      mul_var(&vN, &vNminus1, &vNminus1, 0); /* N * (N - 1) */
    else
      mul_var(&vN, &vN, &vNminus1, 0); /* N * N */
    rscale = select_div_scale(&vsumX2, &vNminus1);
    div_var(&vsumX2, &vNminus1, &vsumX, rscale, true, true);  /* variance */
    if (!variance)
      sqrt_var(&vsumX, &vsumX, rscale); /* stddev */

    res = make_result(&vsumX);
  }

  free_var(&vNminus1);
  free_var(&vsumX);
  free_var(&vsumX2);

  return res;
}

Datum
numeric_var_samp(PG_FUNCTION_ARGS)
{
  NumericAggState *state;
  Numeric   res;
  bool    is_null;

  state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);

  res = numeric_stddev_internal(state, true, true, &is_null);

  if (is_null)
    PG_RETURN_NULL();
  else
    PG_RETURN_NUMERIC(res);
}

Datum
numeric_stddev_samp(PG_FUNCTION_ARGS)
{
  NumericAggState *state;
  Numeric   res;
  bool    is_null;

  state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);

  res = numeric_stddev_internal(state, false, true, &is_null);

  if (is_null)
    PG_RETURN_NULL();
  else
    PG_RETURN_NUMERIC(res);
}

Datum
numeric_var_pop(PG_FUNCTION_ARGS)
{
  NumericAggState *state;
  Numeric   res;
  bool    is_null;

  state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);

  res = numeric_stddev_internal(state, true, false, &is_null);

  if (is_null)
    PG_RETURN_NULL();
  else
    PG_RETURN_NUMERIC(res);
}

Datum
numeric_stddev_pop(PG_FUNCTION_ARGS)
{
  NumericAggState *state;
  Numeric   res;
  bool    is_null;

  state = PG_ARGISNULL(0) ? NULL : (NumericAggState *) PG_GETARG_POINTER(0);

  res = numeric_stddev_internal(state, false, false, &is_null);

  if (is_null)
    PG_RETURN_NULL();
  else
    PG_RETURN_NUMERIC(res);
}

static Numeric
numeric_poly_stddev_internal(Int128AggState *state,
               bool variance, bool sample,
               bool *is_null)
{
  NumericAggState numstate;
  Numeric   res;

  /* Initialize an empty agg state */
  memset(&numstate, 0, sizeof(NumericAggState));

  if (state)
  {
    NumericVar  tmp_var;

    numstate.N = state->N;

    init_var(&tmp_var);

    int128_to_numericvar(state->sumX, &tmp_var);
    accum_sum_add(&numstate.sumX, &tmp_var);

    int128_to_numericvar(state->sumX2, &tmp_var);
    accum_sum_add(&numstate.sumX2, &tmp_var);

    free_var(&tmp_var);
  }

  res = numeric_stddev_internal(&numstate, variance, sample, is_null);

  if (numstate.sumX.ndigits > 0)
  {
    pfree(numstate.sumX.pos_digits);
    pfree(numstate.sumX.neg_digits);
  }
  if (numstate.sumX2.ndigits > 0)
  {
    pfree(numstate.sumX2.pos_digits);
    pfree(numstate.sumX2.neg_digits);
  }

  return res;
}

Datum
numeric_poly_var_samp(PG_FUNCTION_ARGS)
{
  Int128AggState *state;
  Numeric   res;
  bool    is_null;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);

  res = numeric_poly_stddev_internal(state, true, true, &is_null);

  if (is_null)
    PG_RETURN_NULL();
  else
    PG_RETURN_NUMERIC(res);
}

Datum
numeric_poly_stddev_samp(PG_FUNCTION_ARGS)
{
  Int128AggState *state;
  Numeric   res;
  bool    is_null;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);

  res = numeric_poly_stddev_internal(state, false, true, &is_null);

  if (is_null)
    PG_RETURN_NULL();
  else
    PG_RETURN_NUMERIC(res);
}

Datum
numeric_poly_var_pop(PG_FUNCTION_ARGS)
{
  Int128AggState *state;
  Numeric   res;
  bool    is_null;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);

  res = numeric_poly_stddev_internal(state, true, false, &is_null);

  if (is_null)
    PG_RETURN_NULL();
  else
    PG_RETURN_NUMERIC(res);
}

Datum
numeric_poly_stddev_pop(PG_FUNCTION_ARGS)
{
  Int128AggState *state;
  Numeric   res;
  bool    is_null;

  state = PG_ARGISNULL(0) ? NULL : (Int128AggState *) PG_GETARG_POINTER(0);

  res = numeric_poly_stddev_internal(state, false, false, &is_null);

  if (is_null)
    PG_RETURN_NULL();
  else
    PG_RETURN_NUMERIC(res);
}

/*
 * SUM transition functions for integer datatypes.
 *
 * To avoid overflow, we use accumulators wider than the input datatype.
 * A Numeric accumulator is needed for int8 input; for int4 and int2
 * inputs, we use int8 accumulators which should be sufficient for practical
 * purposes.  (The latter two therefore don't really belong in this file,
 * but we keep them here anyway.)
 *
 * Because SQL defines the SUM() of no values to be NULL, not zero,
 * the initial condition of the transition data value needs to be NULL. This
 * means we can't rely on ExecAgg to automatically insert the first non-null
 * data value into the transition data: it doesn't know how to do the type
 * conversion.  The upshot is that these routines have to be marked non-strict
 * and handle substitution of the first non-null input themselves.
 *
 * Note: these functions are used only in plain aggregation mode.
 * In moving-aggregate mode, we use intX_avg_accum and intX_avg_accum_inv.
 */

Datum
int2_sum(PG_FUNCTION_ARGS)
{
  int64   oldsum;
  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);
  }

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

Datum
int4_sum(PG_FUNCTION_ARGS)
{
  int64   oldsum;
  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);
  }

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

/*
 * Note: this function is obsolete, it's no longer used for SUM(int8).
 */
Datum
int8_sum(PG_FUNCTION_ARGS)
{
  Numeric   oldsum;

  if (PG_ARGISNULL(0))
  {
    /* No non-null input seen so far... */
    if (PG_ARGISNULL(1))
      PG_RETURN_NULL(); /* still no non-null */
    /* This is the first non-null input. */
    PG_RETURN_NUMERIC(int64_to_numeric(PG_GETARG_INT64(1)));
  }

  /*
   * Note that we cannot special-case the aggregate case here, as we do for
   * int2_sum and int4_sum: numeric is of variable size, so we cannot modify
   * our first parameter in-place.
   */

  oldsum = PG_GETARG_NUMERIC(0);

  /* Leave sum unchanged if new input is null. */
  if (PG_ARGISNULL(1))
    PG_RETURN_NUMERIC(oldsum);

  /* OK to do the addition. */
  PG_RETURN_DATUM(DirectFunctionCall2(numeric_add,
                    NumericGetDatum(oldsum),
                    NumericGetDatum(int64_to_numeric(PG_GETARG_INT64(1)))));
}


/*
 * Routines for avg(int2) and avg(int4).  The transition datatype
 * is a two-element int8 array, holding count and sum.
 *
 * These functions are also used for sum(int2) and sum(int4) when
 * operating in moving-aggregate mode, since for correct inverse transitions
 * we need to count the inputs.
 */

typedef struct Int8TransTypeData
{
  int64   count;
  int64   sum;
} Int8TransTypeData;

Datum
int2_avg_accum(PG_FUNCTION_ARGS)
{
  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);
}

Datum
int4_avg_accum(PG_FUNCTION_ARGS)
{
  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);
}

Datum
int4_avg_combine(PG_FUNCTION_ARGS)
{
  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);
}

Datum
int2_avg_accum_inv(PG_FUNCTION_ARGS)
{
  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);
}

Datum
int4_avg_accum_inv(PG_FUNCTION_ARGS)
{
  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);
}

Datum
int8_avg(PG_FUNCTION_ARGS)
{
  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));
}

/*
 * SUM(int2) and SUM(int4) both return int8, so we can use this
 * final function for both.
 */
Datum
int2int4_sum(PG_FUNCTION_ARGS)
{
  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));
}


/* ----------------------------------------------------------------------
 *
 * Debug support
 *
 * ----------------------------------------------------------------------
 */

#ifdef NUMERIC_DEBUG

/*
 * dump_numeric() - Dump a value in the db storage format for debugging
 */
static void
dump_numeric(const char *str, Numeric num)
{
  NumericDigit *digits = NUMERIC_DIGITS(num);
  int     ndigits;
  int     i;

  ndigits = NUMERIC_NDIGITS(num);

  printf("%s: NUMERIC w=%d d=%d ", str,
       NUMERIC_WEIGHT(num), NUMERIC_DSCALE(num));
  switch (NUMERIC_SIGN(num))
  {
    case NUMERIC_POS:
      printf("POS");
      break;
    case NUMERIC_NEG:
      printf("NEG");
      break;
    case NUMERIC_NAN:
      printf("NaN");
      break;
    case NUMERIC_PINF:
      printf("Infinity");
      break;
    case NUMERIC_NINF:
      printf("-Infinity");
      break;
    default:
      printf("SIGN=0x%x", NUMERIC_SIGN(num));
      break;
  }

  for (i = 0; i < ndigits; i++)
    printf(" %0*d", DEC_DIGITS, digits[i]);
  printf("\n");
}


/*
 * dump_var() - Dump a value in the variable format for debugging
 */
static void
dump_var(const char *str, NumericVar *var)
{
  int     i;

  printf("%s: VAR w=%d d=%d ", str, var->weight, var->dscale);
  switch (var->sign)
  {
    case NUMERIC_POS:
      printf("POS");
      break;
    case NUMERIC_NEG:
      printf("NEG");
      break;
    case NUMERIC_NAN:
      printf("NaN");
      break;
    case NUMERIC_PINF:
      printf("Infinity");
      break;
    case NUMERIC_NINF:
      printf("-Infinity");
      break;
    default:
      printf("SIGN=0x%x", var->sign);
      break;
  }

  for (i = 0; i < var->ndigits; i++)
    printf(" %0*d", DEC_DIGITS, var->digits[i]);

  printf("\n");
}
#endif              /* NUMERIC_DEBUG */


/* ----------------------------------------------------------------------
 *
 * Local functions follow
 *
 * In general, these do not support "special" (NaN or infinity) inputs;
 * callers should handle those possibilities first.
 * (There are one or two exceptions, noted in their header comments.)
 *
 * ----------------------------------------------------------------------
 */


/*
 * alloc_var() -
 *
 *  Allocate a digit buffer of ndigits digits (plus a spare digit for rounding)
 */
static void
alloc_var(NumericVar *var, int ndigits)
{
  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;
}


/*
 * free_var() -
 *
 *  Return the digit buffer of a variable to the free pool
 */
static void
free_var(NumericVar *var)
{
  digitbuf_free(var->buf);
  var->buf = NULL;
  var->digits = NULL;
  var->sign = NUMERIC_NAN;
}


/*
 * zero_var() -
 *
 *  Set a variable to ZERO.
 *  Note: its dscale is not touched.
 */
static void
zero_var(NumericVar *var)
{
  digitbuf_free(var->buf);
  var->buf = NULL;
  var->digits = NULL;
  var->ndigits = 0;
  var->weight = 0;      /* by convention; doesn't really matter */
  var->sign = NUMERIC_POS; /* anything but NAN... */
}


/*
 * set_var_from_str()
 *
 *  Parse a string and put the number into a variable
 *
 * This function does not handle leading or trailing spaces.  It returns
 * the end+1 position parsed into *endptr, so that caller can check for
 * trailing spaces/garbage if deemed necessary.
 *
 * cp is the place to actually start parsing; str is what to use in error
 * reports.  (Typically cp would be the same except advanced over spaces.)
 *
 * Returns true on success, false on failure (if escontext points to an
 * ErrorSaveContext; otherwise errors are thrown).
 */
static bool
set_var_from_str(const char *str, const char *cp,
         NumericVar *dest, const char **endptr,
         Node *escontext)
{
  bool    have_dp = false;
  int     i;
  unsigned char *decdigits;
  int     sign = NUMERIC_POS;
  int     dweight = -1;
  int     ddigits;
  int     dscale = 0;
  int     weight;
  int     ndigits;
  int     offset;
  NumericDigit *digits;

  /*
   * We first parse the string to extract decimal digits and determine the
   * correct decimal weight.  Then convert to NBASE representation.
   */
  switch (*cp)
  {
    case '+':
      sign = NUMERIC_POS;
      cp++;
      break;

    case '-':
      sign = NUMERIC_NEG;
      cp++;
      break;
  }

  if (*cp == '.')
  {
    have_dp = true;
    cp++;
  }

  if (!isdigit((unsigned char) *cp))
    goto invalid_syntax;

  decdigits = (unsigned char *) palloc(strlen(cp) + DEC_DIGITS * 2);

  /* leading padding for digit alignment later */
  memset(decdigits, 0, DEC_DIGITS);
  i = DEC_DIGITS;

  while (*cp)
  {
    if (isdigit((unsigned char) *cp))
    {
      decdigits[i++] = *cp++ - '0';
      if (!have_dp)
        dweight++;
      else
        dscale++;
    }
    else if (*cp == '.')
    {
      if (have_dp)
        goto invalid_syntax;
      have_dp = true;
      cp++;
      /* decimal point must not be followed by underscore */
      if (*cp == '_')
        goto invalid_syntax;
    }
    else if (*cp == '_')
    {
      /* underscore must be followed by more digits */
      cp++;
      if (!isdigit((unsigned char) *cp))
        goto invalid_syntax;
    }
    else
      break;
  }

  ddigits = i - DEC_DIGITS;
  /* trailing padding for digit alignment later */
  memset(decdigits + i, 0, DEC_DIGITS - 1);

  /* Handle exponent, if any */
  if (*cp == 'e' || *cp == 'E')
  {
    int64   exponent = 0;
    bool    neg = false;

    /*
     * At this point, dweight and dscale can't be more than about
     * INT_MAX/2 due to the MaxAllocSize limit on string length, so
     * constraining the exponent similarly should be enough to prevent
     * integer overflow in this function.  If the value is too large to
     * fit in storage format, make_result() will complain about it later;
     * for consistency use the same ereport errcode/text as make_result().
     */

    /* exponent sign */
    cp++;
    if (*cp == '+')
      cp++;
    else if (*cp == '-')
    {
      neg = true;
      cp++;
    }

    /* exponent digits */
    if (!isdigit((unsigned char) *cp))
      goto invalid_syntax;

    while (*cp)
    {
      if (isdigit((unsigned char) *cp))
      {
        exponent = exponent * 10 + (*cp++ - '0');
        if (exponent > PG_INT32_MAX / 2)
          goto out_of_range;
      }
      else if (*cp == '_')
      {
        /* underscore must be followed by more digits */
        cp++;
        if (!isdigit((unsigned char) *cp))
          goto invalid_syntax;
      }
      else
        break;
    }

    if (neg)
      exponent = -exponent;

    dweight += (int) exponent;
    dscale -= (int) exponent;
    if (dscale < 0)
      dscale = 0;
  }

  /*
   * Okay, convert pure-decimal representation to base NBASE.  First we need
   * to determine the converted weight and ndigits.  offset is the number of
   * decimal zeroes to insert before the first given digit to have a
   * correctly aligned first NBASE digit.
   */
  if (dweight >= 0)
    weight = (dweight + 1 + DEC_DIGITS - 1) / DEC_DIGITS - 1;
  else
    weight = -((-dweight - 1) / DEC_DIGITS + 1);
  offset = (weight + 1) * DEC_DIGITS - (dweight + 1);
  ndigits = (ddigits + offset + DEC_DIGITS - 1) / DEC_DIGITS;

  alloc_var(dest, ndigits);
  dest->sign = sign;
  dest->weight = weight;
  dest->dscale = dscale;

  i = DEC_DIGITS - offset;
  digits = dest->digits;

  while (ndigits-- > 0)
  {
#if DEC_DIGITS == 4
    *digits++ = ((decdigits[i] * 10 + decdigits[i + 1]) * 10 +
           decdigits[i + 2]) * 10 + decdigits[i + 3];
#elif DEC_DIGITS == 2
    *digits++ = decdigits[i] * 10 + decdigits[i + 1];
#elif DEC_DIGITS == 1
    *digits++ = decdigits[i];
#else
#error unsupported NBASE
#endif
    i += DEC_DIGITS;
  }

  pfree(decdigits);

  /* Strip any leading/trailing zeroes, and normalize weight if zero */
  strip_var(dest);

  /* Return end+1 position for caller */
  *endptr = cp;

  return true;

out_of_range:
  ereturn(escontext, false,
      (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
       errmsg("value overflows numeric format")));

invalid_syntax:
  ereturn(escontext, false,
      (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
       errmsg("invalid input syntax for type %s: \"%s\"",
          "numeric", str)));
}


/*
 * Return the numeric value of a single hex digit.
 */
static inline int
xdigit_value(char dig)
{
  return dig >= '0' && dig <= '9' ? dig - '0' :
    dig >= 'a' && dig <= 'f' ? dig - 'a' + 10 :
    dig >= 'A' && dig <= 'F' ? dig - 'A' + 10 : -1;
}

/*
 * set_var_from_non_decimal_integer_str()
 *
 *  Parse a string containing a non-decimal integer
 *
 * This function does not handle leading or trailing spaces.  It returns
 * the end+1 position parsed into *endptr, so that caller can check for
 * trailing spaces/garbage if deemed necessary.
 *
 * cp is the place to actually start parsing; str is what to use in error
 * reports.  The number's sign and base prefix indicator (e.g., "0x") are
 * assumed to have already been parsed, so cp should point to the number's
 * first digit in the base specified.
 *
 * base is expected to be 2, 8 or 16.
 *
 * Returns true on success, false on failure (if escontext points to an
 * ErrorSaveContext; otherwise errors are thrown).
 */
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)
{
  const char *firstdigit = cp;
  int64   tmp;
  int64   mul;
  NumericVar  tmp_var;

  init_var(&tmp_var);

  zero_var(dest);

  /*
   * Process input digits in groups that fit in int64.  Here "tmp" is the
   * value of the digits in the group, and "mul" is base^n, where n is the
   * number of digits in the group.  Thus tmp < mul, and we must start a new
   * group when mul * base threatens to overflow PG_INT64_MAX.
   */
  tmp = 0;
  mul = 1;

  if (base == 16)
  {
    while (*cp)
    {
      if (isxdigit((unsigned char) *cp))
      {
        if (mul > PG_INT64_MAX / 16)
        {
          /* Add the contribution from this group of digits */
          int64_to_numericvar(mul, &tmp_var);
          mul_var(dest, &tmp_var, dest, 0);
          int64_to_numericvar(tmp, &tmp_var);
          add_var(dest, &tmp_var, dest);

          /* Result will overflow if weight overflows int16 */
          if (dest->weight > NUMERIC_WEIGHT_MAX)
            goto out_of_range;

          /* Begin a new group */
          tmp = 0;
          mul = 1;
        }

        tmp = tmp * 16 + xdigit_value(*cp++);
        mul = mul * 16;
      }
      else if (*cp == '_')
      {
        /* Underscore must be followed by more digits */
        cp++;
        if (!isxdigit((unsigned char) *cp))
          goto invalid_syntax;
      }
      else
        break;
    }
  }
  else if (base == 8)
  {
    while (*cp)
    {
      if (*cp >= '0' && *cp <= '7')
      {
        if (mul > PG_INT64_MAX / 8)
        {
          /* Add the contribution from this group of digits */
          int64_to_numericvar(mul, &tmp_var);
          mul_var(dest, &tmp_var, dest, 0);
          int64_to_numericvar(tmp, &tmp_var);
          add_var(dest, &tmp_var, dest);

          /* Result will overflow if weight overflows int16 */
          if (dest->weight > NUMERIC_WEIGHT_MAX)
            goto out_of_range;

          /* Begin a new group */
          tmp = 0;
          mul = 1;
        }

        tmp = tmp * 8 + (*cp++ - '0');
        mul = mul * 8;
      }
      else if (*cp == '_')
      {
        /* Underscore must be followed by more digits */
        cp++;
        if (*cp < '0' || *cp > '7')
          goto invalid_syntax;
      }
      else
        break;
    }
  }
  else if (base == 2)
  {
    while (*cp)
    {
      if (*cp >= '0' && *cp <= '1')
      {
        if (mul > PG_INT64_MAX / 2)
        {
          /* Add the contribution from this group of digits */
          int64_to_numericvar(mul, &tmp_var);
          mul_var(dest, &tmp_var, dest, 0);
          int64_to_numericvar(tmp, &tmp_var);
          add_var(dest, &tmp_var, dest);

          /* Result will overflow if weight overflows int16 */
          if (dest->weight > NUMERIC_WEIGHT_MAX)
            goto out_of_range;

          /* Begin a new group */
          tmp = 0;
          mul = 1;
        }

        tmp = tmp * 2 + (*cp++ - '0');
        mul = mul * 2;
      }
      else if (*cp == '_')
      {
        /* Underscore must be followed by more digits */
        cp++;
        if (*cp < '0' || *cp > '1')
          goto invalid_syntax;
      }
      else
        break;
    }
  }
  else
    /* Should never happen; treat as invalid input */
    goto invalid_syntax;

  /* Check that we got at least one digit */
  if (unlikely(cp == firstdigit))
    goto invalid_syntax;

  /* Add the contribution from the final group of digits */
  int64_to_numericvar(mul, &tmp_var);
  mul_var(dest, &tmp_var, dest, 0);
  int64_to_numericvar(tmp, &tmp_var);
  add_var(dest, &tmp_var, dest);

  if (dest->weight > NUMERIC_WEIGHT_MAX)
    goto out_of_range;

  dest->sign = sign;

  free_var(&tmp_var);

  /* Return end+1 position for caller */
  *endptr = cp;

  return true;

out_of_range:
  ereturn(escontext, false,
      (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
       errmsg("value overflows numeric format")));

invalid_syntax:
  ereturn(escontext, false,
      (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
       errmsg("invalid input syntax for type %s: \"%s\"",
          "numeric", str)));
}


/*
 * set_var_from_num() -
 *
 *  Convert the packed db format into a variable
 */
static void
set_var_from_num(Numeric num, NumericVar *dest)
{
  int     ndigits;

  ndigits = NUMERIC_NDIGITS(num);

  alloc_var(dest, ndigits);

  dest->weight = NUMERIC_WEIGHT(num);
  dest->sign = NUMERIC_SIGN(num);
  dest->dscale = NUMERIC_DSCALE(num);

  memcpy(dest->digits, NUMERIC_DIGITS(num), ndigits * sizeof(NumericDigit));
}


/*
 * init_var_from_num() -
 *
 *  Initialize a variable from packed db format. The digits array is not
 *  copied, which saves some cycles when the resulting var is not modified.
 *  Also, there's no need to call free_var(), as long as you don't assign any
 *  other value to it (with set_var_* functions, or by using the var as the
 *  destination of a function like add_var())
 *
 *  CAUTION: Do not modify the digits buffer of a var initialized with this
 *  function, e.g by calling round_var() or trunc_var(), as the changes will
 *  propagate to the original Numeric! It's OK to use it as the destination
 *  argument of one of the calculational functions, though.
 */
static void
init_var_from_num(Numeric num, NumericVar *dest)
{
  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 */
}


/*
 * set_var_from_var() -
 *
 *  Copy one variable into another
 */
static void
set_var_from_var(const NumericVar *value, NumericVar *dest)
{
  NumericDigit *newbuf;

  newbuf = digitbuf_alloc(value->ndigits + 1);
  newbuf[0] = 0;        /* spare digit for rounding */
  if (value->ndigits > 0)   /* else value->digits might be null */
    memcpy(newbuf + 1, value->digits,
         value->ndigits * sizeof(NumericDigit));

  digitbuf_free(dest->buf);

  memmove(dest, value, sizeof(NumericVar));
  dest->buf = newbuf;
  dest->digits = newbuf + 1;
}


/*
 * get_str_from_var() -
 *
 *  Convert a var to text representation (guts of numeric_out).
 *  The var is displayed to the number of digits indicated by its dscale.
 *  Returns a palloc'd string.
 */
static char *
get_str_from_var(const NumericVar *var)
{
  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;
}

/*
 * get_str_from_var_sci() -
 *
 *  Convert a var to a normalised scientific notation text representation.
 *  This function does the heavy lifting for numeric_out_sci().
 *
 *  This notation has the general form a * 10^b, where a is known as the
 *  "significand" and b is known as the "exponent".
 *
 *  Because we can't do superscript in ASCII (and because we want to copy
 *  printf's behaviour) we display the exponent using E notation, with a
 *  minimum of two exponent digits.
 *
 *  For example, the value 1234 could be output as 1.2e+03.
 *
 *  We assume that the exponent can fit into an int32.
 *
 *  rscale is the number of decimal digits desired after the decimal point in
 *  the output, negative values will be treated as meaning zero.
 *
 *  Returns a palloc'd string.
 */
static char *
get_str_from_var_sci(const NumericVar *var, int rscale)
{
  int32   exponent;
  NumericVar  tmp_var;
  size_t    len;
  char     *str;
  char     *sig_out;

  if (rscale < 0)
    rscale = 0;

  /*
   * Determine the exponent of this number in normalised form.
   *
   * This is the exponent required to represent the number with only one
   * significant digit before the decimal place.
   */
  if (var->ndigits > 0)
  {
    exponent = (var->weight + 1) * DEC_DIGITS;

    /*
     * Compensate for leading decimal zeroes in the first numeric digit by
     * decrementing the exponent.
     */
    exponent -= DEC_DIGITS - (int) log10(var->digits[0]);
  }
  else
  {
    /*
     * If var has no digits, then it must be zero.
     *
     * Zero doesn't technically have a meaningful exponent in normalised
     * notation, but we just display the exponent as zero for consistency
     * of output.
     */
    exponent = 0;
  }

  /*
   * Divide var by 10^exponent to get the significand, rounding to rscale
   * decimal digits in the process.
   */
  init_var(&tmp_var);

  power_ten_int(exponent, &tmp_var);
  div_var(var, &tmp_var, &tmp_var, rscale, true, true);
  sig_out = get_str_from_var(&tmp_var);

  free_var(&tmp_var);

  /*
   * Allocate space for the result.
   *
   * In addition to the significand, we need room for the exponent
   * decoration ("e"), the sign of the exponent, up to 10 digits for the
   * exponent itself, and of course the null terminator.
   */
  len = strlen(sig_out) + 13;
  str = palloc(len);
  snprintf(str, len, "%se%+03d", sig_out, exponent);

  pfree(sig_out);

  return str;
}


/*
 * numericvar_serialize - serialize NumericVar to binary format
 *
 * At variable level, no checks are performed on the weight or dscale, allowing
 * us to pass around intermediate values with higher precision than supported
 * by the numeric type.  Note: this is incompatible with numeric_send/recv(),
 * which use 16-bit integers for these fields.
 */
static void
numericvar_serialize(StringInfo buf, const NumericVar *var)
{
  int     i;

  pq_sendint32(buf, var->ndigits);
  pq_sendint32(buf, var->weight);
  pq_sendint32(buf, var->sign);
  pq_sendint32(buf, var->dscale);
  for (i = 0; i < var->ndigits; i++)
    pq_sendint16(buf, var->digits[i]);
}

/*
 * numericvar_deserialize - deserialize binary format to NumericVar
 */
static void
numericvar_deserialize(StringInfo buf, NumericVar *var)
{
  int     len,
        i;

  len = pq_getmsgint(buf, sizeof(int32));

  alloc_var(var, len);    /* sets var->ndigits */

  var->weight = pq_getmsgint(buf, sizeof(int32));
  var->sign = pq_getmsgint(buf, sizeof(int32));
  var->dscale = pq_getmsgint(buf, sizeof(int32));
  for (i = 0; i < len; i++)
    var->digits[i] = pq_getmsgint(buf, sizeof(int16));
}


/*
 * duplicate_numeric() - copy a packed-format Numeric
 *
 * This will handle NaN and Infinity cases.
 */
static Numeric
duplicate_numeric(Numeric num)
{
  Numeric   res;

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

/*
 * make_result_safe() -
 *
 *  Create the packed db numeric format in palloc()'d memory from
 *  a variable.  This will handle NaN and Infinity cases.
 */
static Numeric
make_result_safe(const NumericVar *var, Node *escontext)
{
  Numeric   result;
  NumericDigit *digits = var->digits;
  int     weight = var->weight;
  int     sign = var->sign;
  int     n;
  Size    len;

  if ((sign & NUMERIC_SIGN_MASK) == NUMERIC_SPECIAL)
  {
    /*
     * Verify valid special value.  This could be just an Assert, perhaps,
     * but it seems worthwhile to expend a few cycles to ensure that we
     * never write any nonzero reserved bits to disk.
     */
    if (!(sign == NUMERIC_NAN ||
        sign == NUMERIC_PINF ||
        sign == NUMERIC_NINF))
      elog(ERROR, "invalid numeric sign value 0x%x", sign);

    result = (Numeric) palloc(NUMERIC_HDRSZ_SHORT);

    SET_VARSIZE(result, NUMERIC_HDRSZ_SHORT);
    result->choice.n_header = sign;
    /* the header word is all we need */

    dump_numeric("make_result()", result);
    return result;
  }

  n = var->ndigits;

  /* truncate leading zeroes */
  while (n > 0 && *digits == 0)
  {
    digits++;
    weight--;
    n--;
  }
  /* truncate trailing zeroes */
  while (n > 0 && digits[n - 1] == 0)
    n--;

  /* If zero result, force to weight=0 and positive sign */
  if (n == 0)
  {
    weight = 0;
    sign = NUMERIC_POS;
  }

  /* Build the result */
  if (NUMERIC_CAN_BE_SHORT(var->dscale, weight))
  {
    len = NUMERIC_HDRSZ_SHORT + n * sizeof(NumericDigit);
    result = (Numeric) palloc(len);
    SET_VARSIZE(result, len);
    result->choice.n_short.n_header =
      (sign == NUMERIC_NEG ? (NUMERIC_SHORT | NUMERIC_SHORT_SIGN_MASK)
       : NUMERIC_SHORT)
      | (var->dscale << NUMERIC_SHORT_DSCALE_SHIFT)
      | (weight < 0 ? NUMERIC_SHORT_WEIGHT_SIGN_MASK : 0)
      | (weight & NUMERIC_SHORT_WEIGHT_MASK);
  }
  else
  {
    len = NUMERIC_HDRSZ + n * sizeof(NumericDigit);
    result = (Numeric) palloc(len);
    SET_VARSIZE(result, len);
    result->choice.n_long.n_sign_dscale =
      sign | (var->dscale & NUMERIC_DSCALE_MASK);
    result->choice.n_long.n_weight = weight;
  }

  Assert(NUMERIC_NDIGITS(result) == n);
  if (n > 0)
    memcpy(NUMERIC_DIGITS(result), digits, n * sizeof(NumericDigit));

  /* Check for overflow of int16 fields */
  if (NUMERIC_WEIGHT(result) != weight ||
    NUMERIC_DSCALE(result) != var->dscale)
    ereturn(escontext, NULL,
        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
         errmsg("value overflows numeric format")));

  dump_numeric("make_result()", result);
  return result;
}


/*
 * make_result() -
 *
 *  An interface to make_result_safe() without "escontext" argument.
 */
static Numeric
make_result(const NumericVar *var)
{
  return make_result_safe(var, NULL);
}


/*
 * apply_typmod() -
 *
 *  Do bounds checking and rounding according to the specified typmod.
 *  Note that this is only applied to normal finite values.
 *
 * Returns true on success, false on failure (if escontext points to an
 * ErrorSaveContext; otherwise errors are thrown).
 */
static bool
apply_typmod(NumericVar *var, int32 typmod, Node *escontext)
{
  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;
}

/*
 * apply_typmod_special() -
 *
 *  Do bounds checking according to the specified typmod, for an Inf or NaN.
 *  For convenience of most callers, the value is presented in packed form.
 *
 * Returns true on success, false on failure (if escontext points to an
 * ErrorSaveContext; otherwise errors are thrown).
 */
static bool
apply_typmod_special(Numeric num, int32 typmod, Node *escontext)
{
  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)));
}


/*
 * Convert numeric to int8, rounding if needed.
 *
 * If overflow, return false (no error is raised).  Return true if okay.
 */
static bool
numericvar_to_int64(const NumericVar *var, int64 *result)
{
  NumericDigit *digits;
  int     ndigits;
  int     weight;
  int     i;
  int64   val;
  bool    neg;
  NumericVar  rounded;

  /* Round to nearest integer */
  init_var(&rounded);
  set_var_from_var(var, &rounded);
  round_var(&rounded, 0);

  /* Check for zero input */
  strip_var(&rounded);
  ndigits = rounded.ndigits;
  if (ndigits == 0)
  {
    *result = 0;
    free_var(&rounded);
    return true;
  }

  /*
   * For input like 10000000000, we must treat stripped digits as real. So
   * the loop assumes there are weight+1 digits before the decimal point.
   */
  weight = rounded.weight;
  Assert(weight >= 0 && ndigits <= weight + 1);

  /*
   * Construct the result. To avoid issues with converting a value
   * corresponding to INT64_MIN (which can't be represented as a positive 64
   * bit two's complement integer), accumulate value as a negative number.
   */
  digits = rounded.digits;
  neg = (rounded.sign == NUMERIC_NEG);
  val = -digits[0];
  for (i = 1; i <= weight; i++)
  {
    if (unlikely(pg_mul_s64_overflow(val, NBASE, &val)))
    {
      free_var(&rounded);
      return false;
    }

    if (i < ndigits)
    {
      if (unlikely(pg_sub_s64_overflow(val, digits[i], &val)))
      {
        free_var(&rounded);
        return false;
      }
    }
  }

  free_var(&rounded);

  if (!neg)
  {
    if (unlikely(pg_neg_s64_overflow(val, &val)))
      return false;
  }
  *result = val;

  return true;
}

/*
 * Convert int8 value to numeric.
 */
static void
int64_to_numericvar(int64 val, NumericVar *var)
{
  uint64    uval,
        newuval;
  NumericDigit *ptr;
  int     ndigits;

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

/*
 * Convert numeric to uint64, rounding if needed.
 *
 * If overflow, return false (no error is raised).  Return true if okay.
 */
static bool
numericvar_to_uint64(const NumericVar *var, uint64 *result)
{
  NumericDigit *digits;
  int     ndigits;
  int     weight;
  int     i;
  uint64    val;
  NumericVar  rounded;

  /* Round to nearest integer */
  init_var(&rounded);
  set_var_from_var(var, &rounded);
  round_var(&rounded, 0);

  /* Check for zero input */
  strip_var(&rounded);
  ndigits = rounded.ndigits;
  if (ndigits == 0)
  {
    *result = 0;
    free_var(&rounded);
    return true;
  }

  /* Check for negative input */
  if (rounded.sign == NUMERIC_NEG)
  {
    free_var(&rounded);
    return false;
  }

  /*
   * For input like 10000000000, we must treat stripped digits as real. So
   * the loop assumes there are weight+1 digits before the decimal point.
   */
  weight = rounded.weight;
  Assert(weight >= 0 && ndigits <= weight + 1);

  /* Construct the result */
  digits = rounded.digits;
  val = digits[0];
  for (i = 1; i <= weight; i++)
  {
    if (unlikely(pg_mul_u64_overflow(val, NBASE, &val)))
    {
      free_var(&rounded);
      return false;
    }

    if (i < ndigits)
    {
      if (unlikely(pg_add_u64_overflow(val, digits[i], &val)))
      {
        free_var(&rounded);
        return false;
      }
    }
  }

  free_var(&rounded);

  *result = val;

  return true;
}

/*
 * Convert 128 bit integer to numeric.
 */
static void
int128_to_numericvar(INT128 val, NumericVar *var)
{
  int     sign;
  NumericDigit *ptr;
  int     ndigits;
  int32   dig;

  /* int128 can require at most 39 decimal digits; add one for safety */
  alloc_var(var, 40 / DEC_DIGITS);
  sign = int128_sign(val);
  var->sign = sign < 0 ? NUMERIC_NEG : NUMERIC_POS;
  var->dscale = 0;
  if (sign == 0)
  {
    var->ndigits = 0;
    var->weight = 0;
    return;
  }
  ptr = var->digits + var->ndigits;
  ndigits = 0;
  do
  {
    ptr--;
    ndigits++;
    int128_div_mod_int32(&val, NBASE, &dig);
    *ptr = (NumericDigit) abs(dig);
  } while (!int128_is_zero(val));
  var->digits = ptr;
  var->ndigits = ndigits;
  var->weight = ndigits - 1;
}

/*
 * Convert a NumericVar to float8; if out of range, return +/- HUGE_VAL
 */
static double
numericvar_to_double_no_overflow(const NumericVar *var)
{
  char     *tmp;
  double    val;
  char     *endptr;

  tmp = get_str_from_var(var);

  /* unlike float8in, we ignore ERANGE from strtod */
  val = strtod(tmp, &endptr);
  if (*endptr != '\0')
  {
    /* shouldn't happen ... */
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
         errmsg("invalid input syntax for type %s: \"%s\"",
            "double precision", tmp)));
  }

  pfree(tmp);

  return val;
}


/*
 * cmp_var() -
 *
 *  Compare two values on variable level.  We assume zeroes have been
 *  truncated to no digits.
 */
static int
cmp_var(const NumericVar *var1, const NumericVar *var2)
{
  return cmp_var_common(var1->digits, var1->ndigits,
              var1->weight, var1->sign,
              var2->digits, var2->ndigits,
              var2->weight, var2->sign);
}

/*
 * cmp_var_common() -
 *
 *  Main routine of cmp_var(). This function can be used by both
 *  NumericVar and Numeric.
 */
static int
cmp_var_common(const NumericDigit *var1digits, int var1ndigits,
         int var1weight, int var1sign,
         const NumericDigit *var2digits, int var2ndigits,
         int var2weight, int var2sign)
{
  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);
}


/*
 * add_var() -
 *
 *  Full version of add functionality on variable level (handling signs).
 *  result might point to one of the operands too without danger.
 */
static void
add_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
{
  /*
   * 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;
    }
  }
}


/*
 * sub_var() -
 *
 *  Full version of sub functionality on variable level (handling signs).
 *  result might point to one of the operands too without danger.
 */
static void
sub_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
{
  /*
   * Decide on the signs of the two variables what to do
   */
  if (var1->sign == NUMERIC_POS)
  {
    if (var2->sign == NUMERIC_NEG)
    {
      /* ----------
       * var1 is positive, var2 is negative
       * result = +(ABS(var1) + ABS(var2))
       * ----------
       */
      add_abs(var1, var2, result);
      result->sign = NUMERIC_POS;
    }
    else
    {
      /* ----------
       * Both are positive
       * Must compare absolute values
       * ----------
       */
      switch (cmp_abs(var1, var2))
      {
        case 0:
          /* ----------
           * ABS(var1) == ABS(var2)
           * result = ZERO
           * ----------
           */
          zero_var(result);
          result->dscale = Max(var1->dscale, var2->dscale);
          break;

        case 1:
          /* ----------
           * ABS(var1) > ABS(var2)
           * result = +(ABS(var1) - ABS(var2))
           * ----------
           */
          sub_abs(var1, var2, result);
          result->sign = NUMERIC_POS;
          break;

        case -1:
          /* ----------
           * ABS(var1) < ABS(var2)
           * result = -(ABS(var2) - ABS(var1))
           * ----------
           */
          sub_abs(var2, var1, result);
          result->sign = NUMERIC_NEG;
          break;
      }
    }
  }
  else
  {
    if (var2->sign == NUMERIC_NEG)
    {
      /* ----------
       * Both are negative
       * Must compare absolute values
       * ----------
       */
      switch (cmp_abs(var1, var2))
      {
        case 0:
          /* ----------
           * ABS(var1) == ABS(var2)
           * result = ZERO
           * ----------
           */
          zero_var(result);
          result->dscale = Max(var1->dscale, var2->dscale);
          break;

        case 1:
          /* ----------
           * ABS(var1) > ABS(var2)
           * result = -(ABS(var1) - ABS(var2))
           * ----------
           */
          sub_abs(var1, var2, result);
          result->sign = NUMERIC_NEG;
          break;

        case -1:
          /* ----------
           * ABS(var1) < ABS(var2)
           * result = +(ABS(var2) - ABS(var1))
           * ----------
           */
          sub_abs(var2, var1, result);
          result->sign = NUMERIC_POS;
          break;
      }
    }
    else
    {
      /* ----------
       * var1 is negative, var2 is positive
       * result = -(ABS(var1) + ABS(var2))
       * ----------
       */
      add_abs(var1, var2, result);
      result->sign = NUMERIC_NEG;
    }
  }
}


/*
 * mul_var() -
 *
 *  Multiplication on variable level. Product of var1 * var2 is stored
 *  in result.  Result is rounded to no more than rscale fractional digits.
 */
static void
mul_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result,
    int rscale)
{
  int     res_ndigits;
  int     res_ndigitpairs;
  int     res_sign;
  int     res_weight;
  int     pair_offset;
  int     maxdigits;
  int     maxdigitpairs;
  uint64     *dig,
         *dig_i1_off;
  uint64    maxdig;
  uint64    carry;
  uint64    newdig;
  int     var1ndigits;
  int     var2ndigits;
  int     var1ndigitpairs;
  int     var2ndigitpairs;
  NumericDigit *var1digits;
  NumericDigit *var2digits;
  uint32    var1digitpair;
  uint32     *var2digitpairs;
  NumericDigit *res_digits;
  int     i,
        i1,
        i2,
        i2limit;

  /*
   * Arrange for var1 to be the shorter of the two numbers.  This improves
   * performance because the inner multiplication loop is much simpler than
   * the outer loop, so it's better to have a smaller number of iterations
   * of the outer loop.  This also reduces the number of times that the
   * accumulator array needs to be normalized.
   */
  if (var1->ndigits > var2->ndigits)
  {
    const NumericVar *tmp = var1;

    var1 = var2;
    var2 = tmp;
  }

  /* copy these values into local vars for speed in inner loop */
  var1ndigits = var1->ndigits;
  var2ndigits = var2->ndigits;
  var1digits = var1->digits;
  var2digits = var2->digits;

  if (var1ndigits == 0)
  {
    /* one or both inputs is zero; so is result */
    zero_var(result);
    result->dscale = rscale;
    return;
  }

  /*
   * If var1 has 1-6 digits and the exact result was requested, delegate to
   * mul_var_short() which uses a faster direct multiplication algorithm.
   */
  if (var1ndigits <= 6 && rscale == var1->dscale + var2->dscale)
  {
    mul_var_short(var1, var2, result);
    return;
  }

  /* Determine result sign */
  if (var1->sign == var2->sign)
    res_sign = NUMERIC_POS;
  else
    res_sign = NUMERIC_NEG;

  /*
   * Determine the number of result digits to compute and the (maximum
   * possible) result weight.  If the exact result would have more than
   * rscale fractional digits, truncate the computation with
   * MUL_GUARD_DIGITS guard digits, i.e., ignore input digits that would
   * only contribute to the right of that.  (This will give the exact
   * rounded-to-rscale answer unless carries out of the ignored positions
   * would have propagated through more than MUL_GUARD_DIGITS digits.)
   *
   * Note: an exact computation could not produce more than var1ndigits +
   * var2ndigits digits, but we allocate at least one extra output digit in
   * case rscale-driven rounding produces a carry out of the highest exact
   * digit.
   *
   * The computation itself is done using base-NBASE^2 arithmetic, so we
   * actually process the input digits in pairs, producing a base-NBASE^2
   * intermediate result.  This significantly improves performance, since
   * schoolbook multiplication is O(N^2) in the number of input digits, and
   * working in base NBASE^2 effectively halves "N".
   *
   * Note: in a truncated computation, we must compute at least one extra
   * output digit to ensure that all the guard digits are fully computed.
   */
  /* digit pairs in each input */
  var1ndigitpairs = (var1ndigits + 1) / 2;
  var2ndigitpairs = (var2ndigits + 1) / 2;

  /* digits in exact result */
  res_ndigits = var1ndigits + var2ndigits;

  /* digit pairs in exact result with at least one extra output digit */
  res_ndigitpairs = res_ndigits / 2 + 1;

  /* pair offset to align result to end of dig[] */
  pair_offset = res_ndigitpairs - var1ndigitpairs - var2ndigitpairs + 1;

  /* maximum possible result weight (odd-length inputs shifted up below) */
  res_weight = var1->weight + var2->weight + 1 + 2 * res_ndigitpairs -
    res_ndigits - (var1ndigits & 1) - (var2ndigits & 1);

  /* rscale-based truncation with at least one extra output digit */
  maxdigits = res_weight + 1 + (rscale + DEC_DIGITS - 1) / DEC_DIGITS +
    MUL_GUARD_DIGITS;
  maxdigitpairs = maxdigits / 2 + 1;

  res_ndigitpairs = Min(res_ndigitpairs, maxdigitpairs);
  res_ndigits = 2 * res_ndigitpairs;

  /*
   * In the computation below, digit pair i1 of var1 and digit pair i2 of
   * var2 are multiplied and added to digit i1+i2+pair_offset of dig[]. Thus
   * input digit pairs with index >= res_ndigitpairs - pair_offset don't
   * contribute to the result, and can be ignored.
   */
  if (res_ndigitpairs <= pair_offset)
  {
    /* All input digits will be ignored; so result is zero */
    zero_var(result);
    result->dscale = rscale;
    return;
  }
  var1ndigitpairs = Min(var1ndigitpairs, res_ndigitpairs - pair_offset);
  var2ndigitpairs = Min(var2ndigitpairs, res_ndigitpairs - pair_offset);

  /*
   * We do the arithmetic in an array "dig[]" of unsigned 64-bit integers.
   * Since PG_UINT64_MAX is much larger than NBASE^4, this gives us a lot of
   * headroom to avoid normalizing carries immediately.
   *
   * maxdig tracks the maximum possible value of any dig[] entry; when this
   * threatens to exceed PG_UINT64_MAX, we take the time to propagate
   * carries.  Furthermore, we need to ensure that overflow doesn't occur
   * during the carry propagation passes either.  The carry values could be
   * as much as PG_UINT64_MAX / NBASE^2, so really we must normalize when
   * digits threaten to exceed PG_UINT64_MAX - PG_UINT64_MAX / NBASE^2.
   *
   * To avoid overflow in maxdig itself, it actually represents the maximum
   * possible value divided by NBASE^2-1, i.e., at the top of the loop it is
   * known that no dig[] entry exceeds maxdig * (NBASE^2-1).
   *
   * The conversion of var1 to base NBASE^2 is done on the fly, as each new
   * digit is required.  The digits of var2 are converted upfront, and
   * stored at the end of dig[].  To avoid loss of precision, the input
   * digits are aligned with the start of digit pair array, effectively
   * shifting them up (multiplying by NBASE) if the inputs have an odd
   * number of NBASE digits.
   */
  dig = (uint64 *) palloc(res_ndigitpairs * sizeof(uint64) +
              var2ndigitpairs * sizeof(uint32));

  /* convert var2 to base NBASE^2, shifting up if its length is odd */
  var2digitpairs = (uint32 *) (dig + res_ndigitpairs);

  for (i2 = 0; i2 < var2ndigitpairs - 1; i2++)
    var2digitpairs[i2] = var2digits[2 * i2] * NBASE + var2digits[2 * i2 + 1];

  if (2 * i2 + 1 < var2ndigits)
    var2digitpairs[i2] = var2digits[2 * i2] * NBASE + var2digits[2 * i2 + 1];
  else
    var2digitpairs[i2] = var2digits[2 * i2] * NBASE;

  /*
   * Start by multiplying var2 by the least significant contributing digit
   * pair from var1, storing the results at the end of dig[], and filling
   * the leading digits with zeros.
   *
   * The loop here is the same as the inner loop below, except that we set
   * the results in dig[], rather than adding to them.  This is the
   * performance bottleneck for multiplication, so we want to keep it simple
   * enough so that it can be auto-vectorized.  Accordingly, process the
   * digits left-to-right even though schoolbook multiplication would
   * suggest right-to-left.  Since we aren't propagating carries in this
   * loop, the order does not matter.
   */
  i1 = var1ndigitpairs - 1;
  if (2 * i1 + 1 < var1ndigits)
    var1digitpair = var1digits[2 * i1] * NBASE + var1digits[2 * i1 + 1];
  else
    var1digitpair = var1digits[2 * i1] * NBASE;
  maxdig = var1digitpair;

  i2limit = Min(var2ndigitpairs, res_ndigitpairs - i1 - pair_offset);
  dig_i1_off = &dig[i1 + pair_offset];

  memset(dig, 0, (i1 + pair_offset) * sizeof(uint64));
  for (i2 = 0; i2 < i2limit; i2++)
    dig_i1_off[i2] = (uint64) var1digitpair * var2digitpairs[i2];

  /*
   * Next, multiply var2 by the remaining digit pairs from var1, adding the
   * results to dig[] at the appropriate offsets, and normalizing whenever
   * there is a risk of any dig[] entry overflowing.
   */
  for (i1 = i1 - 1; i1 >= 0; i1--)
  {
    var1digitpair = var1digits[2 * i1] * NBASE + var1digits[2 * i1 + 1];
    if (var1digitpair == 0)
      continue;

    /* Time to normalize? */
    maxdig += var1digitpair;
    if (maxdig > (PG_UINT64_MAX - PG_UINT64_MAX / NBASE_SQR) / (NBASE_SQR - 1))
    {
      /* Yes, do it (to base NBASE^2) */
      carry = 0;
      for (i = res_ndigitpairs - 1; i >= 0; i--)
      {
        newdig = dig[i] + carry;
        if (newdig >= NBASE_SQR)
        {
          carry = newdig / NBASE_SQR;
          newdig -= carry * NBASE_SQR;
        }
        else
          carry = 0;
        dig[i] = newdig;
      }
      Assert(carry == 0);
      /* Reset maxdig to indicate new worst-case */
      maxdig = 1 + var1digitpair;
    }

    /* Multiply and add */
    i2limit = Min(var2ndigitpairs, res_ndigitpairs - i1 - pair_offset);
    dig_i1_off = &dig[i1 + pair_offset];

    for (i2 = 0; i2 < i2limit; i2++)
      dig_i1_off[i2] += (uint64) var1digitpair * var2digitpairs[i2];
  }

  /*
   * Now we do a final carry propagation pass to normalize back to base
   * NBASE^2, and construct the base-NBASE result digits.  Note that this is
   * still done at full precision w/guard digits.
   */
  alloc_var(result, res_ndigits);
  res_digits = result->digits;
  carry = 0;
  for (i = res_ndigitpairs - 1; i >= 0; i--)
  {
    newdig = dig[i] + carry;
    if (newdig >= NBASE_SQR)
    {
      carry = newdig / NBASE_SQR;
      newdig -= carry * NBASE_SQR;
    }
    else
      carry = 0;
    res_digits[2 * i + 1] = (NumericDigit) ((uint32) newdig % NBASE);
    res_digits[2 * i] = (NumericDigit) ((uint32) newdig / NBASE);
  }
  Assert(carry == 0);

  pfree(dig);

  /*
   * Finally, round the result to the requested precision.
   */
  result->weight = res_weight;
  result->sign = res_sign;

  /* Round to target rscale (and set result->dscale) */
  round_var(result, rscale);

  /* Strip leading and trailing zeroes */
  strip_var(result);
}


/*
 * mul_var_short() -
 *
 *  Special-case multiplication function used when var1 has 1-6 digits, var2
 *  has at least as many digits as var1, and the exact product var1 * var2 is
 *  requested.
 */
static void
mul_var_short(const NumericVar *var1, const NumericVar *var2,
        NumericVar *result)
{
  int     var1ndigits = var1->ndigits;
  int     var2ndigits = var2->ndigits;
  NumericDigit *var1digits = var1->digits;
  NumericDigit *var2digits = var2->digits;
  int     res_sign;
  int     res_weight;
  int     res_ndigits;
  NumericDigit *res_buf;
  NumericDigit *res_digits;
  uint32    carry = 0;
  uint32    term;

  /* Check preconditions */
  Assert(var1ndigits >= 1);
  Assert(var1ndigits <= 6);
  Assert(var2ndigits >= var1ndigits);

  /*
   * Determine the result sign, weight, and number of digits to calculate.
   * The weight figured here is correct if the product has no leading zero
   * digits; otherwise strip_var() will fix things up.  Note that, unlike
   * mul_var(), we do not need to allocate an extra output digit, because we
   * are not rounding here.
   */
  if (var1->sign == var2->sign)
    res_sign = NUMERIC_POS;
  else
    res_sign = NUMERIC_NEG;
  res_weight = var1->weight + var2->weight + 1;
  res_ndigits = var1ndigits + var2ndigits;

  /* Allocate result digit array */
  res_buf = digitbuf_alloc(res_ndigits + 1);
  res_buf[0] = 0;       /* spare digit for later rounding */
  res_digits = res_buf + 1;

  /*
   * Compute the result digits in reverse, in one pass, propagating the
   * carry up as we go.  The i'th result digit consists of the sum of the
   * products var1digits[i1] * var2digits[i2] for which i = i1 + i2 + 1.
   */
#define PRODSUM1(v1,i1,v2,i2) ((v1)[(i1)] * (v2)[(i2)])
#define PRODSUM2(v1,i1,v2,i2) (PRODSUM1(v1,i1,v2,i2) + (v1)[(i1)+1] * (v2)[(i2)-1])
#define PRODSUM3(v1,i1,v2,i2) (PRODSUM2(v1,i1,v2,i2) + (v1)[(i1)+2] * (v2)[(i2)-2])
#define PRODSUM4(v1,i1,v2,i2) (PRODSUM3(v1,i1,v2,i2) + (v1)[(i1)+3] * (v2)[(i2)-3])
#define PRODSUM5(v1,i1,v2,i2) (PRODSUM4(v1,i1,v2,i2) + (v1)[(i1)+4] * (v2)[(i2)-4])
#define PRODSUM6(v1,i1,v2,i2) (PRODSUM5(v1,i1,v2,i2) + (v1)[(i1)+5] * (v2)[(i2)-5])

  switch (var1ndigits)
  {
    case 1:
      /* ---------
       * 1-digit case:
       *    var1ndigits = 1
       *    var2ndigits >= 1
       *    res_ndigits = var2ndigits + 1
       * ----------
       */
      for (int i = var2ndigits - 1; i >= 0; i--)
      {
        term = PRODSUM1(var1digits, 0, var2digits, i) + carry;
        res_digits[i + 1] = (NumericDigit) (term % NBASE);
        carry = term / NBASE;
      }
      res_digits[0] = (NumericDigit) carry;
      break;

    case 2:
      /* ---------
       * 2-digit case:
       *    var1ndigits = 2
       *    var2ndigits >= 2
       *    res_ndigits = var2ndigits + 2
       * ----------
       */
      /* last result digit and carry */
      term = PRODSUM1(var1digits, 1, var2digits, var2ndigits - 1);
      res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      /* remaining digits, except for the first two */
      for (int i = var2ndigits - 1; i >= 1; i--)
      {
        term = PRODSUM2(var1digits, 0, var2digits, i) + carry;
        res_digits[i + 1] = (NumericDigit) (term % NBASE);
        carry = term / NBASE;
      }
      break;

    case 3:
      /* ---------
       * 3-digit case:
       *    var1ndigits = 3
       *    var2ndigits >= 3
       *    res_ndigits = var2ndigits + 3
       * ----------
       */
      /* last two result digits */
      term = PRODSUM1(var1digits, 2, var2digits, var2ndigits - 1);
      res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      term = PRODSUM2(var1digits, 1, var2digits, var2ndigits - 1) + carry;
      res_digits[res_ndigits - 2] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      /* remaining digits, except for the first three */
      for (int i = var2ndigits - 1; i >= 2; i--)
      {
        term = PRODSUM3(var1digits, 0, var2digits, i) + carry;
        res_digits[i + 1] = (NumericDigit) (term % NBASE);
        carry = term / NBASE;
      }
      break;

    case 4:
      /* ---------
       * 4-digit case:
       *    var1ndigits = 4
       *    var2ndigits >= 4
       *    res_ndigits = var2ndigits + 4
       * ----------
       */
      /* last three result digits */
      term = PRODSUM1(var1digits, 3, var2digits, var2ndigits - 1);
      res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      term = PRODSUM2(var1digits, 2, var2digits, var2ndigits - 1) + carry;
      res_digits[res_ndigits - 2] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      term = PRODSUM3(var1digits, 1, var2digits, var2ndigits - 1) + carry;
      res_digits[res_ndigits - 3] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      /* remaining digits, except for the first four */
      for (int i = var2ndigits - 1; i >= 3; i--)
      {
        term = PRODSUM4(var1digits, 0, var2digits, i) + carry;
        res_digits[i + 1] = (NumericDigit) (term % NBASE);
        carry = term / NBASE;
      }
      break;

    case 5:
      /* ---------
       * 5-digit case:
       *    var1ndigits = 5
       *    var2ndigits >= 5
       *    res_ndigits = var2ndigits + 5
       * ----------
       */
      /* last four result digits */
      term = PRODSUM1(var1digits, 4, var2digits, var2ndigits - 1);
      res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      term = PRODSUM2(var1digits, 3, var2digits, var2ndigits - 1) + carry;
      res_digits[res_ndigits - 2] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      term = PRODSUM3(var1digits, 2, var2digits, var2ndigits - 1) + carry;
      res_digits[res_ndigits - 3] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      term = PRODSUM4(var1digits, 1, var2digits, var2ndigits - 1) + carry;
      res_digits[res_ndigits - 4] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      /* remaining digits, except for the first five */
      for (int i = var2ndigits - 1; i >= 4; i--)
      {
        term = PRODSUM5(var1digits, 0, var2digits, i) + carry;
        res_digits[i + 1] = (NumericDigit) (term % NBASE);
        carry = term / NBASE;
      }
      break;

    case 6:
      /* ---------
       * 6-digit case:
       *    var1ndigits = 6
       *    var2ndigits >= 6
       *    res_ndigits = var2ndigits + 6
       * ----------
       */
      /* last five result digits */
      term = PRODSUM1(var1digits, 5, var2digits, var2ndigits - 1);
      res_digits[res_ndigits - 1] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      term = PRODSUM2(var1digits, 4, var2digits, var2ndigits - 1) + carry;
      res_digits[res_ndigits - 2] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      term = PRODSUM3(var1digits, 3, var2digits, var2ndigits - 1) + carry;
      res_digits[res_ndigits - 3] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      term = PRODSUM4(var1digits, 2, var2digits, var2ndigits - 1) + carry;
      res_digits[res_ndigits - 4] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      term = PRODSUM5(var1digits, 1, var2digits, var2ndigits - 1) + carry;
      res_digits[res_ndigits - 5] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;

      /* remaining digits, except for the first six */
      for (int i = var2ndigits - 1; i >= 5; i--)
      {
        term = PRODSUM6(var1digits, 0, var2digits, i) + carry;
        res_digits[i + 1] = (NumericDigit) (term % NBASE);
        carry = term / NBASE;
      }
      break;
  }

  /*
   * Finally, for var1ndigits > 1, compute the remaining var1ndigits most
   * significant result digits.
   */
  switch (var1ndigits)
  {
    case 6:
      term = PRODSUM5(var1digits, 0, var2digits, 4) + carry;
      res_digits[5] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;
      pg_fallthrough;
    case 5:
      term = PRODSUM4(var1digits, 0, var2digits, 3) + carry;
      res_digits[4] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;
      pg_fallthrough;
    case 4:
      term = PRODSUM3(var1digits, 0, var2digits, 2) + carry;
      res_digits[3] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;
      pg_fallthrough;
    case 3:
      term = PRODSUM2(var1digits, 0, var2digits, 1) + carry;
      res_digits[2] = (NumericDigit) (term % NBASE);
      carry = term / NBASE;
      pg_fallthrough;
    case 2:
      term = PRODSUM1(var1digits, 0, var2digits, 0) + carry;
      res_digits[1] = (NumericDigit) (term % NBASE);
      res_digits[0] = (NumericDigit) (term / NBASE);
      break;
  }

  /* Store the product in result */
  digitbuf_free(result->buf);
  result->ndigits = res_ndigits;
  result->buf = res_buf;
  result->digits = res_digits;
  result->weight = res_weight;
  result->sign = res_sign;
  result->dscale = var1->dscale + var2->dscale;

  /* Strip leading and trailing zeroes */
  strip_var(result);
}


/*
 * div_var() -
 *
 *  Compute the quotient var1 / var2 to rscale fractional digits.
 *
 *  If "round" is true, the result is rounded at the rscale'th digit; if
 *  false, it is truncated (towards zero) at that digit.
 *
 *  If "exact" is true, the exact result is computed to the specified rscale;
 *  if false, successive quotient digits are approximated up to rscale plus
 *  DIV_GUARD_DIGITS extra digits, ignoring all contributions from digits to
 *  the right of that, before rounding or truncating to the specified rscale.
 *  This can be significantly faster, and usually gives the same result as the
 *  exact computation, but it may occasionally be off by one in the final
 *  digit, if contributions from the ignored digits would have propagated
 *  through the guard digits.  This is good enough for the transcendental
 *  functions, where small errors are acceptable.
 */
static void
div_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result,
    int rscale, bool round, bool exact)
{
  int     var1ndigits = var1->ndigits;
  int     var2ndigits = var2->ndigits;
  int     res_sign;
  int     res_weight;
  int     res_ndigits;
  int     var1ndigitpairs;
  int     var2ndigitpairs;
  int     res_ndigitpairs;
  int     div_ndigitpairs;
  int64    *dividend;
  int32    *divisor;
  double    fdivisor,
        fdivisorinverse,
        fdividend,
        fquotient;
  int64   maxdiv;
  int     qi;
  int32   qdigit;
  int64   carry;
  int64   newdig;
  int64    *remainder;
  NumericDigit *res_digits;
  int     i;

  /*
   * First of all division by zero check; we must not be handed an
   * unnormalized divisor.
   */
  if (var2ndigits == 0 || var2->digits[0] == 0)
    ereport(ERROR,
        (errcode(ERRCODE_DIVISION_BY_ZERO),
         errmsg("division by zero")));

  /*
   * If the divisor has just one or two digits, delegate to div_var_int(),
   * which uses fast short division.
   *
   * Similarly, on platforms with 128-bit integer support, delegate to
   * div_var_int64() for divisors with three or four digits.
   */
  if (var2ndigits <= 2)
  {
    int     idivisor;
    int     idivisor_weight;

    idivisor = var2->digits[0];
    idivisor_weight = var2->weight;
    if (var2ndigits == 2)
    {
      idivisor = idivisor * NBASE + var2->digits[1];
      idivisor_weight--;
    }
    if (var2->sign == NUMERIC_NEG)
      idivisor = -idivisor;

    div_var_int(var1, idivisor, idivisor_weight, result, rscale, round);
    return;
  }
#ifdef HAVE_INT128
  if (var2ndigits <= 4)
  {
    int64   idivisor;
    int     idivisor_weight;

    idivisor = var2->digits[0];
    idivisor_weight = var2->weight;
    for (i = 1; i < var2ndigits; i++)
    {
      idivisor = idivisor * NBASE + var2->digits[i];
      idivisor_weight--;
    }
    if (var2->sign == NUMERIC_NEG)
      idivisor = -idivisor;

    div_var_int64(var1, idivisor, idivisor_weight, result, rscale, round);
    return;
  }
#endif

  /*
   * Otherwise, perform full long division.
   */

  /* Result zero check */
  if (var1ndigits == 0)
  {
    zero_var(result);
    result->dscale = rscale;
    return;
  }

  /*
   * The approximate computation can be significantly faster than the exact
   * one, since the working dividend is var2ndigitpairs base-NBASE^2 digits
   * shorter below.  However, that comes with the tradeoff of computing
   * DIV_GUARD_DIGITS extra base-NBASE result digits.  Ignoring all other
   * overheads, that suggests that, in theory, the approximate computation
   * will only be faster than the exact one when var2ndigits is greater than
   * 2 * (DIV_GUARD_DIGITS + 1), independent of the size of var1.
   *
   * Thus, we're better off doing an exact computation when var2 is shorter
   * than this.  Empirically, it has been found that the exact threshold is
   * a little higher, due to other overheads in the outer division loop.
   */
  if (var2ndigits <= 2 * (DIV_GUARD_DIGITS + 2))
    exact = true;

  /*
   * Determine the result sign, weight and number of digits to calculate.
   * The weight figured here is correct if the emitted quotient has no
   * leading zero digits; otherwise strip_var() will fix things up.
   */
  if (var1->sign == var2->sign)
    res_sign = NUMERIC_POS;
  else
    res_sign = NUMERIC_NEG;
  res_weight = var1->weight - var2->weight + 1;
  /* The number of accurate result digits we need to produce: */
  res_ndigits = res_weight + 1 + (rscale + DEC_DIGITS - 1) / DEC_DIGITS;
  /* ... but always at least 1 */
  res_ndigits = Max(res_ndigits, 1);
  /* If rounding needed, figure one more digit to ensure correct result */
  if (round)
    res_ndigits++;
  /* Add guard digits for roundoff error when producing approx result */
  if (!exact)
    res_ndigits += DIV_GUARD_DIGITS;

  /*
   * The computation itself is done using base-NBASE^2 arithmetic, so we
   * actually process the input digits in pairs, producing a base-NBASE^2
   * intermediate result.  This significantly improves performance, since
   * the computation is O(N^2) in the number of input digits, and working in
   * base NBASE^2 effectively halves "N".
   */
  var1ndigitpairs = (var1ndigits + 1) / 2;
  var2ndigitpairs = (var2ndigits + 1) / 2;
  res_ndigitpairs = (res_ndigits + 1) / 2;
  res_ndigits = 2 * res_ndigitpairs;

  /*
   * We do the arithmetic in an array "dividend[]" of signed 64-bit
   * integers.  Since PG_INT64_MAX is much larger than NBASE^4, this gives
   * us a lot of headroom to avoid normalizing carries immediately.
   *
   * When performing an exact computation, the working dividend requires
   * res_ndigitpairs + var2ndigitpairs digits.  If var1 is larger than that,
   * the extra digits do not contribute to the result, and are ignored.
   *
   * When performing an approximate computation, the working dividend only
   * requires res_ndigitpairs digits (which includes the extra guard
   * digits).  All input digits beyond that are ignored.
   */
  if (exact)
  {
    div_ndigitpairs = res_ndigitpairs + var2ndigitpairs;
    var1ndigitpairs = Min(var1ndigitpairs, div_ndigitpairs);
  }
  else
  {
    div_ndigitpairs = res_ndigitpairs;
    var1ndigitpairs = Min(var1ndigitpairs, div_ndigitpairs);
    var2ndigitpairs = Min(var2ndigitpairs, div_ndigitpairs);
  }

  /*
   * Allocate room for the working dividend (div_ndigitpairs 64-bit digits)
   * plus the divisor (var2ndigitpairs 32-bit base-NBASE^2 digits).
   *
   * For convenience, we allocate one extra dividend digit, which is set to
   * zero and not counted in div_ndigitpairs, so that the main loop below
   * can safely read and write the (qi+1)'th digit in the approximate case.
   */
  dividend = (int64 *) palloc((div_ndigitpairs + 1) * sizeof(int64) +
                var2ndigitpairs * sizeof(int32));
  divisor = (int32 *) (dividend + div_ndigitpairs + 1);

  /* load var1 into dividend[0 .. var1ndigitpairs-1], zeroing the rest */
  for (i = 0; i < var1ndigitpairs - 1; i++)
    dividend[i] = var1->digits[2 * i] * NBASE + var1->digits[2 * i + 1];

  if (2 * i + 1 < var1ndigits)
    dividend[i] = var1->digits[2 * i] * NBASE + var1->digits[2 * i + 1];
  else
    dividend[i] = var1->digits[2 * i] * NBASE;

  memset(dividend + i + 1, 0, (div_ndigitpairs - i) * sizeof(int64));

  /* load var2 into divisor[0 .. var2ndigitpairs-1] */
  for (i = 0; i < var2ndigitpairs - 1; i++)
    divisor[i] = var2->digits[2 * i] * NBASE + var2->digits[2 * i + 1];

  if (2 * i + 1 < var2ndigits)
    divisor[i] = var2->digits[2 * i] * NBASE + var2->digits[2 * i + 1];
  else
    divisor[i] = var2->digits[2 * i] * NBASE;

  /*
   * We estimate each quotient digit using floating-point arithmetic, taking
   * the first 2 base-NBASE^2 digits of the (current) dividend and divisor.
   * This must be float to avoid overflow.
   *
   * Since the floating-point dividend and divisor use 4 base-NBASE input
   * digits, they include roughly 40-53 bits of information from their
   * respective inputs (assuming NBASE is 10000), which fits well in IEEE
   * double-precision variables.  The relative error in the floating-point
   * quotient digit will then be less than around 2/NBASE^3, so the
   * estimated base-NBASE^2 quotient digit will typically be correct, and
   * should not be off by more than one from the correct value.
   */
  fdivisor = (double) divisor[0] * NBASE_SQR;
  if (var2ndigitpairs > 1)
    fdivisor += (double) divisor[1];
  fdivisorinverse = 1.0 / fdivisor;

  /*
   * maxdiv tracks the maximum possible absolute value of any dividend[]
   * entry; when this threatens to exceed PG_INT64_MAX, we take the time to
   * propagate carries.  Furthermore, we need to ensure that overflow
   * doesn't occur during the carry propagation passes either.  The carry
   * values may have an absolute value as high as PG_INT64_MAX/NBASE^2 + 1,
   * so really we must normalize when digits threaten to exceed PG_INT64_MAX
   * - PG_INT64_MAX/NBASE^2 - 1.
   *
   * To avoid overflow in maxdiv itself, it represents the max absolute
   * value divided by NBASE^2-1, i.e., at the top of the loop it is known
   * that no dividend[] entry has an absolute value exceeding maxdiv *
   * (NBASE^2-1).
   *
   * Actually, though, that holds good only for dividend[] entries after
   * dividend[qi]; the adjustment done at the bottom of the loop may cause
   * dividend[qi + 1] to exceed the maxdiv limit, so that dividend[qi] in
   * the next iteration is beyond the limit.  This does not cause problems,
   * as explained below.
   */
  maxdiv = 1;

  /*
   * Outer loop computes next quotient digit, which goes in dividend[qi].
   */
  for (qi = 0; qi < res_ndigitpairs; qi++)
  {
    /* Approximate the current dividend value */
    fdividend = (double) dividend[qi] * NBASE_SQR;
    fdividend += (double) dividend[qi + 1];

    /* Compute the (approximate) quotient digit */
    fquotient = fdividend * fdivisorinverse;
    qdigit = (fquotient >= 0.0) ? ((int32) fquotient) :
      (((int32) fquotient) - 1); /* truncate towards -infinity */

    if (qdigit != 0)
    {
      /* Do we need to normalize now? */
      maxdiv += i64abs(qdigit);
      if (maxdiv > (PG_INT64_MAX - PG_INT64_MAX / NBASE_SQR - 1) / (NBASE_SQR - 1))
      {
        /*
         * Yes, do it.  Note that if var2ndigitpairs is much smaller
         * than div_ndigitpairs, we can save a significant amount of
         * effort here by noting that we only need to normalise those
         * dividend[] entries touched where prior iterations
         * subtracted multiples of the divisor.
         */
        carry = 0;
        for (i = Min(qi + var2ndigitpairs - 2, div_ndigitpairs - 1); i > qi; i--)
        {
          newdig = dividend[i] + carry;
          if (newdig < 0)
          {
            carry = -((-newdig - 1) / NBASE_SQR) - 1;
            newdig -= carry * NBASE_SQR;
          }
          else if (newdig >= NBASE_SQR)
          {
            carry = newdig / NBASE_SQR;
            newdig -= carry * NBASE_SQR;
          }
          else
            carry = 0;
          dividend[i] = newdig;
        }
        dividend[qi] += carry;

        /*
         * All the dividend[] digits except possibly dividend[qi] are
         * now in the range 0..NBASE^2-1.  We do not need to consider
         * dividend[qi] in the maxdiv value anymore, so we can reset
         * maxdiv to 1.
         */
        maxdiv = 1;

        /*
         * Recompute the quotient digit since new info may have
         * propagated into the top two dividend digits.
         */
        fdividend = (double) dividend[qi] * NBASE_SQR;
        fdividend += (double) dividend[qi + 1];
        fquotient = fdividend * fdivisorinverse;
        qdigit = (fquotient >= 0.0) ? ((int32) fquotient) :
          (((int32) fquotient) - 1); /* truncate towards -infinity */

        maxdiv += i64abs(qdigit);
      }

      /*
       * Subtract off the appropriate multiple of the divisor.
       *
       * The digits beyond dividend[qi] cannot overflow, because we know
       * they will fall within the maxdiv limit.  As for dividend[qi]
       * itself, note that qdigit is approximately trunc(dividend[qi] /
       * divisor[0]), which would make the new value simply dividend[qi]
       * mod divisor[0].  The lower-order terms in qdigit can change
       * this result by not more than about twice PG_INT64_MAX/NBASE^2,
       * so overflow is impossible.
       *
       * This inner loop is the performance bottleneck for division, so
       * code it in the same way as the inner loop of mul_var() so that
       * it can be auto-vectorized.
       */
      if (qdigit != 0)
      {
        int     istop = Min(var2ndigitpairs, div_ndigitpairs - qi);
        int64    *dividend_qi = &dividend[qi];

        for (i = 0; i < istop; i++)
          dividend_qi[i] -= (int64) qdigit * divisor[i];
      }
    }

    /*
     * The dividend digit we are about to replace might still be nonzero.
     * Fold it into the next digit position.
     *
     * There is no risk of overflow here, although proving that requires
     * some care.  Much as with the argument for dividend[qi] not
     * overflowing, if we consider the first two terms in the numerator
     * and denominator of qdigit, we can see that the final value of
     * dividend[qi + 1] will be approximately a remainder mod
     * (divisor[0]*NBASE^2 + divisor[1]).  Accounting for the lower-order
     * terms is a bit complicated but ends up adding not much more than
     * PG_INT64_MAX/NBASE^2 to the possible range.  Thus, dividend[qi + 1]
     * cannot overflow here, and in its role as dividend[qi] in the next
     * loop iteration, it can't be large enough to cause overflow in the
     * carry propagation step (if any), either.
     *
     * But having said that: dividend[qi] can be more than
     * PG_INT64_MAX/NBASE^2, as noted above, which means that the product
     * dividend[qi] * NBASE^2 *can* overflow.  When that happens, adding
     * it to dividend[qi + 1] will always cause a canceling overflow so
     * that the end result is correct.  We could avoid the intermediate
     * overflow by doing the multiplication and addition using unsigned
     * int64 arithmetic, which is modulo 2^64, but so far there appears no
     * need.
     */
    dividend[qi + 1] += dividend[qi] * NBASE_SQR;

    dividend[qi] = qdigit;
  }

  /*
   * If an exact result was requested, use the remainder to correct the
   * approximate quotient.  The remainder is in dividend[], immediately
   * after the quotient digits.  Note, however, that although the remainder
   * starts at dividend[qi = res_ndigitpairs], the first digit is the result
   * of folding two remainder digits into one above, and the remainder
   * currently only occupies var2ndigitpairs - 1 digits (the last digit of
   * the working dividend was untouched by the computation above).  Thus we
   * expand the remainder down by one base-NBASE^2 digit when we normalize
   * it, so that it completely fills the last var2ndigitpairs digits of the
   * dividend array.
   */
  if (exact)
  {
    /* Normalize the remainder, expanding it down by one digit */
    remainder = &dividend[qi];
    carry = 0;
    for (i = var2ndigitpairs - 2; i >= 0; i--)
    {
      newdig = remainder[i] + carry;
      if (newdig < 0)
      {
        carry = -((-newdig - 1) / NBASE_SQR) - 1;
        newdig -= carry * NBASE_SQR;
      }
      else if (newdig >= NBASE_SQR)
      {
        carry = newdig / NBASE_SQR;
        newdig -= carry * NBASE_SQR;
      }
      else
        carry = 0;
      remainder[i + 1] = newdig;
    }
    remainder[0] = carry;

    if (remainder[0] < 0)
    {
      /*
       * The remainder is negative, so the approximate quotient is too
       * large.  Correct by reducing the quotient by one and adding the
       * divisor to the remainder until the remainder is positive.  We
       * expect the quotient to be off by at most one, which has been
       * borne out in all testing, but not conclusively proven, so we
       * allow for larger corrections, just in case.
       */
      do
      {
        /* Add the divisor to the remainder */
        carry = 0;
        for (i = var2ndigitpairs - 1; i > 0; i--)
        {
          newdig = remainder[i] + divisor[i] + carry;
          if (newdig >= NBASE_SQR)
          {
            remainder[i] = newdig - NBASE_SQR;
            carry = 1;
          }
          else
          {
            remainder[i] = newdig;
            carry = 0;
          }
        }
        remainder[0] += divisor[0] + carry;

        /* Subtract 1 from the quotient (propagating carries later) */
        dividend[qi - 1]--;

      } while (remainder[0] < 0);
    }
    else
    {
      /*
       * The remainder is nonnegative.  If it's greater than or equal to
       * the divisor, then the approximate quotient is too small and
       * must be corrected.  As above, we don't expect to have to apply
       * more than one correction, but allow for it just in case.
       */
      while (true)
      {
        bool    less = false;

        /* Is remainder < divisor? */
        for (i = 0; i < var2ndigitpairs; i++)
        {
          if (remainder[i] < divisor[i])
          {
            less = true;
            break;
          }
          if (remainder[i] > divisor[i])
            break; /* remainder > divisor */
        }
        if (less)
          break;   /* quotient is correct */

        /* Subtract the divisor from the remainder */
        carry = 0;
        for (i = var2ndigitpairs - 1; i > 0; i--)
        {
          newdig = remainder[i] - divisor[i] + carry;
          if (newdig < 0)
          {
            remainder[i] = newdig + NBASE_SQR;
            carry = -1;
          }
          else
          {
            remainder[i] = newdig;
            carry = 0;
          }
        }
        remainder[0] = remainder[0] - divisor[0] + carry;

        /* Add 1 to the quotient (propagating carries later) */
        dividend[qi - 1]++;
      }
    }
  }

  /*
   * Because the quotient digits were estimates that might have been off by
   * one (and we didn't bother propagating carries when adjusting the
   * quotient above), some quotient digits might be out of range, so do a
   * final carry propagation pass to normalize back to base NBASE^2, and
   * construct the base-NBASE result digits.  Note that this is still done
   * at full precision w/guard digits.
   */
  alloc_var(result, res_ndigits);
  res_digits = result->digits;
  carry = 0;
  for (i = res_ndigitpairs - 1; i >= 0; i--)
  {
    newdig = dividend[i] + carry;
    if (newdig < 0)
    {
      carry = -((-newdig - 1) / NBASE_SQR) - 1;
      newdig -= carry * NBASE_SQR;
    }
    else if (newdig >= NBASE_SQR)
    {
      carry = newdig / NBASE_SQR;
      newdig -= carry * NBASE_SQR;
    }
    else
      carry = 0;
    res_digits[2 * i + 1] = (NumericDigit) ((uint32) newdig % NBASE);
    res_digits[2 * i] = (NumericDigit) ((uint32) newdig / NBASE);
  }
  Assert(carry == 0);

  pfree(dividend);

  /*
   * Finally, round or truncate the result to the requested precision.
   */
  result->weight = res_weight;
  result->sign = res_sign;

  /* Round or truncate to target rscale (and set result->dscale) */
  if (round)
    round_var(result, rscale);
  else
    trunc_var(result, rscale);

  /* Strip leading and trailing zeroes */
  strip_var(result);
}


/*
 * div_var_int() -
 *
 *  Divide a numeric variable by a 32-bit integer with the specified weight.
 *  The quotient var / (ival * NBASE^ival_weight) is stored in result.
 */
static void
div_var_int(const NumericVar *var, int ival, int ival_weight,
      NumericVar *result, int rscale, bool round)
{
  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);
}


#ifdef HAVE_INT128
/*
 * div_var_int64() -
 *
 *  Divide a numeric variable by a 64-bit integer with the specified weight.
 *  The quotient var / (ival * NBASE^ival_weight) is stored in result.
 *
 *  This duplicates the logic in div_var_int(), so any changes made there
 *  should be made here too.
 */
static void
div_var_int64(const NumericVar *var, int64 ival, int ival_weight,
        NumericVar *result, int rscale, bool round)
{
  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;
  uint64    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 128-bit
   * integer if this exceeds PG_UINT64_MAX.
   */
  divisor = i64abs(ival);

  if (divisor <= PG_UINT64_MAX / NBASE)
  {
    /* carry cannot overflow 64 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;
    }
  }
  else
  {
    /* carry may exceed 64 bits */
    uint128   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);
}
#endif


/*
 * Default scale selection for division
 *
 * Returns the appropriate result scale for the division result.
 */
static int
select_div_scale(const NumericVar *var1, const NumericVar *var2)
{
  int     weight1,
        weight2,
        qweight,
        i;
  NumericDigit firstdigit1,
        firstdigit2;
  int     rscale;

  /*
   * The result scale of a division isn't specified in any SQL standard. For
   * PostgreSQL we select a result scale that will give at least
   * NUMERIC_MIN_SIG_DIGITS significant digits, so that numeric gives a
   * result no less accurate than float8; but use a scale not less than
   * either input's display scale.
   */

  /* Get the actual (normalized) weight and first digit of each input */

  weight1 = 0;        /* values to use if var1 is zero */
  firstdigit1 = 0;
  for (i = 0; i < var1->ndigits; i++)
  {
    firstdigit1 = var1->digits[i];
    if (firstdigit1 != 0)
    {
      weight1 = var1->weight - i;
      break;
    }
  }

  weight2 = 0;        /* values to use if var2 is zero */
  firstdigit2 = 0;
  for (i = 0; i < var2->ndigits; i++)
  {
    firstdigit2 = var2->digits[i];
    if (firstdigit2 != 0)
    {
      weight2 = var2->weight - i;
      break;
    }
  }

  /*
   * Estimate weight of quotient.  If the two first digits are equal, we
   * can't be sure, but assume that var1 is less than var2.
   */
  qweight = weight1 - weight2;
  if (firstdigit1 <= firstdigit2)
    qweight--;

  /* Select result scale */
  rscale = NUMERIC_MIN_SIG_DIGITS - qweight * DEC_DIGITS;
  rscale = Max(rscale, var1->dscale);
  rscale = Max(rscale, var2->dscale);
  rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
  rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);

  return rscale;
}


/*
 * mod_var() -
 *
 *  Calculate the modulo of two numerics at variable level
 */
static void
mod_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
{
  NumericVar  tmp;

  init_var(&tmp);

  /* ---------
   * We do this using the equation
   *    mod(x,y) = x - trunc(x/y)*y
   * div_var can be persuaded to give us trunc(x/y) directly.
   * ----------
   */
  div_var(var1, var2, &tmp, 0, false, true);

  mul_var(var2, &tmp, &tmp, var2->dscale);

  sub_var(var1, &tmp, result);

  free_var(&tmp);
}


/*
 * div_mod_var() -
 *
 *  Calculate the truncated integer quotient and numeric remainder of two
 *  numeric variables.  The remainder is precise to var2's dscale.
 */
static void
div_mod_var(const NumericVar *var1, const NumericVar *var2,
      NumericVar *quot, NumericVar *rem)
{
  NumericVar  q;
  NumericVar  r;

  init_var(&q);
  init_var(&r);

  /*
   * Use div_var() with exact = false to get an initial estimate for the
   * integer quotient (truncated towards zero).  This might be slightly
   * inaccurate, but we correct it below.
   */
  div_var(var1, var2, &q, 0, false, false);

  /* Compute initial estimate of remainder using the quotient estimate. */
  mul_var(var2, &q, &r, var2->dscale);
  sub_var(var1, &r, &r);

  /*
   * Adjust the results if necessary --- the remainder should have the same
   * sign as var1, and its absolute value should be less than the absolute
   * value of var2.
   */
  while (r.ndigits != 0 && r.sign != var1->sign)
  {
    /* The absolute value of the quotient is too large */
    if (var1->sign == var2->sign)
    {
      sub_var(&q, &const_one, &q);
      add_var(&r, var2, &r);
    }
    else
    {
      add_var(&q, &const_one, &q);
      sub_var(&r, var2, &r);
    }
  }

  while (cmp_abs(&r, var2) >= 0)
  {
    /* The absolute value of the quotient is too small */
    if (var1->sign == var2->sign)
    {
      add_var(&q, &const_one, &q);
      sub_var(&r, var2, &r);
    }
    else
    {
      sub_var(&q, &const_one, &q);
      add_var(&r, var2, &r);
    }
  }

  set_var_from_var(&q, quot);
  set_var_from_var(&r, rem);

  free_var(&q);
  free_var(&r);
}


/*
 * ceil_var() -
 *
 *  Return the smallest integer greater than or equal to the argument
 *  on variable level
 */
static void
ceil_var(const NumericVar *var, NumericVar *result)
{
  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);
}


/*
 * floor_var() -
 *
 *  Return the largest integer equal to or less than the argument
 *  on variable level
 */
static void
floor_var(const NumericVar *var, NumericVar *result)
{
  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);
}


/*
 * gcd_var() -
 *
 *  Calculate the greatest common divisor of two numerics at variable level
 */
static void
gcd_var(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
{
  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);
}


/*
 * sqrt_var() -
 *
 *  Compute the square root of x using the Karatsuba Square Root algorithm.
 *  NOTE: we allow rscale < 0 here, implying rounding before the decimal
 *  point.
 */
static void
sqrt_var(const NumericVar *arg, NumericVar *result, int rscale)
{
  int     stat;
  int     res_weight;
  int     res_ndigits;
  int     src_ndigits;
  int     step;
  int     ndigits[32];
  int     blen;
  int64   arg_int64;
  int     src_idx;
  int64   s_int64;
  int64   r_int64;
  NumericVar  s_var;
  NumericVar  r_var;
  NumericVar  a0_var;
  NumericVar  a1_var;
  NumericVar  q_var;
  NumericVar  u_var;

  stat = cmp_var(arg, &const_zero);
  if (stat == 0)
  {
    zero_var(result);
    result->dscale = rscale;
    return;
  }

  /*
   * SQL2003 defines sqrt() in terms of power, so we need to emit the right
   * SQLSTATE error code if the operand is negative.
   */
  if (stat < 0)
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
         errmsg("cannot take square root of a negative number")));

  init_var(&s_var);
  init_var(&r_var);
  init_var(&a0_var);
  init_var(&a1_var);
  init_var(&q_var);
  init_var(&u_var);

  /*
   * The result weight is half the input weight, rounded towards minus
   * infinity --- res_weight = floor(arg->weight / 2).
   */
  if (arg->weight >= 0)
    res_weight = arg->weight / 2;
  else
    res_weight = -((-arg->weight - 1) / 2 + 1);

  /*
   * Number of NBASE digits to compute.  To ensure correct rounding, compute
   * at least 1 extra decimal digit.  We explicitly allow rscale to be
   * negative here, but must always compute at least 1 NBASE digit.  Thus
   * res_ndigits = res_weight + 1 + ceil((rscale + 1) / DEC_DIGITS) or 1.
   */
  if (rscale + 1 >= 0)
    res_ndigits = res_weight + 1 + (rscale + DEC_DIGITS) / DEC_DIGITS;
  else
    res_ndigits = res_weight + 1 - (-rscale - 1) / DEC_DIGITS;
  res_ndigits = Max(res_ndigits, 1);

  /*
   * Number of source NBASE digits logically required to produce a result
   * with this precision --- every digit before the decimal point, plus 2
   * for each result digit after the decimal point (or minus 2 for each
   * result digit we round before the decimal point).
   */
  src_ndigits = arg->weight + 1 + (res_ndigits - res_weight - 1) * 2;
  src_ndigits = Max(src_ndigits, 1);

  /* ----------
   * From this point on, we treat the input and the result as integers and
   * compute the integer square root and remainder using the Karatsuba
   * Square Root algorithm, which may be written recursively as follows:
   *
   *  SqrtRem(n = a3*b^3 + a2*b^2 + a1*b + a0):
   *    [ for some base b, and coefficients a0,a1,a2,a3 chosen so that
   *      0 <= a0,a1,a2 < b and a3 >= b/4 ]
   *    Let (s,r) = SqrtRem(a3*b + a2)
   *    Let (q,u) = DivRem(r*b + a1, 2*s)
   *    Let s = s*b + q
   *    Let r = u*b + a0 - q^2
   *    If r < 0 Then
   *      Let r = r + s
   *      Let s = s - 1
   *      Let r = r + s
   *    Return (s,r)
   *
   * See "Karatsuba Square Root", Paul Zimmermann, INRIA Research Report
   * RR-3805, November 1999.  At the time of writing this was available
   * on the net at <https://hal.inria.fr/inria-00072854>.
   *
   * The way to read the assumption "n = a3*b^3 + a2*b^2 + a1*b + a0" is
   * "choose a base b such that n requires at least four base-b digits to
   * express; then those digits are a3,a2,a1,a0, with a3 possibly larger
   * than b".  For optimal performance, b should have approximately a
   * quarter the number of digits in the input, so that the outer square
   * root computes roughly twice as many digits as the inner one.  For
   * simplicity, we choose b = NBASE^blen, an integer power of NBASE.
   *
   * We implement the algorithm iteratively rather than recursively, to
   * allow the working variables to be reused.  With this approach, each
   * digit of the input is read precisely once --- src_idx tracks the number
   * of input digits used so far.
   *
   * The array ndigits[] holds the number of NBASE digits of the input that
   * will have been used at the end of each iteration, which roughly doubles
   * each time.  Note that the array elements are stored in reverse order,
   * so if the final iteration requires src_ndigits = 37 input digits, the
   * array will contain [37,19,11,7,5,3], and we would start by computing
   * the square root of the 3 most significant NBASE digits.
   *
   * In each iteration, we choose blen to be the largest integer for which
   * the input number has a3 >= b/4, when written in the form above.  In
   * general, this means blen = src_ndigits / 4 (truncated), but if
   * src_ndigits is a multiple of 4, that might lead to the coefficient a3
   * being less than b/4 (if the first input digit is less than NBASE/4), in
   * which case we choose blen = src_ndigits / 4 - 1.  The number of digits
   * in the inner square root is then src_ndigits - 2*blen.  So, for
   * example, if we have src_ndigits = 26 initially, the array ndigits[]
   * will be either [26,14,8,4] or [26,14,8,6,4], depending on the size of
   * the first input digit.
   *
   * Additionally, we can put an upper bound on the number of steps required
   * as follows --- suppose that the number of source digits is an n-bit
   * number in the range [2^(n-1), 2^n-1], then blen will be in the range
   * [2^(n-3)-1, 2^(n-2)-1] and the number of digits in the inner square
   * root will be in the range [2^(n-2), 2^(n-1)+1].  In the next step, blen
   * will be in the range [2^(n-4)-1, 2^(n-3)] and the number of digits in
   * the next inner square root will be in the range [2^(n-3), 2^(n-2)+1].
   * This pattern repeats, and in the worst case the array ndigits[] will
   * contain [2^n-1, 2^(n-1)+1, 2^(n-2)+1, ... 9, 5, 3], and the computation
   * will require n steps.  Therefore, since all digit array sizes are
   * signed 32-bit integers, the number of steps required is guaranteed to
   * be less than 32.
   * ----------
   */
  step = 0;
  while ((ndigits[step] = src_ndigits) > 4)
  {
    /* Choose b so that a3 >= b/4, as described above */
    blen = src_ndigits / 4;
    if (blen * 4 == src_ndigits && arg->digits[0] < NBASE / 4)
      blen--;

    /* Number of digits in the next step (inner square root) */
    src_ndigits -= 2 * blen;
    step++;
  }

  /*
   * First iteration (innermost square root and remainder):
   *
   * Here src_ndigits <= 4, and the input fits in an int64.  Its square root
   * has at most 9 decimal digits, so estimate it using double precision
   * arithmetic, which will in fact almost certainly return the correct
   * result with no further correction required.
   */
  arg_int64 = arg->digits[0];
  for (src_idx = 1; src_idx < src_ndigits; src_idx++)
  {
    arg_int64 *= NBASE;
    if (src_idx < arg->ndigits)
      arg_int64 += arg->digits[src_idx];
  }

  s_int64 = (int64) sqrt((double) arg_int64);
  r_int64 = arg_int64 - s_int64 * s_int64;

  /*
   * Use Newton's method to correct the result, if necessary.
   *
   * This uses integer division with truncation to compute the truncated
   * integer square root by iterating using the formula x -> (x + n/x) / 2.
   * This is known to converge to isqrt(n), unless n+1 is a perfect square.
   * If n+1 is a perfect square, the sequence will oscillate between the two
   * values isqrt(n) and isqrt(n)+1, so we can be assured of convergence by
   * checking the remainder.
   */
  while (r_int64 < 0 || r_int64 > 2 * s_int64)
  {
    s_int64 = (s_int64 + arg_int64 / s_int64) / 2;
    r_int64 = arg_int64 - s_int64 * s_int64;
  }

  /*
   * Iterations with src_ndigits <= 8:
   *
   * The next 1 or 2 iterations compute larger (outer) square roots with
   * src_ndigits <= 8, so the result still fits in an int64 (even though the
   * input no longer does) and we can continue to compute using int64
   * variables to avoid more expensive numeric computations.
   *
   * It is fairly easy to see that there is no risk of the intermediate
   * values below overflowing 64-bit integers.  In the worst case, the
   * previous iteration will have computed a 3-digit square root (of a
   * 6-digit input less than NBASE^6 / 4), so at the start of this
   * iteration, s will be less than NBASE^3 / 2 = 10^12 / 2, and r will be
   * less than 10^12.  In this case, blen will be 1, so numer will be less
   * than 10^17, and denom will be less than 10^12 (and hence u will also be
   * less than 10^12).  Finally, since q^2 = u*b + a0 - r, we can also be
   * sure that q^2 < 10^17.  Therefore all these quantities fit comfortably
   * in 64-bit integers.
   */
  step--;
  while (step >= 0 && (src_ndigits = ndigits[step]) <= 8)
  {
    int     b;
    int     a0;
    int     a1;
    int     i;
    int64   numer;
    int64   denom;
    int64   q;
    int64   u;

    blen = (src_ndigits - src_idx) / 2;

    /* Extract a1 and a0, and compute b */
    a0 = 0;
    a1 = 0;
    b = 1;

    for (i = 0; i < blen; i++, src_idx++)
    {
      b *= NBASE;
      a1 *= NBASE;
      if (src_idx < arg->ndigits)
        a1 += arg->digits[src_idx];
    }

    for (i = 0; i < blen; i++, src_idx++)
    {
      a0 *= NBASE;
      if (src_idx < arg->ndigits)
        a0 += arg->digits[src_idx];
    }

    /* Compute (q,u) = DivRem(r*b + a1, 2*s) */
    numer = r_int64 * b + a1;
    denom = 2 * s_int64;
    q = numer / denom;
    u = numer - q * denom;

    /* Compute s = s*b + q and r = u*b + a0 - q^2 */
    s_int64 = s_int64 * b + q;
    r_int64 = u * b + a0 - q * q;

    if (r_int64 < 0)
    {
      /* s is too large by 1; set r += s, s--, r += s */
      r_int64 += s_int64;
      s_int64--;
      r_int64 += s_int64;
    }

    Assert(src_idx == src_ndigits); /* All input digits consumed */
    step--;
  }

  /*
   * On platforms with 128-bit integer support, we can further delay the
   * need to use numeric variables.
   */
#ifdef HAVE_INT128
  if (step >= 0)
  {
    int128    s_int128;
    int128    r_int128;

    s_int128 = s_int64;
    r_int128 = r_int64;

    /*
     * Iterations with src_ndigits <= 16:
     *
     * The result fits in an int128 (even though the input doesn't) so we
     * use int128 variables to avoid more expensive numeric computations.
     */
    while (step >= 0 && (src_ndigits = ndigits[step]) <= 16)
    {
      int64   b;
      int64   a0;
      int64   a1;
      int64   i;
      int128    numer;
      int128    denom;
      int128    q;
      int128    u;

      blen = (src_ndigits - src_idx) / 2;

      /* Extract a1 and a0, and compute b */
      a0 = 0;
      a1 = 0;
      b = 1;

      for (i = 0; i < blen; i++, src_idx++)
      {
        b *= NBASE;
        a1 *= NBASE;
        if (src_idx < arg->ndigits)
          a1 += arg->digits[src_idx];
      }

      for (i = 0; i < blen; i++, src_idx++)
      {
        a0 *= NBASE;
        if (src_idx < arg->ndigits)
          a0 += arg->digits[src_idx];
      }

      /* Compute (q,u) = DivRem(r*b + a1, 2*s) */
      numer = r_int128 * b + a1;
      denom = 2 * s_int128;
      q = numer / denom;
      u = numer - q * denom;

      /* Compute s = s*b + q and r = u*b + a0 - q^2 */
      s_int128 = s_int128 * b + q;
      r_int128 = u * b + a0 - q * q;

      if (r_int128 < 0)
      {
        /* s is too large by 1; set r += s, s--, r += s */
        r_int128 += s_int128;
        s_int128--;
        r_int128 += s_int128;
      }

      Assert(src_idx == src_ndigits); /* All input digits consumed */
      step--;
    }

    /*
     * All remaining iterations require numeric variables.  Convert the
     * integer values to NumericVar and continue.  Note that in the final
     * iteration we don't need the remainder, so we can save a few cycles
     * there by not fully computing it.
     */
    int128_to_numericvar(s_int128, &s_var);
    if (step >= 0)
      int128_to_numericvar(r_int128, &r_var);
  }
  else
  {
    int64_to_numericvar(s_int64, &s_var);
    /* step < 0, so we certainly don't need r */
  }
#else             /* !HAVE_INT128 */
  int64_to_numericvar(s_int64, &s_var);
  if (step >= 0)
    int64_to_numericvar(r_int64, &r_var);
#endif              /* HAVE_INT128 */

  /*
   * The remaining iterations with src_ndigits > 8 (or 16, if have int128)
   * use numeric variables.
   */
  while (step >= 0)
  {
    int     tmp_len;

    src_ndigits = ndigits[step];
    blen = (src_ndigits - src_idx) / 2;

    /* Extract a1 and a0 */
    if (src_idx < arg->ndigits)
    {
      tmp_len = Min(blen, arg->ndigits - src_idx);
      alloc_var(&a1_var, tmp_len);
      memcpy(a1_var.digits, arg->digits + src_idx,
           tmp_len * sizeof(NumericDigit));
      a1_var.weight = blen - 1;
      a1_var.sign = NUMERIC_POS;
      a1_var.dscale = 0;
      strip_var(&a1_var);
    }
    else
    {
      zero_var(&a1_var);
      a1_var.dscale = 0;
    }
    src_idx += blen;

    if (src_idx < arg->ndigits)
    {
      tmp_len = Min(blen, arg->ndigits - src_idx);
      alloc_var(&a0_var, tmp_len);
      memcpy(a0_var.digits, arg->digits + src_idx,
           tmp_len * sizeof(NumericDigit));
      a0_var.weight = blen - 1;
      a0_var.sign = NUMERIC_POS;
      a0_var.dscale = 0;
      strip_var(&a0_var);
    }
    else
    {
      zero_var(&a0_var);
      a0_var.dscale = 0;
    }
    src_idx += blen;

    /* Compute (q,u) = DivRem(r*b + a1, 2*s) */
    set_var_from_var(&r_var, &q_var);
    q_var.weight += blen;
    add_var(&q_var, &a1_var, &q_var);
    add_var(&s_var, &s_var, &u_var);
    div_mod_var(&q_var, &u_var, &q_var, &u_var);

    /* Compute s = s*b + q */
    s_var.weight += blen;
    add_var(&s_var, &q_var, &s_var);

    /*
     * Compute r = u*b + a0 - q^2.
     *
     * In the final iteration, we don't actually need r; we just need to
     * know whether it is negative, so that we know whether to adjust s.
     * So instead of the final subtraction we can just compare.
     */
    u_var.weight += blen;
    add_var(&u_var, &a0_var, &u_var);
    mul_var(&q_var, &q_var, &q_var, 0);

    if (step > 0)
    {
      /* Need r for later iterations */
      sub_var(&u_var, &q_var, &r_var);
      if (r_var.sign == NUMERIC_NEG)
      {
        /* s is too large by 1; set r += s, s--, r += s */
        add_var(&r_var, &s_var, &r_var);
        sub_var(&s_var, &const_one, &s_var);
        add_var(&r_var, &s_var, &r_var);
      }
    }
    else
    {
      /* Don't need r anymore, except to test if s is too large by 1 */
      if (cmp_var(&u_var, &q_var) < 0)
        sub_var(&s_var, &const_one, &s_var);
    }

    Assert(src_idx == src_ndigits); /* All input digits consumed */
    step--;
  }

  /*
   * Construct the final result, rounding it to the requested precision.
   */
  set_var_from_var(&s_var, result);
  result->weight = res_weight;
  result->sign = NUMERIC_POS;

  /* Round to target rscale (and set result->dscale) */
  round_var(result, rscale);

  /* Strip leading and trailing zeroes */
  strip_var(result);

  free_var(&s_var);
  free_var(&r_var);
  free_var(&a0_var);
  free_var(&a1_var);
  free_var(&q_var);
  free_var(&u_var);
}


/*
 * exp_var() -
 *
 *  Raise e to the power of x, computed to rscale fractional digits
 */
static void
exp_var(const NumericVar *arg, NumericVar *result, int rscale)
{
  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);
}


/*
 * Estimate the dweight of the most significant decimal digit of the natural
 * logarithm of a number.
 *
 * Essentially, we're approximating log10(abs(ln(var))).  This is used to
 * determine the appropriate rscale when computing natural logarithms.
 *
 * Note: many callers call this before range-checking the input.  Therefore,
 * we must be robust against values that are invalid to apply ln() to.
 * We don't wish to throw an error here, so just return zero in such cases.
 */
static int
estimate_ln_dweight(const NumericVar *var)
{
  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;
}


/*
 * ln_var() -
 *
 *  Compute the natural log of x
 */
static void
ln_var(const NumericVar *arg, NumericVar *result, int rscale)
{
  NumericVar  x;
  NumericVar  xx;
  int     ni;
  NumericVar  elem;
  NumericVar  fact;
  int     nsqrt;
  int     local_rscale;
  int     cmp;

  cmp = cmp_var(arg, &const_zero);
  if (cmp == 0)
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
         errmsg("cannot take logarithm of zero")));
  else if (cmp < 0)
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
         errmsg("cannot take logarithm of a negative number")));

  init_var(&x);
  init_var(&xx);
  init_var(&elem);
  init_var(&fact);

  set_var_from_var(arg, &x);
  set_var_from_var(&const_two, &fact);

  /*
   * Reduce input into range 0.9 < x < 1.1 with repeated sqrt() operations.
   *
   * The final logarithm will have up to around rscale+6 significant digits.
   * Each sqrt() will roughly halve the weight of x, so adjust the local
   * rscale as we work so that we keep this many significant digits at each
   * step (plus a few more for good measure).
   *
   * Note that we allow local_rscale < 0 during this input reduction
   * process, which implies rounding before the decimal point.  sqrt_var()
   * explicitly supports this, and it significantly reduces the work
   * required to reduce very large inputs to the required range.  Once the
   * input reduction is complete, x.weight will be 0 and its display scale
   * will be non-negative again.
   */
  nsqrt = 0;
  while (cmp_var(&x, &const_zero_point_nine) <= 0)
  {
    local_rscale = rscale - x.weight * DEC_DIGITS / 2 + 8;
    sqrt_var(&x, &x, local_rscale);
    mul_var(&fact, &const_two, &fact, 0);
    nsqrt++;
  }
  while (cmp_var(&x, &const_one_point_one) >= 0)
  {
    local_rscale = rscale - x.weight * DEC_DIGITS / 2 + 8;
    sqrt_var(&x, &x, local_rscale);
    mul_var(&fact, &const_two, &fact, 0);
    nsqrt++;
  }

  /*
   * We use the Taylor series for 0.5 * ln((1+z)/(1-z)),
   *
   * z + z^3/3 + z^5/5 + ...
   *
   * where z = (x-1)/(x+1) is in the range (approximately) -0.053 .. 0.048
   * due to the above range-reduction of x.
   *
   * The convergence of this is not as fast as one would like, but is
   * tolerable given that z is small.
   *
   * The Taylor series result will be multiplied by 2^(nsqrt+1), which has a
   * decimal weight of (nsqrt+1) * log10(2), so work with this many extra
   * digits of precision (plus a few more for good measure).
   */
  local_rscale = rscale + (int) ((nsqrt + 1) * 0.301029995663981) + 8;

  sub_var(&x, &const_one, result);
  add_var(&x, &const_one, &elem);
  div_var(result, &elem, result, local_rscale, true, false);
  set_var_from_var(result, &xx);
  mul_var(result, result, &x, local_rscale);

  ni = 1;

  for (;;)
  {
    ni += 2;
    mul_var(&xx, &x, &xx, local_rscale);
    div_var_int(&xx, ni, 0, &elem, local_rscale, true);

    if (elem.ndigits == 0)
      break;

    add_var(result, &elem, result);

    if (elem.weight < (result->weight - local_rscale * 2 / DEC_DIGITS))
      break;
  }

  /* Compensate for argument range reduction, round to requested rscale */
  mul_var(result, &fact, result, rscale);

  free_var(&x);
  free_var(&xx);
  free_var(&elem);
  free_var(&fact);
}


/*
 * log_var() -
 *
 *  Compute the logarithm of num in a given base.
 *
 *  Note: this routine chooses dscale of the result.
 */
static void
log_var(const NumericVar *base, const NumericVar *num, NumericVar *result)
{
  NumericVar  ln_base;
  NumericVar  ln_num;
  int     ln_base_dweight;
  int     ln_num_dweight;
  int     result_dweight;
  int     rscale;
  int     ln_base_rscale;
  int     ln_num_rscale;

  /*
   * ln_var will throw a suitable error for most invalid-input cases, but we
   * need a special case for base == 1, else we'd report "division by zero"
   * which is a bit confusing.
   */
  if (cmp_var(base, &const_one) == 0)
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_ARGUMENT_FOR_LOG),
         errmsg("cannot take logarithm using base one")));

  init_var(&ln_base);
  init_var(&ln_num);

  /* Estimated dweights of ln(base), ln(num) and the final result */
  ln_base_dweight = estimate_ln_dweight(base);
  ln_num_dweight = estimate_ln_dweight(num);
  result_dweight = ln_num_dweight - ln_base_dweight;

  /*
   * Select the scale of the result so that it will have at least
   * NUMERIC_MIN_SIG_DIGITS significant digits and is not less than either
   * input's display scale.
   */
  rscale = NUMERIC_MIN_SIG_DIGITS - result_dweight;
  rscale = Max(rscale, base->dscale);
  rscale = Max(rscale, num->dscale);
  rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
  rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);

  /*
   * Set the scales for ln(base) and ln(num) so that they each have more
   * significant digits than the final result.
   */
  ln_base_rscale = rscale + result_dweight - ln_base_dweight + 8;
  ln_base_rscale = Max(ln_base_rscale, NUMERIC_MIN_DISPLAY_SCALE);

  ln_num_rscale = rscale + result_dweight - ln_num_dweight + 8;
  ln_num_rscale = Max(ln_num_rscale, NUMERIC_MIN_DISPLAY_SCALE);

  /* Form natural logarithms */
  ln_var(base, &ln_base, ln_base_rscale);
  ln_var(num, &ln_num, ln_num_rscale);

  /* Divide and round to the required scale */
  div_var(&ln_num, &ln_base, result, rscale, true, false);

  free_var(&ln_num);
  free_var(&ln_base);
}


/*
 * power_var() -
 *
 *  Raise base to the power of exp
 *
 *  Note: this routine chooses dscale of the result.
 */
static void
power_var(const NumericVar *base, const NumericVar *exp, NumericVar *result)
{
  int     res_sign;
  NumericVar  abs_base;
  NumericVar  ln_base;
  NumericVar  ln_num;
  int     ln_dweight;
  int     rscale;
  int     sig_digits;
  int     local_rscale;
  double    val;

  /* If exp can be represented as an integer, use power_var_int */
  if (exp->ndigits == 0 || exp->ndigits <= exp->weight + 1)
  {
    /* exact integer, but does it fit in int? */
    int64   expval64;

    if (numericvar_to_int64(exp, &expval64))
    {
      if (expval64 >= PG_INT32_MIN && expval64 <= PG_INT32_MAX)
      {
        /* Okay, use power_var_int */
        power_var_int(base, (int) expval64, exp->dscale, result);
        return;
      }
    }
  }

  /*
   * This avoids log(0) for cases of 0 raised to a non-integer.  0 ^ 0 is
   * handled by power_var_int().
   */
  if (cmp_var(base, &const_zero) == 0)
  {
    set_var_from_var(&const_zero, result);
    result->dscale = NUMERIC_MIN_SIG_DIGITS; /* no need to round */
    return;
  }

  init_var(&abs_base);
  init_var(&ln_base);
  init_var(&ln_num);

  /*
   * If base is negative, insist that exp be an integer.  The result is then
   * positive if exp is even and negative if exp is odd.
   */
  if (base->sign == NUMERIC_NEG)
  {
    /*
     * Check that exp is an integer.  This error code is defined by the
     * SQL standard, and matches other errors in numeric_power().
     */
    if (exp->ndigits > 0 && exp->ndigits > exp->weight + 1)
      ereport(ERROR,
          (errcode(ERRCODE_INVALID_ARGUMENT_FOR_POWER_FUNCTION),
           errmsg("a negative number raised to a non-integer power yields a complex result")));

    /* Test if exp is odd or even */
    if (exp->ndigits > 0 && exp->ndigits == exp->weight + 1 &&
      (exp->digits[exp->ndigits - 1] & 1))
      res_sign = NUMERIC_NEG;
    else
      res_sign = NUMERIC_POS;

    /* Then work with abs(base) below */
    set_var_from_var(base, &abs_base);
    abs_base.sign = NUMERIC_POS;
    base = &abs_base;
  }
  else
    res_sign = NUMERIC_POS;

  /*----------
   * Decide on the scale for the ln() calculation.  For this we need an
   * estimate of the weight of the result, which we obtain by doing an
   * initial low-precision calculation of exp * ln(base).
   *
   * We want result = e ^ (exp * ln(base))
   * so result dweight = log10(result) = exp * ln(base) * log10(e)
   *
   * We also perform a crude overflow test here so that we can exit early if
   * the full-precision result is sure to overflow, and to guard against
   * integer overflow when determining the scale for the real calculation.
   * exp_var() supports inputs up to NUMERIC_MAX_RESULT_SCALE * 3, so the
   * result will overflow if exp * ln(base) >= NUMERIC_MAX_RESULT_SCALE * 3.
   * Since the values here are only approximations, we apply a small fuzz
   * factor to this overflow test and let exp_var() determine the exact
   * overflow threshold so that it is consistent for all inputs.
   *----------
   */
  ln_dweight = estimate_ln_dweight(base);

  /*
   * Set the scale for the low-precision calculation, computing ln(base) to
   * around 8 significant digits.  Note that ln_dweight may be as small as
   * -NUMERIC_DSCALE_MAX, so the scale may exceed NUMERIC_MAX_DISPLAY_SCALE
   * here.
   */
  local_rscale = 8 - ln_dweight;
  local_rscale = Max(local_rscale, NUMERIC_MIN_DISPLAY_SCALE);

  ln_var(base, &ln_base, local_rscale);

  mul_var(&ln_base, exp, &ln_num, local_rscale);

  val = numericvar_to_double_no_overflow(&ln_num);

  /* initial overflow/underflow test with fuzz factor */
  if (fabs(val) > NUMERIC_MAX_RESULT_SCALE * 3.01)
  {
    if (val > 0)
      ereport(ERROR,
          (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
           errmsg("value overflows numeric format")));
    zero_var(result);
    result->dscale = NUMERIC_MAX_DISPLAY_SCALE;
    return;
  }

  val *= 0.434294481903252; /* approximate decimal result weight */

  /* choose the result scale */
  rscale = NUMERIC_MIN_SIG_DIGITS - (int) val;
  rscale = Max(rscale, base->dscale);
  rscale = Max(rscale, exp->dscale);
  rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
  rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);

  /* significant digits required in the result */
  sig_digits = rscale + (int) val;
  sig_digits = Max(sig_digits, 0);

  /* set the scale for the real exp * ln(base) calculation */
  local_rscale = sig_digits - ln_dweight + 8;
  local_rscale = Max(local_rscale, NUMERIC_MIN_DISPLAY_SCALE);

  /* and do the real calculation */

  ln_var(base, &ln_base, local_rscale);

  mul_var(&ln_base, exp, &ln_num, local_rscale);

  exp_var(&ln_num, result, rscale);

  if (res_sign == NUMERIC_NEG && result->ndigits > 0)
    result->sign = NUMERIC_NEG;

  free_var(&ln_num);
  free_var(&ln_base);
  free_var(&abs_base);
}

/*
 * power_var_int() -
 *
 *  Raise base to the power of exp, where exp is an integer.
 *
 *  Note: this routine chooses dscale of the result.
 */
static void
power_var_int(const NumericVar *base, int exp, int exp_dscale,
        NumericVar *result)
{
  double    f;
  int     p;
  int     i;
  int     rscale;
  int     sig_digits;
  unsigned int mask;
  bool    neg;
  NumericVar  base_prod;
  int     local_rscale;

  /*
   * Choose the result scale.  For this we need an estimate of the decimal
   * weight of the result, which we obtain by approximating using double
   * precision arithmetic.
   *
   * We also perform crude overflow/underflow tests here so that we can exit
   * early if the result is sure to overflow/underflow, and to guard against
   * integer overflow when choosing the result scale.
   */
  if (base->ndigits != 0)
  {
    /*----------
     * Choose f (double) and p (int) such that base ~= f * 10^p.
     * Then log10(result) = log10(base^exp) ~= exp * (log10(f) + p).
     *----------
     */
    f = base->digits[0];
    p = base->weight * DEC_DIGITS;

    for (i = 1; i < base->ndigits && i * DEC_DIGITS < 16; i++)
    {
      f = f * NBASE + base->digits[i];
      p -= DEC_DIGITS;
    }

    f = exp * (log10(f) + p); /* approximate decimal result weight */
  }
  else
    f = 0;         /* result is 0 or 1 (weight 0), or error */

  /* overflow/underflow tests with fuzz factors */
  if (f > (NUMERIC_WEIGHT_MAX + 1) * DEC_DIGITS)
    ereport(ERROR,
        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
         errmsg("value overflows numeric format")));
  if (f + 1 < -NUMERIC_MAX_DISPLAY_SCALE)
  {
    zero_var(result);
    result->dscale = NUMERIC_MAX_DISPLAY_SCALE;
    return;
  }

  /*
   * Choose the result scale in the same way as power_var(), so it has at
   * least NUMERIC_MIN_SIG_DIGITS significant digits and is not less than
   * either input's display scale.
   */
  rscale = NUMERIC_MIN_SIG_DIGITS - (int) f;
  rscale = Max(rscale, base->dscale);
  rscale = Max(rscale, exp_dscale);
  rscale = Max(rscale, NUMERIC_MIN_DISPLAY_SCALE);
  rscale = Min(rscale, NUMERIC_MAX_DISPLAY_SCALE);

  /* Handle some common special cases, as well as corner cases */
  switch (exp)
  {
    case 0:

      /*
       * While 0 ^ 0 can be either 1 or indeterminate (error), we treat
       * it as 1 because most programming languages do this. SQL:2003
       * also requires a return value of 1.
       * https://en.wikipedia.org/wiki/Exponentiation#Zero_to_the_zero_power
       */
      set_var_from_var(&const_one, result);
      result->dscale = rscale;  /* no need to round */
      return;
    case 1:
      set_var_from_var(base, result);
      round_var(result, rscale);
      return;
    case -1:
      div_var(&const_one, base, result, rscale, true, true);
      return;
    case 2:
      mul_var(base, base, result, rscale);
      return;
    default:
      break;
  }

  /* Handle the special case where the base is zero */
  if (base->ndigits == 0)
  {
    if (exp < 0)
      ereport(ERROR,
          (errcode(ERRCODE_DIVISION_BY_ZERO),
           errmsg("division by zero")));
    zero_var(result);
    result->dscale = rscale;
    return;
  }

  /*
   * The general case repeatedly multiplies base according to the bit
   * pattern of exp.
   *
   * The local rscale used for each multiplication is varied to keep a fixed
   * number of significant digits, sufficient to give the required result
   * scale.
   */

  /*
   * Approximate number of significant digits in the result.  Note that the
   * underflow test above, together with the choice of rscale, ensures that
   * this approximation is necessarily > 0.
   */
  sig_digits = 1 + rscale + (int) f;

  /*
   * The multiplications to produce the result may introduce an error of up
   * to around log10(abs(exp)) digits, so work with this many extra digits
   * of precision (plus a few more for good measure).
   */
  sig_digits += (int) log(fabs((double) exp)) + 8;

  /*
   * Now we can proceed with the multiplications.
   */
  neg = (exp < 0);
  mask = pg_abs_s32(exp);

  init_var(&base_prod);
  set_var_from_var(base, &base_prod);

  if (mask & 1)
    set_var_from_var(base, result);
  else
    set_var_from_var(&const_one, result);

  while ((mask >>= 1) > 0)
  {
    /*
     * Do the multiplications using rscales large enough to hold the
     * results to the required number of significant digits, but don't
     * waste time by exceeding the scales of the numbers themselves.
     */
    local_rscale = sig_digits - 2 * base_prod.weight * DEC_DIGITS;
    local_rscale = Min(local_rscale, 2 * base_prod.dscale);
    local_rscale = Max(local_rscale, NUMERIC_MIN_DISPLAY_SCALE);

    mul_var(&base_prod, &base_prod, &base_prod, local_rscale);

    if (mask & 1)
    {
      local_rscale = sig_digits -
        (base_prod.weight + result->weight) * DEC_DIGITS;
      local_rscale = Min(local_rscale,
                 base_prod.dscale + result->dscale);
      local_rscale = Max(local_rscale, NUMERIC_MIN_DISPLAY_SCALE);

      mul_var(&base_prod, result, result, local_rscale);
    }

    /*
     * When abs(base) > 1, the number of digits to the left of the decimal
     * point in base_prod doubles at each iteration, so if exp is large we
     * could easily spend large amounts of time and memory space doing the
     * multiplications.  But once the weight exceeds what will fit in
     * int16, the final result is guaranteed to overflow (or underflow, if
     * exp < 0), so we can give up before wasting too many cycles.
     */
    if (base_prod.weight > NUMERIC_WEIGHT_MAX ||
      result->weight > NUMERIC_WEIGHT_MAX)
    {
      /* overflow, unless neg, in which case result should be 0 */
      if (!neg)
        ereport(ERROR,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value overflows numeric format")));
      zero_var(result);
      neg = false;
      break;
    }
  }

  free_var(&base_prod);

  /* Compensate for input sign, and round to requested rscale */
  if (neg)
    div_var(&const_one, result, result, rscale, true, false);
  else
    round_var(result, rscale);
}

/*
 * power_ten_int() -
 *
 *  Raise ten to the power of exp, where exp is an integer.  Note that unlike
 *  power_var_int(), this does no overflow/underflow checking or rounding.
 */
static void
power_ten_int(int exp, NumericVar *result)
{
  /* Construct the result directly, starting from 10^0 = 1 */
  set_var_from_var(&const_one, result);

  /* Scale needed to represent the result exactly */
  result->dscale = exp < 0 ? -exp : 0;

  /* Base-NBASE weight of result and remaining exponent */
  if (exp >= 0)
    result->weight = exp / DEC_DIGITS;
  else
    result->weight = (exp + 1) / DEC_DIGITS - 1;

  exp -= result->weight * DEC_DIGITS;

  /* Final adjustment of the result's single NBASE digit */
  while (exp-- > 0)
    result->digits[0] *= 10;
}

/*
 * random_var() - return a random value in the range [rmin, rmax].
 */
static void
random_var(pg_prng_state *state, const NumericVar *rmin,
       const NumericVar *rmax, NumericVar *result)
{
  int     rscale;
  NumericVar  rlen;
  int     res_ndigits;
  int     n;
  int     pow10;
  int     i;
  uint64    rlen64;
  int     rlen64_ndigits;

  rscale = Max(rmin->dscale, rmax->dscale);

  /* Compute rlen = rmax - rmin and check the range bounds */
  init_var(&rlen);
  sub_var(rmax, rmin, &rlen);

  if (rlen.sign == NUMERIC_NEG)
    ereport(ERROR,
        errcode(ERRCODE_INVALID_PARAMETER_VALUE),
        errmsg("lower bound must be less than or equal to upper bound"));

  /* Special case for an empty range */
  if (rlen.ndigits == 0)
  {
    set_var_from_var(rmin, result);
    result->dscale = rscale;
    free_var(&rlen);
    return;
  }

  /*
   * Otherwise, select a random value in the range [0, rlen = rmax - rmin],
   * and shift it to the required range by adding rmin.
   */

  /* Required result digits */
  res_ndigits = rlen.weight + 1 + (rscale + DEC_DIGITS - 1) / DEC_DIGITS;

  /*
   * To get the required rscale, the final result digit must be a multiple
   * of pow10 = 10^n, where n = (-rscale) mod DEC_DIGITS.
   */
  n = ((rscale + DEC_DIGITS - 1) / DEC_DIGITS) * DEC_DIGITS - rscale;
  pow10 = 1;
  for (i = 0; i < n; i++)
    pow10 *= 10;

  /*
   * To choose a random value uniformly from the range [0, rlen], we choose
   * from the slightly larger range [0, rlen2], where rlen2 is formed from
   * rlen by copying the first 4 NBASE digits, and setting all remaining
   * decimal digits to "9".
   *
   * Without loss of generality, we can ignore the weight of rlen2 and treat
   * it as a pure integer for the purposes of this discussion.  The process
   * above gives rlen2 + 1 = rlen64 * 10^N, for some integer N, where rlen64
   * is a 64-bit integer formed from the first 4 NBASE digits copied from
   * rlen.  Since this trivially factors into smaller pieces that fit in
   * 64-bit integers, the task of choosing a random value uniformly from the
   * rlen2 + 1 possible values in [0, rlen2] is much simpler.
   *
   * If the random value selected is too large, it is rejected, and we try
   * again until we get a result <= rlen, ensuring that the overall result
   * is uniform (no particular value is any more likely than any other).
   *
   * Since rlen64 holds 4 NBASE digits from rlen, it contains at least
   * DEC_DIGITS * 3 + 1 decimal digits (i.e., at least 13 decimal digits,
   * when DEC_DIGITS is 4). Therefore the probability of needing to reject
   * the value chosen and retry is less than 1e-13.
   */
  rlen64 = (uint64) rlen.digits[0];
  rlen64_ndigits = 1;
  while (rlen64_ndigits < res_ndigits && rlen64_ndigits < 4)
  {
    rlen64 *= NBASE;
    if (rlen64_ndigits < rlen.ndigits)
      rlen64 += rlen.digits[rlen64_ndigits];
    rlen64_ndigits++;
  }

  /* Loop until we get a result <= rlen */
  do
  {
    NumericDigit *res_digits;
    uint64    rand;
    int     whole_ndigits;

    alloc_var(result, res_ndigits);
    result->sign = NUMERIC_POS;
    result->weight = rlen.weight;
    result->dscale = rscale;
    res_digits = result->digits;

    /*
     * Set the first rlen64_ndigits using a random value in [0, rlen64].
     *
     * If this is the whole result, and rscale is not a multiple of
     * DEC_DIGITS (pow10 from above is not 1), then we need this to be a
     * multiple of pow10.
     */
    if (rlen64_ndigits == res_ndigits && pow10 != 1)
      rand = pg_prng_uint64_range(state, 0, rlen64 / pow10) * pow10;
    else
      rand = pg_prng_uint64_range(state, 0, rlen64);

    for (i = rlen64_ndigits - 1; i >= 0; i--)
    {
      res_digits[i] = (NumericDigit) (rand % NBASE);
      rand = rand / NBASE;
    }

    /*
     * Set the remaining digits to random values in range [0, NBASE),
     * noting that the last digit needs to be a multiple of pow10.
     */
    whole_ndigits = res_ndigits;
    if (pow10 != 1)
      whole_ndigits--;

    /* Set whole digits in groups of 4 for best performance */
    i = rlen64_ndigits;
    while (i < whole_ndigits - 3)
    {
      rand = pg_prng_uint64_range(state, 0,
                    (uint64) NBASE * NBASE * NBASE * NBASE - 1);
      res_digits[i++] = (NumericDigit) (rand % NBASE);
      rand = rand / NBASE;
      res_digits[i++] = (NumericDigit) (rand % NBASE);
      rand = rand / NBASE;
      res_digits[i++] = (NumericDigit) (rand % NBASE);
      rand = rand / NBASE;
      res_digits[i++] = (NumericDigit) rand;
    }

    /* Remaining whole digits */
    while (i < whole_ndigits)
    {
      rand = pg_prng_uint64_range(state, 0, NBASE - 1);
      res_digits[i++] = (NumericDigit) rand;
    }

    /* Final partial digit (multiple of pow10) */
    if (i < res_ndigits)
    {
      rand = pg_prng_uint64_range(state, 0, NBASE / pow10 - 1) * pow10;
      res_digits[i] = (NumericDigit) rand;
    }

    /* Remove leading/trailing zeroes */
    strip_var(result);

    /* If result > rlen, try again */

  } while (cmp_var(result, &rlen) > 0);

  /* Offset the result to the required range */
  add_var(result, rmin, result);

  free_var(&rlen);
}


/* ----------------------------------------------------------------------
 *
 * Following are the lowest level functions that operate unsigned
 * on the variable level
 *
 * ----------------------------------------------------------------------
 */


/* ----------
 * cmp_abs() -
 *
 *  Compare the absolute values of var1 and var2
 *  Returns:  -1 for ABS(var1) < ABS(var2)
 *        0  for ABS(var1) == ABS(var2)
 *        1  for ABS(var1) > ABS(var2)
 * ----------
 */
static int
cmp_abs(const NumericVar *var1, const NumericVar *var2)
{
  return cmp_abs_common(var1->digits, var1->ndigits, var1->weight,
              var2->digits, var2->ndigits, var2->weight);
}

/* ----------
 * cmp_abs_common() -
 *
 *  Main routine of cmp_abs(). This function can be used by both
 *  NumericVar and Numeric.
 * ----------
 */
static int
cmp_abs_common(const NumericDigit *var1digits, int var1ndigits, int var1weight,
         const NumericDigit *var2digits, int var2ndigits, int var2weight)
{
  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;
}


/*
 * add_abs() -
 *
 *  Add the absolute values of two variables into result.
 *  result might point to one of the operands without danger.
 */
static void
add_abs(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
{
  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);
}


/*
 * sub_abs()
 *
 *  Subtract the absolute value of var2 from the absolute value of var1
 *  and store in result. result might point to one of the operands
 *  without danger.
 *
 *  ABS(var1) MUST BE GREATER OR EQUAL ABS(var2) !!!
 */
static void
sub_abs(const NumericVar *var1, const NumericVar *var2, NumericVar *result)
{
  NumericDigit *res_buf;
  NumericDigit *res_digits;
  int     res_ndigits;
  int     res_weight;
  int     res_rscale,
        rscale1,
        rscale2;
  int     res_dscale;
  int     i,
        i1,
        i2;
  int     borrow = 0;

  /* copy these values into local vars for speed in inner loop */
  int     var1ndigits = var1->ndigits;
  int     var2ndigits = var2->ndigits;
  NumericDigit *var1digits = var1->digits;
  NumericDigit *var2digits = var2->digits;

  res_weight = var1->weight;

  res_dscale = Max(var1->dscale, var2->dscale);

  /* Note: here we are figuring rscale in base-NBASE digits */
  rscale1 = var1->ndigits - var1->weight - 1;
  rscale2 = var2->ndigits - var2->weight - 1;
  res_rscale = Max(rscale1, rscale2);

  res_ndigits = res_rscale + res_weight + 1;
  if (res_ndigits <= 0)
    res_ndigits = 1;

  res_buf = digitbuf_alloc(res_ndigits + 1);
  res_buf[0] = 0;       /* spare digit for later rounding */
  res_digits = res_buf + 1;

  i1 = res_rscale + var1->weight + 1;
  i2 = res_rscale + var2->weight + 1;
  for (i = res_ndigits - 1; i >= 0; i--)
  {
    i1--;
    i2--;
    if (i1 >= 0 && i1 < var1ndigits)
      borrow += var1digits[i1];
    if (i2 >= 0 && i2 < var2ndigits)
      borrow -= var2digits[i2];

    if (borrow < 0)
    {
      res_digits[i] = borrow + NBASE;
      borrow = -1;
    }
    else
    {
      res_digits[i] = borrow;
      borrow = 0;
    }
  }

  Assert(borrow == 0);    /* else caller gave us var1 < var2 */

  digitbuf_free(result->buf);
  result->ndigits = res_ndigits;
  result->buf = res_buf;
  result->digits = res_digits;
  result->weight = res_weight;
  result->dscale = res_dscale;

  /* Remove leading/trailing zeroes */
  strip_var(result);
}

/*
 * round_var
 *
 * Round the value of a variable to no more than rscale decimal digits
 * after the decimal point.  NOTE: we allow rscale < 0 here, implying
 * rounding before the decimal point.
 */
static void
round_var(NumericVar *var, int rscale)
{
  NumericDigit *digits = var->digits;
  int     di;
  int     ndigits;
  int     carry;

  var->dscale = rscale;

  /* decimal digits wanted */
  di = (var->weight + 1) * DEC_DIGITS + rscale;

  /*
   * If di = 0, the value loses all digits, but could round up to 1 if its
   * first extra digit is >= 5.  If di < 0 the result must be 0.
   */
  if (di < 0)
  {
    var->ndigits = 0;
    var->weight = 0;
    var->sign = NUMERIC_POS;
  }
  else
  {
    /* NBASE digits wanted */
    ndigits = (di + DEC_DIGITS - 1) / DEC_DIGITS;

    /* 0, or number of decimal digits to keep in last NBASE digit */
    di %= DEC_DIGITS;

    if (ndigits < var->ndigits ||
      (ndigits == var->ndigits && di > 0))
    {
      var->ndigits = ndigits;

#if DEC_DIGITS == 1
      /* di must be zero */
      carry = (digits[ndigits] >= HALF_NBASE) ? 1 : 0;
#else
      if (di == 0)
        carry = (digits[ndigits] >= HALF_NBASE) ? 1 : 0;
      else
      {
        /* Must round within last NBASE digit */
        int     extra,
              pow10;

#if DEC_DIGITS == 4
        pow10 = round_powers[di];
#elif DEC_DIGITS == 2
        pow10 = 10;
#else
#error unsupported NBASE
#endif
        extra = digits[--ndigits] % pow10;
        digits[ndigits] -= extra;
        carry = 0;
        if (extra >= pow10 / 2)
        {
          pow10 += digits[ndigits];
          if (pow10 >= NBASE)
          {
            pow10 -= NBASE;
            carry = 1;
          }
          digits[ndigits] = pow10;
        }
      }
#endif

      /* Propagate carry if needed */
      while (carry)
      {
        carry += digits[--ndigits];
        if (carry >= NBASE)
        {
          digits[ndigits] = carry - NBASE;
          carry = 1;
        }
        else
        {
          digits[ndigits] = carry;
          carry = 0;
        }
      }

      if (ndigits < 0)
      {
        Assert(ndigits == -1);  /* better not have added > 1 digit */
        Assert(var->digits > var->buf);
        var->digits--;
        var->ndigits++;
        var->weight++;
      }
    }
  }
}

/*
 * trunc_var
 *
 * Truncate (towards zero) the value of a variable at rscale decimal digits
 * after the decimal point.  NOTE: we allow rscale < 0 here, implying
 * truncation before the decimal point.
 */
static void
trunc_var(NumericVar *var, int rscale)
{
  int     di;
  int     ndigits;

  var->dscale = rscale;

  /* decimal digits wanted */
  di = (var->weight + 1) * DEC_DIGITS + rscale;

  /*
   * If di <= 0, the value loses all digits.
   */
  if (di <= 0)
  {
    var->ndigits = 0;
    var->weight = 0;
    var->sign = NUMERIC_POS;
  }
  else
  {
    /* NBASE digits wanted */
    ndigits = (di + DEC_DIGITS - 1) / DEC_DIGITS;

    if (ndigits <= var->ndigits)
    {
      var->ndigits = ndigits;

#if DEC_DIGITS == 1
      /* no within-digit stuff to worry about */
#else
      /* 0, or number of decimal digits to keep in last NBASE digit */
      di %= DEC_DIGITS;

      if (di > 0)
      {
        /* Must truncate within last NBASE digit */
        NumericDigit *digits = var->digits;
        int     extra,
              pow10;

#if DEC_DIGITS == 4
        pow10 = round_powers[di];
#elif DEC_DIGITS == 2
        pow10 = 10;
#else
#error unsupported NBASE
#endif
        extra = digits[--ndigits] % pow10;
        digits[ndigits] -= extra;
      }
#endif
    }
  }
}

/*
 * strip_var
 *
 * Strip any leading and trailing zeroes from a numeric variable
 */
static void
strip_var(NumericVar *var)
{
  NumericDigit *digits = var->digits;
  int     ndigits = var->ndigits;

  /* Strip leading zeroes */
  while (ndigits > 0 && *digits == 0)
  {
    digits++;
    var->weight--;
    ndigits--;
  }

  /* Strip trailing zeroes */
  while (ndigits > 0 && digits[ndigits - 1] == 0)
    ndigits--;

  /* If it's zero, normalize the sign and weight */
  if (ndigits == 0)
  {
    var->sign = NUMERIC_POS;
    var->weight = 0;
  }

  var->digits = digits;
  var->ndigits = ndigits;
}


/* ----------------------------------------------------------------------
 *
 * Fast sum accumulator functions
 *
 * ----------------------------------------------------------------------
 */

/*
 * Reset the accumulator's value to zero.  The buffers to hold the digits
 * are not free'd.
 */
static void
accum_sum_reset(NumericSumAccum *accum)
{
  int     i;

  accum->dscale = 0;
  for (i = 0; i < accum->ndigits; i++)
  {
    accum->pos_digits[i] = 0;
    accum->neg_digits[i] = 0;
  }
}

/*
 * Accumulate a new value.
 */
static void
accum_sum_add(NumericSumAccum *accum, const NumericVar *val)
{
  int32    *accum_digits;
  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;

  accum_digits += accum->weight - val->weight;
  for (int i = 0; i < val_ndigits; i++)
    accum_digits[i] += (int32) val_digits[i];

  accum->num_uncarried++;
}

/*
 * Propagate carries.
 */
static void
accum_sum_carry(NumericSumAccum *accum)
{
  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;
}

/*
 * Re-scale accumulator to accommodate new value.
 *
 * If the new value has more digits than the current digit buffers in the
 * accumulator, enlarge the buffers.
 */
static void
accum_sum_rescale(NumericSumAccum *accum, const NumericVar *val)
{
  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_array(int32, accum_ndigits);
    new_neg_digits = palloc0_array(int32, accum_ndigits);

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

/*
 * Return the current value of the accumulator.  This perform final carry
 * propagation, and adds together the positive and negative sums.
 *
 * Unlike all the other routines, the caller is not required to switch to
 * the memory context that holds the accumulator.
 */
static void
accum_sum_final(NumericSumAccum *accum, NumericVar *result)
{
  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);
}

/*
 * Copy an accumulator's state.
 *
 * 'dst' is assumed to be uninitialized beforehand.  No attempt is made at
 * freeing old values.
 */
static void
accum_sum_copy(NumericSumAccum *dst, NumericSumAccum *src)
{
  dst->pos_digits = palloc_array(int32, src->ndigits);
  dst->neg_digits = palloc_array(int32, src->ndigits);

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

/*
 * Add the current value of 'accum2' into 'accum'.
 */
static void
accum_sum_combine(NumericSumAccum *accum, NumericSumAccum *accum2)
{
  NumericVar  tmp_var;

  init_var(&tmp_var);

  accum_sum_final(accum2, &tmp_var);
  accum_sum_add(accum, &tmp_var);

  free_var(&tmp_var);
}

Coverage Report

Created: 2026-10-16 06:48