>> It would be good to know how much we can save on top by directly working
>> off of the packed representation as outlined above. On x86 that test is
>> simple to do because unaligned memory accesses are allowed. You would
>> just replace PG_DETOAST_DATUM() by PG_DETOAST_DATUM_PACKED() and adapt
>> the macros to work with a packed representation.
> 
> I can answer part of your question. This patch set is one of three parts of a
> numeric speed-up project I implemented a year ago for an ERP workload that is
> very heavy in numeric types, and I'm now trying to publish these ideas to the
> community.
> 
> 1. The first part is about unpacking the short numerics into a local buffer
> (this thread).
> 2. The second part uses numeric_eq() and numeric_ne() to derive the result
> directly from the stored bytes, with no unpacking at all.
> 3. Part 3 is a fast 128 bit accumulator for numeric aggregates (not ready for
> publishing yet).
> 
> I've attached a draft of part 2. It just handles = and <> without any 
> unpacking.
> Compared to master, it's typically ~30% faster with clang 19 and ~60% faster
> with gcc. So, I guess it is a practical limit for your feature too.

Could you run your changes against my benchmark script? Once only with
the scratch buffer change and then combined with also avoiding the
unpacking. You could do that exemplary just for a few operations. It
would be great to talk about concrete, reproducible numbers. On that
note: what architecture are you testing on?

(2) and (3) of your patches are only for a narrow subset of NUMERIC
functionality, are they? I would love to apply the "not unpacking"
change to all of numeric.c.

> It doesn't overlap with the idea you're referring to, but it has a similar
> issue: the code is quite specialized and complex. I'm not sure if an 
> open-source
> project would want to take on that challenge. Still, we can try to use common
> helpers to make it simpler and more broadly useful.

The "not unpacking" change is not complex and pretty repetitive but for
sure a lot of code churn.

>> I can send you my patch if you like.
> 
> Yes, please. I’d like to compare the two.

It's attached. I saw really good results on x86 but some regressions on
M5. That's why I started working on centralizing the case distinction
work scattered throughout all the macros in set_var_from_num() and have
all functions use that. This also makes the code a lot nicer. This
change isn't complete yet, so I cannot send it to you.

I'll share the results on my box with you tomorrow. Right now, I don't
have access to my benchmark machine.

-- 
David Geier
From 50a02c470c9222ea5ffe66904dc35578f11ae988 Mon Sep 17 00:00:00 2001
From: David Geier <[email protected]>
Date: Tue, 29 Sep 2026 11:37:40 +0200
Subject: [PATCH v1] Optimize NUMERIC by not unpacking 1-byte varlenas

---
 src/backend/utils/adt/numeric.c | 891 ++++++++++++++++----------------
 src/include/utils/numeric.h     |  11 +-
 2 files changed, 448 insertions(+), 454 deletions(-)

diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index 7deea2046f1..760b0def0bb 100644
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -106,61 +106,58 @@ typedef int16 NumericDigit;
 #define NBASE_SQR      (NBASE * NBASE)
 
 /*
- * The Numeric type as stored on disk.
+ * The Numeric type as stored on disk. Ignoring the preceding varlena header,
+ * the payload has one of the following layouts:
  *
- * 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.
+ * Short format:
  *
- * 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.
+ *     struct
+ *     {
+ *             uint16          sign_dscale_weight;
+ *             NumericDigit digits[];
+ *     };
  *
- * 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.
+ * Long format:
  *
- * 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
+ *     {
+ *             uint16          sign_dscale;
+ *             int16           weight;
+ *             NumericDigit digits[];
+ *     };
+ *
+ * Special values:
+ *
+ *     struct
+ *     {
+ *             uint16          sign;
+ *     };
+ *
+ * A Numeric may have either a four-byte or a packed one-byte varlena header.
+ * Consequently, its payload is not necessarily aligned, so the layouts above
+ * are illustrative only: no C structures are overlaid on the payload.  Header,
+ * weight, and digit fields must instead be accessed in a way that is safe for
+ * potentially unaligned storage.
+ *
+ * The high bits of the first word select the format. NUMERIC_SHORT selects
+ * the short format, in which the remaining 14 bits contain the sign, display
+ * scale, and weight.  NUMERIC_POS and NUMERIC_NEG select the long format, in
+ * which the remaining 14 bits contain the display scale and a separate int16
+ * stores the weight.  In practice, most commonly-encountered values can be
+ * represented in the short format.
+ *
+ * NUMERIC_SPECIAL identifies a NaN or Infinity. We currently store special
+ * values using only the two-byte header word, but previous releases used the
+ * long format, so we might find four-byte NaNs (though not infinities) on disk
+ * after pg_upgrade.  In either case, the low-order bits of a special value's
+ * header are reserved and must be zero.
+ *
+ * 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.
  */
@@ -171,7 +168,42 @@ struct NumericData
 #define NUMERIC_SHORT          0x8000
 #define NUMERIC_SPECIAL                0xC000
 
-#define NUMERIC_FLAGBITS(n) ((n)->choice.n_header & NUMERIC_SIGN_MASK)
+/*
+ * Access the Numeric header fields.  A Numeric may use either a four-byte or
+ * a packed one-byte varlena header, so use VARDATA_ANY() to locate the payload
+ * in both representations.  Keeping these accesses in helper functions also
+ * avoids exposing the details of the on-disk layout to callers.  The compiler
+ * can optimize the memcpy calls to native loads and stores where supported.
+ */
+static inline uint16
+numeric_header_word(Numeric num)
+{
+       uint16 h;
+       memcpy(&h, VARDATA_ANY(num), sizeof(h));
+       return h;
+}
+
+static inline int16
+numeric_long_weight(Numeric num)
+{
+       int16 w;
+       memcpy(&w, VARDATA_ANY(num) + sizeof(uint16), sizeof(w));
+       return w;
+}
+
+static inline void
+numeric_set_header_word(Numeric num, uint16 word)
+{
+       memcpy(VARDATA_ANY(num), &word, sizeof(word));
+}
+
+static inline void
+numeric_set_long_weight(Numeric num, int16 weight)
+{
+       memcpy(VARDATA_ANY(num) + sizeof(uint16), &weight, sizeof(weight));
+}
+
+#define NUMERIC_FLAGBITS(n) (numeric_header_word(n) & NUMERIC_SIGN_MASK)
 #define NUMERIC_IS_SHORT(n)            (NUMERIC_FLAGBITS(n) == NUMERIC_SHORT)
 #define NUMERIC_IS_SPECIAL(n)  (NUMERIC_FLAGBITS(n) == NUMERIC_SPECIAL)
 
@@ -183,9 +215,9 @@ struct NumericData
  * 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_IS_SHORT(n)     (((numeric_header_word(n) & 0x8000) != 
0))
 #define NUMERIC_HEADER_SIZE(n) \
-       (VARHDRSZ + sizeof(uint16) + \
+       (sizeof(uint16) + \
         (NUMERIC_HEADER_IS_SHORT(n) ? 0 : sizeof(int16)))
 
 /*
@@ -203,12 +235,12 @@ struct NumericData
 #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_EXT_FLAGBITS(n)        (numeric_header_word(n) & 
NUMERIC_EXT_SIGN_MASK)
+#define NUMERIC_IS_NAN(n)              (numeric_header_word(n) == NUMERIC_NAN)
+#define NUMERIC_IS_PINF(n)             (numeric_header_word(n) == NUMERIC_PINF)
+#define NUMERIC_IS_NINF(n)             (numeric_header_word(n) == NUMERIC_NINF)
 #define NUMERIC_IS_INF(n) \
-       (((n)->choice.n_header & ~NUMERIC_INF_SIGN_MASK) == NUMERIC_PINF)
+       (((numeric_header_word(n) & ~NUMERIC_INF_SIGN_MASK) == NUMERIC_PINF))
 
 /*
  * Short format definitions.
@@ -239,31 +271,31 @@ struct NumericData
 
 #define NUMERIC_SIGN(n) \
        (NUMERIC_IS_SHORT(n) ? \
-               (((n)->choice.n_short.n_header & NUMERIC_SHORT_SIGN_MASK) ? \
+               ((numeric_header_word(n) & 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 ? \
+#define NUMERIC_DSCALE(n)      (NUMERIC_HEADER_IS_SHORT(n) ? \
+       ((numeric_header_word(n) & NUMERIC_SHORT_DSCALE_MASK) \
+               >> NUMERIC_SHORT_DSCALE_SHIFT) \
+       : (numeric_header_word(n) & NUMERIC_DSCALE_MASK))
+
+#define NUMERIC_WEIGHT(n)      (NUMERIC_HEADER_IS_SHORT(n) ? \
+       (((numeric_header_word(n) & 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))
+        | (numeric_header_word(n) & NUMERIC_SHORT_WEIGHT_MASK))) \
+       : numeric_long_weight(n))
 
 /*
  * 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.
+ * weight field).  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.
+ * is the same, 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)
@@ -318,9 +350,24 @@ typedef struct NumericVar
        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 */
+       NumericDigit *digits;           /* base-NBASE digits (may be unaligned) 
*/
 } NumericVar;
 
+/*
+ * Read a digit from a NumericVar.  When the variable is initialized from a
+ * packed varlena, its digit array may be unaligned, so it must be read through
+ * memcpy rather than by direct dereference.  The compiler can optimize this
+ * to a native unaligned load where supported while retaining portability to
+ * strict-alignment architectures.  Writable NumericVar digit buffers are
+ * always aligned and can be written to by direct reference.
+ */
+static inline NumericDigit
+numeric_digit(const NumericVar *var, int i)
+{
+       NumericDigit digit;
+       memcpy(&digit, var->digits + i, sizeof(digit));
+       return digit;
+}
 
 /* ----------
  * Data for generate_series
@@ -485,10 +532,10 @@ static void dump_var(const char *str, NumericVar *var);
 
 #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_DIGITS(num) \
+       ((NumericDigit *) (VARDATA_ANY(num) + NUMERIC_HEADER_SIZE(num)))
 #define NUMERIC_NDIGITS(num) \
-       ((VARSIZE(num) - NUMERIC_HEADER_SIZE(num)) / sizeof(NumericDigit))
+       ((VARSIZE_ANY_EXHDR(num) - NUMERIC_HEADER_SIZE(num)) / 
sizeof(NumericDigit))
 #define NUMERIC_CAN_BE_SHORT(scale,weight) \
        ((scale) <= NUMERIC_SHORT_DSCALE_MAX && \
        (weight) <= NUMERIC_SHORT_WEIGHT_MAX && \
@@ -506,8 +553,8 @@ static bool set_var_from_non_decimal_integer_str(const char 
*str,
                                                                                
                 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_num(const Numeric num, NumericVar *dest);
+static void init_var_from_num(const 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);
@@ -539,10 +586,6 @@ static Datum numeric_abbrev_convert_var(const NumericVar 
*var,
 
 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,
@@ -585,10 +628,6 @@ 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,
@@ -798,7 +837,7 @@ invalid_syntax:
 Datum
 numeric_out(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        NumericVar      x;
        char       *str;
 
@@ -1145,7 +1184,7 @@ numeric_recv(PG_FUNCTION_ARGS)
 Datum
 numeric_send(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        NumericVar      x;
        StringInfoData buf;
        int                     i;
@@ -1159,7 +1198,7 @@ numeric_send(PG_FUNCTION_ARGS)
        pq_sendint16(&buf, x.sign);
        pq_sendint16(&buf, x.dscale);
        for (i = 0; i < x.ndigits; i++)
-               pq_sendint16(&buf, x.digits[i]);
+               pq_sendint16(&buf, numeric_digit(&x, i));
 
        PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
 }
@@ -1226,9 +1265,9 @@ numeric_support(PG_FUNCTION_ARGS)
  *     scale of the attribute have to be applied on the value.
  */
 Datum
-numeric                (PG_FUNCTION_ARGS)
+numeric        (PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        int32           typmod = PG_GETARG_INT32(1);
        Numeric         new;
        int                     precision;
@@ -1240,21 +1279,20 @@ numeric         (PG_FUNCTION_ARGS)
 
        /*
         * Handle NaN and infinities: if apply_typmod_special doesn't complain,
-        * just return a copy of the input.
+        * just return the input.
         */
        if (NUMERIC_IS_SPECIAL(num))
        {
                if (!apply_typmod_special(num, typmod, fcinfo->context))
                        PG_RETURN_NULL();
-               PG_RETURN_NUMERIC(duplicate_numeric(num));
+               PG_RETURN_NUMERIC(num);
        }
 
        /*
-        * If the value isn't a valid type modifier, simply return a copy of the
-        * input value
+        * If the value isn't a valid type modifier, simply return the input 
value.
         */
        if (!is_valid_numeric_typmod(typmod))
-               PG_RETURN_NUMERIC(duplicate_numeric(num));
+               PG_RETURN_NUMERIC(num);
 
        /*
         * Get the precision and scale out of the typmod value
@@ -1280,12 +1318,13 @@ numeric         (PG_FUNCTION_ARGS)
        {
                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);
+                       numeric_set_header_word(new,
+                                                                       
(numeric_header_word(num) & ~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);
+                       numeric_set_header_word(new,
+                                                                       
NUMERIC_SIGN(new) |
+                                                                       
((uint16) dscale & NUMERIC_DSCALE_MASK));
                PG_RETURN_NUMERIC(new);
        }
 
@@ -1383,25 +1422,20 @@ numerictypmodout(PG_FUNCTION_ARGS)
 Datum
 numeric_abs(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(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;
+               numeric_set_header_word(res, numeric_header_word(num) & 
~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;
+               numeric_set_header_word(res, numeric_header_word(num) & 
~NUMERIC_INF_SIGN_MASK);
        }
        else
-               res->choice.n_long.n_sign_dscale = NUMERIC_POS | 
NUMERIC_DSCALE(num);
+               numeric_set_header_word(res, NUMERIC_POS | NUMERIC_DSCALE(num));
 
        PG_RETURN_NUMERIC(res);
 }
@@ -1410,7 +1444,7 @@ numeric_abs(PG_FUNCTION_ARGS)
 Datum
 numeric_uminus(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        Numeric         res;
 
        /*
@@ -1422,9 +1456,7 @@ numeric_uminus(PG_FUNCTION_ARGS)
        {
                /* 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;
-       }
+                       numeric_set_header_word(res, numeric_header_word(num) ^ 
NUMERIC_INF_SIGN_MASK); }
 
        /*
         * The packed format is known to be totally zero digit trimmed always. 
So
@@ -1435,14 +1467,11 @@ numeric_uminus(PG_FUNCTION_ARGS)
        {
                /* 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;
+                       numeric_set_header_word(res, numeric_header_word(num) ^ 
NUMERIC_SHORT_SIGN_MASK);
                else if (NUMERIC_SIGN(num) == NUMERIC_POS)
-                       res->choice.n_long.n_sign_dscale =
-                               NUMERIC_NEG | NUMERIC_DSCALE(num);
+                       numeric_set_header_word(res, NUMERIC_NEG | 
NUMERIC_DSCALE(num));
                else
-                       res->choice.n_long.n_sign_dscale =
-                               NUMERIC_POS | NUMERIC_DSCALE(num);
+                       numeric_set_header_word(res, NUMERIC_POS | 
NUMERIC_DSCALE(num));
        }
 
        PG_RETURN_NUMERIC(res);
@@ -1452,9 +1481,9 @@ numeric_uminus(PG_FUNCTION_ARGS)
 Datum
 numeric_uplus(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
 
-       PG_RETURN_NUMERIC(duplicate_numeric(num));
+       PG_RETURN_NUMERIC(num);
 }
 
 
@@ -1500,7 +1529,7 @@ numeric_sign_internal(Numeric num)
 Datum
 numeric_sign(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
 
        /*
         * Handle NaN (infinities can be handled normally)
@@ -1533,7 +1562,7 @@ numeric_sign(PG_FUNCTION_ARGS)
 Datum
 numeric_round(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        int32           scale = PG_GETARG_INT32(1);
        Numeric         res;
        NumericVar      arg;
@@ -1542,7 +1571,7 @@ numeric_round(PG_FUNCTION_ARGS)
         * Handle NaN and infinities
         */
        if (NUMERIC_IS_SPECIAL(num))
-               PG_RETURN_NUMERIC(duplicate_numeric(num));
+               PG_RETURN_NUMERIC(num);
 
        /*
         * Limit the scale value to avoid possible overflow in calculations.
@@ -1587,7 +1616,7 @@ numeric_round(PG_FUNCTION_ARGS)
 Datum
 numeric_trunc(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        int32           scale = PG_GETARG_INT32(1);
        Numeric         res;
        NumericVar      arg;
@@ -1596,7 +1625,7 @@ numeric_trunc(PG_FUNCTION_ARGS)
         * Handle NaN and infinities
         */
        if (NUMERIC_IS_SPECIAL(num))
-               PG_RETURN_NUMERIC(duplicate_numeric(num));
+               PG_RETURN_NUMERIC(num);
 
        /*
         * Limit the scale value to avoid possible overflow in calculations.
@@ -1637,7 +1666,7 @@ numeric_trunc(PG_FUNCTION_ARGS)
 Datum
 numeric_ceil(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        Numeric         res;
        NumericVar      result;
 
@@ -1645,7 +1674,7 @@ numeric_ceil(PG_FUNCTION_ARGS)
         * Handle NaN and infinities
         */
        if (NUMERIC_IS_SPECIAL(num))
-               PG_RETURN_NUMERIC(duplicate_numeric(num));
+               PG_RETURN_NUMERIC(num);
 
        init_var_from_num(num, &result);
        ceil_var(&result, &result);
@@ -1665,7 +1694,7 @@ numeric_ceil(PG_FUNCTION_ARGS)
 Datum
 numeric_floor(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        Numeric         res;
        NumericVar      result;
 
@@ -1673,7 +1702,7 @@ numeric_floor(PG_FUNCTION_ARGS)
         * Handle NaN and infinities
         */
        if (NUMERIC_IS_SPECIAL(num))
-               PG_RETURN_NUMERIC(duplicate_numeric(num));
+               PG_RETURN_NUMERIC(num);
 
        init_var_from_num(num, &result);
        floor_var(&result, &result);
@@ -1705,8 +1734,8 @@ generate_series_step_numeric(PG_FUNCTION_ARGS)
 
        if (SRF_IS_FIRSTCALL())
        {
-               Numeric         start_num = PG_GETARG_NUMERIC(0);
-               Numeric         stop_num = PG_GETARG_NUMERIC(1);
+               Numeric         start_num = PG_GETARG_NUMERIC_PACKED(0);
+               Numeric         stop_num = PG_GETARG_NUMERIC_PACKED(1);
                NumericVar      steploc = const_one;
 
                /* Reject NaN and infinities in start and stop values */
@@ -1736,7 +1765,7 @@ generate_series_step_numeric(PG_FUNCTION_ARGS)
                /* see if we were given an explicit step size */
                if (PG_NARGS() == 3)
                {
-                       Numeric         step_num = PG_GETARG_NUMERIC(2);
+                       Numeric         step_num = PG_GETARG_NUMERIC_PACKED(2);
 
                        if (NUMERIC_IS_SPECIAL(step_num))
                        {
@@ -1957,9 +1986,9 @@ generate_series_numeric_support(PG_FUNCTION_ARGS)
 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);
+       Numeric         operand = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         bound1 = PG_GETARG_NUMERIC_PACKED(1);
+       Numeric         bound2 = PG_GETARG_NUMERIC_PACKED(2);
        int32           count = PG_GETARG_INT32(3);
        NumericVar      count_var;
        NumericVar      result_var;
@@ -2285,8 +2314,8 @@ numeric_abbrev_abort(int memtupcount, SortSupport ssup)
 static int
 numeric_fast_cmp(Datum x, Datum y, SortSupport ssup)
 {
-       Numeric         nx = DatumGetNumeric(x);
-       Numeric         ny = DatumGetNumeric(y);
+       Numeric         nx = DatumGetNumericPacked(x);
+       Numeric         ny = DatumGetNumericPacked(y);
        int                     result;
 
        result = cmp_numerics(nx, ny);
@@ -2385,16 +2414,16 @@ numeric_abbrev_convert_var(const NumericVar *var, 
NumericSortSupport *nss)
                switch (ndigits)
                {
                        default:
-                               result |= ((int64) var->digits[3]);
+                               result |= ((int64) numeric_digit(var, 3));
                                pg_fallthrough;
                        case 3:
-                               result |= ((int64) var->digits[2]) << 14;
+                               result |= ((int64) numeric_digit(var, 2)) << 14;
                                pg_fallthrough;
                        case 2:
-                               result |= ((int64) var->digits[1]) << 28;
+                               result |= ((int64) numeric_digit(var, 1)) << 28;
                                pg_fallthrough;
                        case 1:
-                               result |= ((int64) var->digits[0]) << 42;
+                               result |= ((int64) numeric_digit(var, 0)) << 42;
                                break;
                }
        }
@@ -2418,8 +2447,8 @@ numeric_abbrev_convert_var(const NumericVar *var, 
NumericSortSupport *nss)
 Datum
 numeric_cmp(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        int                     result;
 
        result = cmp_numerics(num1, num2);
@@ -2434,8 +2463,8 @@ numeric_cmp(PG_FUNCTION_ARGS)
 Datum
 numeric_eq(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        bool            result;
 
        result = cmp_numerics(num1, num2) == 0;
@@ -2449,8 +2478,8 @@ numeric_eq(PG_FUNCTION_ARGS)
 Datum
 numeric_ne(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        bool            result;
 
        result = cmp_numerics(num1, num2) != 0;
@@ -2464,8 +2493,8 @@ numeric_ne(PG_FUNCTION_ARGS)
 Datum
 numeric_gt(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        bool            result;
 
        result = cmp_numerics(num1, num2) > 0;
@@ -2479,8 +2508,8 @@ numeric_gt(PG_FUNCTION_ARGS)
 Datum
 numeric_ge(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        bool            result;
 
        result = cmp_numerics(num1, num2) >= 0;
@@ -2494,8 +2523,8 @@ numeric_ge(PG_FUNCTION_ARGS)
 Datum
 numeric_lt(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        bool            result;
 
        result = cmp_numerics(num1, num2) < 0;
@@ -2509,8 +2538,8 @@ numeric_lt(PG_FUNCTION_ARGS)
 Datum
 numeric_le(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        bool            result;
 
        result = cmp_numerics(num1, num2) <= 0;
@@ -2566,10 +2595,12 @@ cmp_numerics(Numeric num1, Numeric num2)
        }
        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));
+               NumericVar      var1;
+               NumericVar      var2;
+
+               init_var_from_num(num1, &var1);
+               init_var_from_num(num2, &var2);
+               result = cmp_var(&var1, &var2);
        }
 
        return result;
@@ -2581,9 +2612,9 @@ cmp_numerics(Numeric num1, Numeric num2)
 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);
+       Numeric         val = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         base = PG_GETARG_NUMERIC_PACKED(1);
+       Numeric         offset = PG_GETARG_NUMERIC_PACKED(2);
        bool            sub = PG_GETARG_BOOL(3);
        bool            less = PG_GETARG_BOOL(4);
        bool            result;
@@ -2716,7 +2747,7 @@ in_range_numeric_numeric(PG_FUNCTION_ARGS)
 Datum
 hash_numeric(PG_FUNCTION_ARGS)
 {
-       Numeric         key = PG_GETARG_NUMERIC(0);
+       Numeric         key = PG_GETARG_NUMERIC_PACKED(0);
        uint32          digit_hash;
        uint32          result;
        int                     weight;
@@ -2724,13 +2755,14 @@ hash_numeric(PG_FUNCTION_ARGS)
        int                     end_offset;
        int                     i;
        int                     hash_len;
-       NumericDigit *digits;
+       NumericVar      var;
 
        /* 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);
+       init_var_from_num(key, &var);
+       weight = var.weight;
        start_offset = 0;
        end_offset = 0;
 
@@ -2740,10 +2772,9 @@ hash_numeric(PG_FUNCTION_ARGS)
         * 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++)
+       for (i = 0; i < var.ndigits; i++)
        {
-               if (digits[i] != (NumericDigit) 0)
+               if (numeric_digit(&var, i) != (NumericDigit) 0)
                        break;
 
                start_offset++;
@@ -2759,19 +2790,19 @@ hash_numeric(PG_FUNCTION_ARGS)
         * 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)
+       if (var.ndigits == start_offset)
                PG_RETURN_UINT32(-1);
 
-       for (i = NUMERIC_NDIGITS(key) - 1; i >= 0; i--)
+       for (i = var.ndigits - 1; i >= 0; i--)
        {
-               if (digits[i] != (NumericDigit) 0)
+               if (numeric_digit(&var, 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));
+       Assert(start_offset + end_offset < var.ndigits);
 
        /*
         * Note that we don't hash on the Numeric's scale, since two numerics 
can
@@ -2779,9 +2810,8 @@ hash_numeric(PG_FUNCTION_ARGS)
         * 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 = var.ndigits - start_offset - end_offset;
+       digit_hash = hash_bytes((unsigned char *) (var.digits + start_offset),
                                                        hash_len * 
sizeof(NumericDigit));
 
        /* Mix in the weight, via XOR */
@@ -2797,7 +2827,7 @@ hash_numeric(PG_FUNCTION_ARGS)
 Datum
 hash_numeric_extended(PG_FUNCTION_ARGS)
 {
-       Numeric         key = PG_GETARG_NUMERIC(0);
+       Numeric         key = PG_GETARG_NUMERIC_PACKED(0);
        uint64          seed = PG_GETARG_INT64(1);
        uint64          digit_hash;
        uint64          result;
@@ -2806,20 +2836,20 @@ hash_numeric_extended(PG_FUNCTION_ARGS)
        int                     end_offset;
        int                     i;
        int                     hash_len;
-       NumericDigit *digits;
+       NumericVar      var;
 
        /* 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);
+       init_var_from_num(key, &var);
+       weight = var.weight;
        start_offset = 0;
        end_offset = 0;
 
-       digits = NUMERIC_DIGITS(key);
-       for (i = 0; i < NUMERIC_NDIGITS(key); i++)
+       for (i = 0; i < var.ndigits; i++)
        {
-               if (digits[i] != (NumericDigit) 0)
+               if (numeric_digit(&var, i) != (NumericDigit) 0)
                        break;
 
                start_offset++;
@@ -2827,22 +2857,21 @@ hash_numeric_extended(PG_FUNCTION_ARGS)
                weight--;
        }
 
-       if (NUMERIC_NDIGITS(key) == start_offset)
+       if (var.ndigits == start_offset)
                PG_RETURN_UINT64(seed - 1);
 
-       for (i = NUMERIC_NDIGITS(key) - 1; i >= 0; i--)
+       for (i = var.ndigits - 1; i >= 0; i--)
        {
-               if (digits[i] != (NumericDigit) 0)
+               if (numeric_digit(&var, i) != (NumericDigit) 0)
                        break;
 
                end_offset++;
        }
 
-       Assert(start_offset + end_offset < NUMERIC_NDIGITS(key));
+       Assert(start_offset + end_offset < var.ndigits);
 
-       hash_len = NUMERIC_NDIGITS(key) - start_offset - end_offset;
-       digit_hash = hash_bytes_extended((unsigned char *) (NUMERIC_DIGITS(key)
-                                                                               
                                + start_offset),
+       hash_len = var.ndigits - start_offset - end_offset;
+       digit_hash = hash_any_extended((unsigned char *) (var.digits + 
start_offset),
                                                                         
hash_len * sizeof(NumericDigit),
                                                                         seed);
 
@@ -2868,8 +2897,8 @@ hash_numeric_extended(PG_FUNCTION_ARGS)
 Datum
 numeric_add(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        Numeric         res;
 
        res = numeric_add_safe(num1, num2, NULL);
@@ -2943,8 +2972,8 @@ numeric_add_safe(Numeric num1, Numeric num2, Node 
*escontext)
 Datum
 numeric_sub(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        Numeric         res;
 
        res = numeric_sub_safe(num1, num2, NULL);
@@ -3019,8 +3048,8 @@ numeric_sub_safe(Numeric num1, Numeric num2, Node 
*escontext)
 Datum
 numeric_mul(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        Numeric         res;
 
        res = numeric_mul_safe(num1, num2, fcinfo->context);
@@ -3141,8 +3170,8 @@ numeric_mul_safe(Numeric num1, Numeric num2, Node 
*escontext)
 Datum
 numeric_div(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        Numeric         res;
 
        res = numeric_div_safe(num1, num2, NULL);
@@ -3226,7 +3255,7 @@ numeric_div_safe(Numeric num1, Numeric num2, Node 
*escontext)
        rscale = select_div_scale(&arg1, &arg2);
 
        /* Check for division by zero */
-       if (arg2.ndigits == 0 || arg2.digits[0] == 0)
+       if (arg2.ndigits == 0 || numeric_digit(&arg2, 0) == 0)
                goto division_by_zero;
 
        /*
@@ -3255,8 +3284,8 @@ division_by_zero:
 Datum
 numeric_div_trunc(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        NumericVar      arg1;
        NumericVar      arg2;
        NumericVar      result;
@@ -3344,8 +3373,8 @@ numeric_div_trunc(PG_FUNCTION_ARGS)
 Datum
 numeric_mod(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        Numeric         res;
 
        res = numeric_mod_safe(num1, num2, NULL);
@@ -3385,7 +3414,7 @@ numeric_mod_safe(Numeric num1, Numeric num2, Node 
*escontext)
                        return make_result(&const_nan);
                }
                /* num2 must be [-]Inf; result is num1 regardless of sign of 
num2 */
-               return duplicate_numeric(num1);
+               return num1;
        }
 
        init_var_from_num(num1, &arg1);
@@ -3394,7 +3423,7 @@ numeric_mod_safe(Numeric num1, Numeric num2, Node 
*escontext)
        init_var(&result);
 
        /* Check for division by zero */
-       if (arg2.ndigits == 0 || arg2.digits[0] == 0)
+       if (arg2.ndigits == 0 || numeric_digit(&arg2, 0) == 0)
                goto division_by_zero;
 
        mod_var(&arg1, &arg2, &result);
@@ -3420,7 +3449,7 @@ division_by_zero:
 Datum
 numeric_inc(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        NumericVar      arg;
        Numeric         res;
 
@@ -3428,7 +3457,7 @@ numeric_inc(PG_FUNCTION_ARGS)
         * Handle NaN and infinities
         */
        if (NUMERIC_IS_SPECIAL(num))
-               PG_RETURN_NUMERIC(duplicate_numeric(num));
+               PG_RETURN_NUMERIC(num);
 
        /*
         * Compute the result and return it
@@ -3453,8 +3482,8 @@ numeric_inc(PG_FUNCTION_ARGS)
 Datum
 numeric_smaller(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
 
        /*
         * Use cmp_numerics so that this will agree with the comparison 
operators,
@@ -3475,8 +3504,8 @@ numeric_smaller(PG_FUNCTION_ARGS)
 Datum
 numeric_larger(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
 
        /*
         * Use cmp_numerics so that this will agree with the comparison 
operators,
@@ -3504,8 +3533,8 @@ numeric_larger(PG_FUNCTION_ARGS)
 Datum
 numeric_gcd(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        NumericVar      arg1;
        NumericVar      arg2;
        NumericVar      result;
@@ -3547,8 +3576,8 @@ numeric_gcd(PG_FUNCTION_ARGS)
 Datum
 numeric_lcm(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        NumericVar      arg1;
        NumericVar      arg2;
        NumericVar      result;
@@ -3659,7 +3688,7 @@ numeric_fac(PG_FUNCTION_ARGS)
 Datum
 numeric_sqrt(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        Numeric         res;
        NumericVar      arg;
        NumericVar      result;
@@ -3676,8 +3705,8 @@ numeric_sqrt(PG_FUNCTION_ARGS)
                        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));
+               /* For NAN or PINF, just return the input */
+               PG_RETURN_NUMERIC(num);
        }
 
        /*
@@ -3731,7 +3760,7 @@ numeric_sqrt(PG_FUNCTION_ARGS)
 Datum
 numeric_exp(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        Numeric         res;
        NumericVar      arg;
        NumericVar      result;
@@ -3746,8 +3775,8 @@ numeric_exp(PG_FUNCTION_ARGS)
                /* 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));
+               /* For NAN or PINF, just return the input */
+               PG_RETURN_NUMERIC(num);
        }
 
        /*
@@ -3798,7 +3827,7 @@ numeric_exp(PG_FUNCTION_ARGS)
 Datum
 numeric_ln(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        Numeric         res;
        NumericVar      arg;
        NumericVar      result;
@@ -3814,8 +3843,8 @@ numeric_ln(PG_FUNCTION_ARGS)
                        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));
+               /* For NAN or PINF, just return the input */
+               PG_RETURN_NUMERIC(num);
        }
 
        init_var_from_num(num, &arg);
@@ -3847,8 +3876,8 @@ numeric_ln(PG_FUNCTION_ARGS)
 Datum
 numeric_log(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        Numeric         res;
        NumericVar      arg1;
        NumericVar      arg2;
@@ -3928,8 +3957,8 @@ numeric_log(PG_FUNCTION_ARGS)
 Datum
 numeric_power(PG_FUNCTION_ARGS)
 {
-       Numeric         num1 = PG_GETARG_NUMERIC(0);
-       Numeric         num2 = PG_GETARG_NUMERIC(1);
+       Numeric         num1 = PG_GETARG_NUMERIC_PACKED(0);
+       Numeric         num2 = PG_GETARG_NUMERIC_PACKED(1);
        Numeric         res;
        NumericVar      arg1;
        NumericVar      arg2;
@@ -4066,7 +4095,7 @@ numeric_power(PG_FUNCTION_ARGS)
                 */
                init_var_from_num(num2, &arg2);
                if (arg2.ndigits > 0 && arg2.ndigits == arg2.weight + 1 &&
-                       (arg2.digits[arg2.ndigits - 1] & 1))
+                       (numeric_digit(&arg2, arg2.ndigits - 1) & 1))
                        PG_RETURN_NUMERIC(make_result(&const_ninf));
                else
                        PG_RETURN_NUMERIC(make_result(&const_pinf));
@@ -4115,7 +4144,7 @@ numeric_power(PG_FUNCTION_ARGS)
 Datum
 numeric_scale(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
 
        if (NUMERIC_IS_SPECIAL(num))
                PG_RETURN_NULL();
@@ -4138,8 +4167,7 @@ get_min_scale(NumericVar *var)
         * 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)
+       while (last_digit_pos >= 0 && numeric_digit(var, last_digit_pos) == 0)
                last_digit_pos--;
 
        if (last_digit_pos >= 0)
@@ -4157,7 +4185,7 @@ get_min_scale(NumericVar *var)
                         * Reduce min_scale if trailing digit(s) in last 
NumericDigit are
                         * zero.
                         */
-                       NumericDigit last_digit = var->digits[last_digit_pos];
+                       NumericDigit last_digit = numeric_digit(var, 
last_digit_pos);
 
                        while (last_digit % 10 == 0)
                        {
@@ -4180,7 +4208,7 @@ get_min_scale(NumericVar *var)
 Datum
 numeric_min_scale(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        NumericVar      arg;
        int                     min_scale;
 
@@ -4200,12 +4228,12 @@ numeric_min_scale(PG_FUNCTION_ARGS)
 Datum
 numeric_trim_scale(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        Numeric         res;
        NumericVar      result;
 
        if (NUMERIC_IS_SPECIAL(num))
-               PG_RETURN_NUMERIC(duplicate_numeric(num));
+               PG_RETURN_NUMERIC(num);
 
        init_var_from_num(num, &result);
        result.dscale = get_min_scale(&result);
@@ -4410,7 +4438,7 @@ numeric_int4_safe(Numeric num, Node *escontext)
 Datum
 numeric_int4(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        int32           result;
 
        result = numeric_int4_safe(num, fcinfo->context);
@@ -4486,7 +4514,7 @@ numeric_int8_safe(Numeric num, Node *escontext)
 Datum
 numeric_int8(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        int64           result;
 
        result = numeric_int8_safe(num, fcinfo->context);
@@ -4510,7 +4538,7 @@ int2_numeric(PG_FUNCTION_ARGS)
 Datum
 numeric_int2(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        NumericVar      x;
        int64           val;
        int16           result;
@@ -4586,7 +4614,7 @@ float8_numeric(PG_FUNCTION_ARGS)
 Datum
 numeric_float8(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        char       *tmp;
        Datum           result;
 
@@ -4623,7 +4651,7 @@ numeric_float8(PG_FUNCTION_ARGS)
 Datum
 numeric_float8_no_overflow(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        double          val;
 
        if (NUMERIC_IS_SPECIAL(num))
@@ -4685,7 +4713,7 @@ float4_numeric(PG_FUNCTION_ARGS)
 Datum
 numeric_float4(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        char       *tmp;
        Datum           result;
 
@@ -4720,7 +4748,7 @@ numeric_float4(PG_FUNCTION_ARGS)
 Datum
 numeric_pg_lsn(PG_FUNCTION_ARGS)
 {
-       Numeric         num = PG_GETARG_NUMERIC(0);
+       Numeric         num = PG_GETARG_NUMERIC_PACKED(0);
        NumericVar      x;
        XLogRecPtr      result;
 
@@ -4999,7 +5027,7 @@ numeric_accum(PG_FUNCTION_ARGS)
                state = makeNumericAggState(fcinfo, true);
 
        if (!PG_ARGISNULL(1))
-               do_numeric_accum(state, PG_GETARG_NUMERIC(1));
+               do_numeric_accum(state, PG_GETARG_NUMERIC_PACKED(1));
 
        PG_RETURN_POINTER(state);
 }
@@ -5099,7 +5127,7 @@ numeric_avg_accum(PG_FUNCTION_ARGS)
                state = makeNumericAggState(fcinfo, false);
 
        if (!PG_ARGISNULL(1))
-               do_numeric_accum(state, PG_GETARG_NUMERIC(1));
+               do_numeric_accum(state, PG_GETARG_NUMERIC_PACKED(1));
 
        PG_RETURN_POINTER(state);
 }
@@ -5428,7 +5456,7 @@ numeric_accum_inv(PG_FUNCTION_ARGS)
        if (!PG_ARGISNULL(1))
        {
                /* If we fail to perform the inverse transition, return NULL */
-               if (!do_numeric_discard(state, PG_GETARG_NUMERIC(1)))
+               if (!do_numeric_discard(state, PG_GETARG_NUMERIC_PACKED(1)))
                        PG_RETURN_NULL();
        }
 
@@ -6428,7 +6456,13 @@ int8_sum(PG_FUNCTION_ARGS)
                PG_RETURN_NUMERIC(int64_to_numeric(PG_GETARG_INT64(1)));
        }
 
-       oldsum = PG_GETARG_NUMERIC(0);
+       /*
+        * 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_PACKED(0);
 
        /* Leave sum unchanged if new input is null. */
        if (PG_ARGISNULL(1))
@@ -6680,15 +6714,13 @@ int2int4_sum(PG_FUNCTION_ARGS)
 static void
 dump_numeric(const char *str, Numeric num)
 {
-       NumericDigit *digits = NUMERIC_DIGITS(num);
-       int                     ndigits;
-       int                     i;
+       NumericVar      var;
+       int             i;
 
-       ndigits = NUMERIC_NDIGITS(num);
+       init_var_from_num(num, &var);
 
-       printf("%s: NUMERIC w=%d d=%d ", str,
-                  NUMERIC_WEIGHT(num), NUMERIC_DSCALE(num));
-       switch (NUMERIC_SIGN(num))
+       printf("%s: NUMERIC w=%d d=%d ", str, var.weight, var.dscale);
+       switch (var.sign)
        {
                case NUMERIC_POS:
                        printf("POS");
@@ -6706,12 +6738,12 @@ dump_numeric(const char *str, Numeric num)
                        printf("-Infinity");
                        break;
                default:
-                       printf("SIGN=0x%x", NUMERIC_SIGN(num));
+                       printf("SIGN=0x%x", var.sign);
                        break;
        }
 
-       for (i = 0; i < ndigits; i++)
-               printf(" %0*d", DEC_DIGITS, digits[i]);
+       for (i = 0; i < var.ndigits; i++)
+               printf(" %0*d", DEC_DIGITS, numeric_digit(&var, i));
        printf("\n");
 }
 
@@ -6748,7 +6780,7 @@ dump_var(const char *str, NumericVar *var)
        }
 
        for (i = 0; i < var->ndigits; i++)
-               printf(" %0*d", DEC_DIGITS, var->digits[i]);
+               printf(" %0*d", DEC_DIGITS, numeric_digit(var, i));
 
        printf("\n");
 }
@@ -7240,7 +7272,7 @@ invalid_syntax:
  *     Convert the packed db format into a variable
  */
 static void
-set_var_from_num(Numeric num, NumericVar *dest)
+set_var_from_num(const Numeric num, NumericVar *dest)
 {
        int                     ndigits;
 
@@ -7270,8 +7302,8 @@ set_var_from_num(Numeric num, NumericVar *dest)
  *     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)
+static inline void
+init_var_from_num(const Numeric num, NumericVar *dest)
 {
        dest->ndigits = NUMERIC_NDIGITS(num);
        dest->weight = NUMERIC_WEIGHT(num);
@@ -7363,7 +7395,7 @@ get_str_from_var(const NumericVar *var)
        {
                for (d = 0; d <= var->weight; d++)
                {
-                       dig = (d < var->ndigits) ? var->digits[d] : 0;
+                       dig = (d < var->ndigits) ? numeric_digit(var, d) : 0;
                        /* In the first digit, suppress extra leading decimal 
zeroes */
 #if DEC_DIGITS == 4
                        {
@@ -7411,7 +7443,7 @@ get_str_from_var(const NumericVar *var)
                endcp = cp + dscale;
                for (i = 0; i < dscale; d++, i += DEC_DIGITS)
                {
-                       dig = (d >= 0 && d < var->ndigits) ? var->digits[d] : 0;
+                       dig = (d >= 0 && d < var->ndigits) ? numeric_digit(var, 
d) : 0;
 #if DEC_DIGITS == 4
                        d1 = dig / 1000;
                        dig -= d1 * 1000;
@@ -7492,7 +7524,7 @@ get_str_from_var_sci(const NumericVar *var, int rscale)
                 * Compensate for leading decimal zeroes in the first numeric 
digit by
                 * decrementing the exponent.
                 */
-               exponent -= DEC_DIGITS - (int) log10(var->digits[0]);
+               exponent -= DEC_DIGITS - (int) log10(numeric_digit(var, 0));
        }
        else
        {
@@ -7553,7 +7585,7 @@ numericvar_serialize(StringInfo buf, const NumericVar 
*var)
        pq_sendint32(buf, var->sign);
        pq_sendint32(buf, var->dscale);
        for (i = 0; i < var->ndigits; i++)
-               pq_sendint16(buf, var->digits[i]);
+               pq_sendint16(buf, numeric_digit(var, i));
 }
 
 /*
@@ -7578,17 +7610,21 @@ numericvar_deserialize(StringInfo buf, NumericVar *var)
 
 
 /*
- * duplicate_numeric() - copy a packed-format Numeric
+ * duplicate_numeric() - make a private copy of a Numeric.
  *
- * This will handle NaN and Infinity cases.
+ * The copy preserves the source's varlena header format (1-byte or 4-byte).
+ * This is used when we need to modify a value in place, e.g. for sign or
+ * display scale changes.
  */
 static Numeric
 duplicate_numeric(Numeric num)
 {
        Numeric         res;
+       Size            len = VARSIZE_ANY(num);
+
+       res = (Numeric) palloc(len);
+       memcpy(res, num, len);
 
-       res = (Numeric) palloc(VARSIZE(num));
-       memcpy(res, num, VARSIZE(num));
        return res;
 }
 
@@ -7602,11 +7638,11 @@ 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;
+       int                     i = 0;
 
        if ((sign & NUMERIC_SIGN_MASK) == NUMERIC_SPECIAL)
        {
@@ -7623,7 +7659,7 @@ make_result_safe(const NumericVar *var, Node *escontext)
                result = (Numeric) palloc(NUMERIC_HDRSZ_SHORT);
 
                SET_VARSIZE(result, NUMERIC_HDRSZ_SHORT);
-               result->choice.n_header = sign;
+               numeric_set_header_word(result, sign);
                /* the header word is all we need */
 
                dump_numeric("make_result()", result);
@@ -7633,14 +7669,14 @@ make_result_safe(const NumericVar *var, Node *escontext)
        n = var->ndigits;
 
        /* truncate leading zeroes */
-       while (n > 0 && *digits == 0)
+       while (n > 0 && numeric_digit(var, i) == 0)
        {
-               digits++;
+               i++;
                weight--;
                n--;
        }
        /* truncate trailing zeroes */
-       while (n > 0 && digits[n - 1] == 0)
+       while (n > 0 && numeric_digit(var, i + n - 1) == 0)
                n--;
 
        /* If zero result, force to weight=0 and positive sign */
@@ -7656,26 +7692,25 @@ make_result_safe(const NumericVar *var, Node *escontext)
                len = NUMERIC_HDRSZ_SHORT + n * sizeof(NumericDigit);
                result = (Numeric) palloc(len);
                SET_VARSIZE(result, len);
-               result->choice.n_short.n_header =
+               numeric_set_header_word(result,
                        (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);
+                       | (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;
+               numeric_set_header_word(result, sign | (var->dscale & 
NUMERIC_DSCALE_MASK));
+               numeric_set_long_weight(result, weight);
        }
 
        Assert(NUMERIC_NDIGITS(result) == n);
        if (n > 0)
-               memcpy(NUMERIC_DIGITS(result), digits, n * 
sizeof(NumericDigit));
+               memcpy(NUMERIC_DIGITS(result), var->digits + i, n * 
sizeof(NumericDigit));
 
        /* Check for overflow of int16 fields */
        if (NUMERIC_WEIGHT(result) != weight ||
@@ -7747,7 +7782,7 @@ apply_typmod(NumericVar *var, int32 typmod, Node 
*escontext)
                /* Determine true weight; and check for all-zero result */
                for (i = 0; i < var->ndigits; i++)
                {
-                       NumericDigit dig = var->digits[i];
+                       NumericDigit dig = numeric_digit(var, i);
 
                        if (dig)
                        {
@@ -7835,7 +7870,6 @@ apply_typmod_special(Numeric num, int32 typmod, Node 
*escontext)
 static bool
 numericvar_to_int64(const NumericVar *var, int64 *result)
 {
-       NumericDigit *digits;
        int                     ndigits;
        int                     weight;
        int                     i;
@@ -7870,9 +7904,8 @@ numericvar_to_int64(const NumericVar *var, int64 *result)
         * 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];
+       val = -numeric_digit(&rounded, 0);
        for (i = 1; i <= weight; i++)
        {
                if (unlikely(pg_mul_s64_overflow(val, NBASE, &val)))
@@ -7883,7 +7916,7 @@ numericvar_to_int64(const NumericVar *var, int64 *result)
 
                if (i < ndigits)
                {
-                       if (unlikely(pg_sub_s64_overflow(val, digits[i], &val)))
+                       if (unlikely(pg_sub_s64_overflow(val, 
numeric_digit(&rounded, i), &val)))
                        {
                                free_var(&rounded);
                                return false;
@@ -7956,7 +7989,6 @@ int64_to_numericvar(int64 val, NumericVar *var)
 static bool
 numericvar_to_uint64(const NumericVar *var, uint64 *result)
 {
-       NumericDigit *digits;
        int                     ndigits;
        int                     weight;
        int                     i;
@@ -7993,8 +8025,7 @@ numericvar_to_uint64(const NumericVar *var, uint64 
*result)
        Assert(weight >= 0 && ndigits <= weight + 1);
 
        /* Construct the result */
-       digits = rounded.digits;
-       val = digits[0];
+       val = numeric_digit(&rounded, 0);
        for (i = 1; i <= weight; i++)
        {
                if (unlikely(pg_mul_u64_overflow(val, NBASE, &val)))
@@ -8005,7 +8036,7 @@ numericvar_to_uint64(const NumericVar *var, uint64 
*result)
 
                if (i < ndigits)
                {
-                       if (unlikely(pg_add_u64_overflow(val, digits[i], &val)))
+                       if (unlikely(pg_add_u64_overflow(val, 
numeric_digit(&rounded, i), &val)))
                        {
                                free_var(&rounded);
                                return false;
@@ -8094,52 +8125,32 @@ numericvar_to_double_no_overflow(const NumericVar *var)
 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 (var1->ndigits == 0)
        {
-               if (var2ndigits == 0)
+               if (var2->ndigits == 0)
                        return 0;
-               if (var2sign == NUMERIC_NEG)
+               if (var2->sign == NUMERIC_NEG)
                        return 1;
                return -1;
        }
-       if (var2ndigits == 0)
+       if (var2->ndigits == 0)
        {
-               if (var1sign == NUMERIC_POS)
+               if (var1->sign == NUMERIC_POS)
                        return 1;
                return -1;
        }
 
-       if (var1sign == NUMERIC_POS)
+       if (var1->sign == NUMERIC_POS)
        {
-               if (var2sign == NUMERIC_NEG)
+               if (var2->sign == NUMERIC_NEG)
                        return 1;
-               return cmp_abs_common(var1digits, var1ndigits, var1weight,
-                                                         var2digits, 
var2ndigits, var2weight);
+               return cmp_abs(var1, var2);
        }
 
-       if (var2sign == NUMERIC_POS)
+       if (var2->sign == NUMERIC_POS)
                return -1;
 
-       return cmp_abs_common(var2digits, var2ndigits, var2weight,
-                                                 var1digits, var1ndigits, 
var1weight);
+       return cmp_abs(var2, var1);
 }
 
 
@@ -8407,8 +8418,6 @@ mul_var(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result,
        int                     var2ndigits;
        int                     var1ndigitpairs;
        int                     var2ndigitpairs;
-       NumericDigit *var1digits;
-       NumericDigit *var2digits;
        uint32          var1digitpair;
        uint32     *var2digitpairs;
        NumericDigit *res_digits;
@@ -8435,8 +8444,6 @@ mul_var(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result,
        /* 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)
        {
@@ -8556,12 +8563,12 @@ mul_var(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result,
        var2digitpairs = (uint32 *) (dig + res_ndigitpairs);
 
        for (i2 = 0; i2 < var2ndigitpairs - 1; i2++)
-               var2digitpairs[i2] = var2digits[2 * i2] * NBASE + var2digits[2 
* i2 + 1];
+               var2digitpairs[i2] = numeric_digit(var2, 2 * i2) * NBASE + 
numeric_digit(var2, 2 * i2 + 1);
 
        if (2 * i2 + 1 < var2ndigits)
-               var2digitpairs[i2] = var2digits[2 * i2] * NBASE + var2digits[2 
* i2 + 1];
+               var2digitpairs[i2] = numeric_digit(var2, 2 * i2) * NBASE + 
numeric_digit(var2, 2 * i2 + 1);
        else
-               var2digitpairs[i2] = var2digits[2 * i2] * NBASE;
+               var2digitpairs[i2] = numeric_digit(var2, 2 * i2) * NBASE;
 
        /*
         * Start by multiplying var2 by the least significant contributing digit
@@ -8578,9 +8585,9 @@ mul_var(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result,
         */
        i1 = var1ndigitpairs - 1;
        if (2 * i1 + 1 < var1ndigits)
-               var1digitpair = var1digits[2 * i1] * NBASE + var1digits[2 * i1 
+ 1];
+               var1digitpair = numeric_digit(var1, 2 * i1) * NBASE + 
numeric_digit(var1, 2 * i1 + 1);
        else
-               var1digitpair = var1digits[2 * i1] * NBASE;
+               var1digitpair = numeric_digit(var1, 2 * i1) * NBASE;
        maxdig = var1digitpair;
 
        i2limit = Min(var2ndigitpairs, res_ndigitpairs - i1 - pair_offset);
@@ -8597,7 +8604,7 @@ mul_var(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result,
         */
        for (i1 = i1 - 1; i1 >= 0; i1--)
        {
-               var1digitpair = var1digits[2 * i1] * NBASE + var1digits[2 * i1 
+ 1];
+               var1digitpair = numeric_digit(var1, 2 * i1) * NBASE + 
numeric_digit(var1, 2 * i1 + 1);
                if (var1digitpair == 0)
                        continue;
 
@@ -8684,8 +8691,6 @@ mul_var_short(const NumericVar *var1, const NumericVar 
*var2,
 {
        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;
@@ -8723,12 +8728,12 @@ mul_var_short(const NumericVar *var1, const NumericVar 
*var2,
         * 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])
+#define PRODSUM1(v1,i1,v2,i2) (numeric_digit(v1, i1) * numeric_digit(v2, i2))
+#define PRODSUM2(v1,i1,v2,i2) (PRODSUM1(v1,i1,v2,i2) + numeric_digit(v1, 
(i1)+1) * numeric_digit(v2, (i2)-1))
+#define PRODSUM3(v1,i1,v2,i2) (PRODSUM2(v1,i1,v2,i2) + numeric_digit(v1, 
(i1)+2) * numeric_digit(v2, (i2)-2))
+#define PRODSUM4(v1,i1,v2,i2) (PRODSUM3(v1,i1,v2,i2) + numeric_digit(v1, 
(i1)+3) * numeric_digit(v2, (i2)-3))
+#define PRODSUM5(v1,i1,v2,i2) (PRODSUM4(v1,i1,v2,i2) + numeric_digit(v1, 
(i1)+4) * numeric_digit(v2, (i2)-4))
+#define PRODSUM6(v1,i1,v2,i2) (PRODSUM5(v1,i1,v2,i2) + numeric_digit(v1, 
(i1)+5) * numeric_digit(v2, (i2)-5))
 
        switch (var1ndigits)
        {
@@ -8742,7 +8747,7 @@ mul_var_short(const NumericVar *var1, const NumericVar 
*var2,
                         */
                        for (int i = var2ndigits - 1; i >= 0; i--)
                        {
-                               term = PRODSUM1(var1digits, 0, var2digits, i) + 
carry;
+                               term = PRODSUM1(var1, 0, var2, i) + carry;
                                res_digits[i + 1] = (NumericDigit) (term % 
NBASE);
                                carry = term / NBASE;
                        }
@@ -8758,14 +8763,14 @@ mul_var_short(const NumericVar *var1, const NumericVar 
*var2,
                         * ----------
                         */
                        /* last result digit and carry */
-                       term = PRODSUM1(var1digits, 1, var2digits, var2ndigits 
- 1);
+                       term = PRODSUM1(var1, 1, var2, 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;
+                               term = PRODSUM2(var1, 0, var2, i) + carry;
                                res_digits[i + 1] = (NumericDigit) (term % 
NBASE);
                                carry = term / NBASE;
                        }
@@ -8780,18 +8785,18 @@ mul_var_short(const NumericVar *var1, const NumericVar 
*var2,
                         * ----------
                         */
                        /* last two result digits */
-                       term = PRODSUM1(var1digits, 2, var2digits, var2ndigits 
- 1);
+                       term = PRODSUM1(var1, 2, var2, var2ndigits - 1);
                        res_digits[res_ndigits - 1] = (NumericDigit) (term % 
NBASE);
                        carry = term / NBASE;
 
-                       term = PRODSUM2(var1digits, 1, var2digits, var2ndigits 
- 1) + carry;
+                       term = PRODSUM2(var1, 1, var2, 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;
+                               term = PRODSUM3(var1, 0, var2, i) + carry;
                                res_digits[i + 1] = (NumericDigit) (term % 
NBASE);
                                carry = term / NBASE;
                        }
@@ -8806,22 +8811,22 @@ mul_var_short(const NumericVar *var1, const NumericVar 
*var2,
                         * ----------
                         */
                        /* last three result digits */
-                       term = PRODSUM1(var1digits, 3, var2digits, var2ndigits 
- 1);
+                       term = PRODSUM1(var1, 3, var2, var2ndigits - 1);
                        res_digits[res_ndigits - 1] = (NumericDigit) (term % 
NBASE);
                        carry = term / NBASE;
 
-                       term = PRODSUM2(var1digits, 2, var2digits, var2ndigits 
- 1) + carry;
+                       term = PRODSUM2(var1, 2, var2, var2ndigits - 1) + carry;
                        res_digits[res_ndigits - 2] = (NumericDigit) (term % 
NBASE);
                        carry = term / NBASE;
 
-                       term = PRODSUM3(var1digits, 1, var2digits, var2ndigits 
- 1) + carry;
+                       term = PRODSUM3(var1, 1, var2, 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;
+                               term = PRODSUM4(var1, 0, var2, i) + carry;
                                res_digits[i + 1] = (NumericDigit) (term % 
NBASE);
                                carry = term / NBASE;
                        }
@@ -8836,26 +8841,26 @@ mul_var_short(const NumericVar *var1, const NumericVar 
*var2,
                         * ----------
                         */
                        /* last four result digits */
-                       term = PRODSUM1(var1digits, 4, var2digits, var2ndigits 
- 1);
+                       term = PRODSUM1(var1, 4, var2, var2ndigits - 1);
                        res_digits[res_ndigits - 1] = (NumericDigit) (term % 
NBASE);
                        carry = term / NBASE;
 
-                       term = PRODSUM2(var1digits, 3, var2digits, var2ndigits 
- 1) + carry;
+                       term = PRODSUM2(var1, 3, var2, var2ndigits - 1) + carry;
                        res_digits[res_ndigits - 2] = (NumericDigit) (term % 
NBASE);
                        carry = term / NBASE;
 
-                       term = PRODSUM3(var1digits, 2, var2digits, var2ndigits 
- 1) + carry;
+                       term = PRODSUM3(var1, 2, var2, var2ndigits - 1) + carry;
                        res_digits[res_ndigits - 3] = (NumericDigit) (term % 
NBASE);
                        carry = term / NBASE;
 
-                       term = PRODSUM4(var1digits, 1, var2digits, var2ndigits 
- 1) + carry;
+                       term = PRODSUM4(var1, 1, var2, 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;
+                               term = PRODSUM5(var1, 0, var2, i) + carry;
                                res_digits[i + 1] = (NumericDigit) (term % 
NBASE);
                                carry = term / NBASE;
                        }
@@ -8870,30 +8875,30 @@ mul_var_short(const NumericVar *var1, const NumericVar 
*var2,
                         * ----------
                         */
                        /* last five result digits */
-                       term = PRODSUM1(var1digits, 5, var2digits, var2ndigits 
- 1);
+                       term = PRODSUM1(var1, 5, var2, var2ndigits - 1);
                        res_digits[res_ndigits - 1] = (NumericDigit) (term % 
NBASE);
                        carry = term / NBASE;
 
-                       term = PRODSUM2(var1digits, 4, var2digits, var2ndigits 
- 1) + carry;
+                       term = PRODSUM2(var1, 4, var2, var2ndigits - 1) + carry;
                        res_digits[res_ndigits - 2] = (NumericDigit) (term % 
NBASE);
                        carry = term / NBASE;
 
-                       term = PRODSUM3(var1digits, 3, var2digits, var2ndigits 
- 1) + carry;
+                       term = PRODSUM3(var1, 3, var2, var2ndigits - 1) + carry;
                        res_digits[res_ndigits - 3] = (NumericDigit) (term % 
NBASE);
                        carry = term / NBASE;
 
-                       term = PRODSUM4(var1digits, 2, var2digits, var2ndigits 
- 1) + carry;
+                       term = PRODSUM4(var1, 2, var2, var2ndigits - 1) + carry;
                        res_digits[res_ndigits - 4] = (NumericDigit) (term % 
NBASE);
                        carry = term / NBASE;
 
-                       term = PRODSUM5(var1digits, 1, var2digits, var2ndigits 
- 1) + carry;
+                       term = PRODSUM5(var1, 1, var2, 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;
+                               term = PRODSUM6(var1, 0, var2, i) + carry;
                                res_digits[i + 1] = (NumericDigit) (term % 
NBASE);
                                carry = term / NBASE;
                        }
@@ -8907,27 +8912,27 @@ mul_var_short(const NumericVar *var1, const NumericVar 
*var2,
        switch (var1ndigits)
        {
                case 6:
-                       term = PRODSUM5(var1digits, 0, var2digits, 4) + carry;
+                       term = PRODSUM5(var1, 0, var2, 4) + carry;
                        res_digits[5] = (NumericDigit) (term % NBASE);
                        carry = term / NBASE;
                        pg_fallthrough;
                case 5:
-                       term = PRODSUM4(var1digits, 0, var2digits, 3) + carry;
+                       term = PRODSUM4(var1, 0, var2, 3) + carry;
                        res_digits[4] = (NumericDigit) (term % NBASE);
                        carry = term / NBASE;
                        pg_fallthrough;
                case 4:
-                       term = PRODSUM3(var1digits, 0, var2digits, 2) + carry;
+                       term = PRODSUM3(var1, 0, var2, 2) + carry;
                        res_digits[3] = (NumericDigit) (term % NBASE);
                        carry = term / NBASE;
                        pg_fallthrough;
                case 3:
-                       term = PRODSUM2(var1digits, 0, var2digits, 1) + carry;
+                       term = PRODSUM2(var1, 0, var2, 1) + carry;
                        res_digits[2] = (NumericDigit) (term % NBASE);
                        carry = term / NBASE;
                        pg_fallthrough;
                case 2:
-                       term = PRODSUM1(var1digits, 0, var2digits, 0) + carry;
+                       term = PRODSUM1(var1, 0, var2, 0) + carry;
                        res_digits[1] = (NumericDigit) (term % NBASE);
                        res_digits[0] = (NumericDigit) (term / NBASE);
                        break;
@@ -8997,7 +9002,7 @@ div_var(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result,
         * First of all division by zero check; we must not be handed an
         * unnormalized divisor.
         */
-       if (var2ndigits == 0 || var2->digits[0] == 0)
+       if (var2ndigits == 0 || numeric_digit(var2, 0) == 0)
                ereport(ERROR,
                                (errcode(ERRCODE_DIVISION_BY_ZERO),
                                 errmsg("division by zero")));
@@ -9014,11 +9019,11 @@ div_var(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result,
                int                     idivisor;
                int                     idivisor_weight;
 
-               idivisor = var2->digits[0];
+               idivisor = numeric_digit(var2, 0);
                idivisor_weight = var2->weight;
                if (var2ndigits == 2)
                {
-                       idivisor = idivisor * NBASE + var2->digits[1];
+                       idivisor = idivisor * NBASE + numeric_digit(var2, 1);
                        idivisor_weight--;
                }
                if (var2->sign == NUMERIC_NEG)
@@ -9033,11 +9038,11 @@ div_var(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result,
                int64           idivisor;
                int                     idivisor_weight;
 
-               idivisor = var2->digits[0];
+               idivisor = numeric_digit(var2, 0);
                idivisor_weight = var2->weight;
                for (i = 1; i < var2ndigits; i++)
                {
-                       idivisor = idivisor * NBASE + var2->digits[i];
+                       idivisor = idivisor * NBASE + numeric_digit(var2, i);
                        idivisor_weight--;
                }
                if (var2->sign == NUMERIC_NEG)
@@ -9148,23 +9153,23 @@ div_var(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result,
 
        /* 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];
+               dividend[i] = numeric_digit(var1, 2 * i) * NBASE + 
numeric_digit(var1, 2 * i + 1);
 
        if (2 * i + 1 < var1ndigits)
-               dividend[i] = var1->digits[2 * i] * NBASE + var1->digits[2 * i 
+ 1];
+               dividend[i] = numeric_digit(var1, 2 * i) * NBASE + 
numeric_digit(var1, 2 * i + 1);
        else
-               dividend[i] = var1->digits[2 * i] * NBASE;
+               dividend[i] = numeric_digit(var1, 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];
+               divisor[i] = numeric_digit(var2, 2 * i) * NBASE + 
numeric_digit(var2, 2 * i + 1);
 
        if (2 * i + 1 < var2ndigits)
-               divisor[i] = var2->digits[2 * i] * NBASE + var2->digits[2 * i + 
1];
+               divisor[i] = numeric_digit(var2, 2 * i) * NBASE + 
numeric_digit(var2, 2 * i + 1);
        else
-               divisor[i] = var2->digits[2 * i] * NBASE;
+               divisor[i] = numeric_digit(var2, 2 * i) * NBASE;
 
        /*
         * We estimate each quotient digit using floating-point arithmetic, 
taking
@@ -9510,7 +9515,6 @@ 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;
@@ -9575,7 +9579,7 @@ div_var_int(const NumericVar *var, int ival, int 
ival_weight,
 
                for (i = 0; i < res_ndigits; i++)
                {
-                       carry = carry * NBASE + (i < var_ndigits ? 
var_digits[i] : 0);
+                       carry = carry * NBASE + (i < var_ndigits ? 
numeric_digit(var, i) : 0);
                        res_digits[i] = (NumericDigit) (carry / divisor);
                        carry = carry % divisor;
                }
@@ -9587,7 +9591,7 @@ div_var_int(const NumericVar *var, int ival, int 
ival_weight,
 
                for (i = 0; i < res_ndigits; i++)
                {
-                       carry = carry * NBASE + (i < var_ndigits ? 
var_digits[i] : 0);
+                       carry = carry * NBASE + (i < var_ndigits ? 
numeric_digit(var, i) : 0);
                        res_digits[i] = (NumericDigit) (carry / divisor);
                        carry = carry % divisor;
                }
@@ -9626,7 +9630,6 @@ 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;
@@ -9691,7 +9694,7 @@ div_var_int64(const NumericVar *var, int64 ival, int 
ival_weight,
 
                for (i = 0; i < res_ndigits; i++)
                {
-                       carry = carry * NBASE + (i < var_ndigits ? 
var_digits[i] : 0);
+                       carry = carry * NBASE + (i < var_ndigits ? 
numeric_digit(var, i) : 0);
                        res_digits[i] = (NumericDigit) (carry / divisor);
                        carry = carry % divisor;
                }
@@ -9703,7 +9706,7 @@ div_var_int64(const NumericVar *var, int64 ival, int 
ival_weight,
 
                for (i = 0; i < res_ndigits; i++)
                {
-                       carry = carry * NBASE + (i < var_ndigits ? 
var_digits[i] : 0);
+                       carry = carry * NBASE + (i < var_ndigits ? 
numeric_digit(var, i) : 0);
                        res_digits[i] = (NumericDigit) (carry / divisor);
                        carry = carry % divisor;
                }
@@ -9759,7 +9762,7 @@ select_div_scale(const NumericVar *var1, const NumericVar 
*var2)
        firstdigit1 = 0;
        for (i = 0; i < var1->ndigits; i++)
        {
-               firstdigit1 = var1->digits[i];
+               firstdigit1 = numeric_digit(var1, i);
                if (firstdigit1 != 0)
                {
                        weight1 = var1->weight - i;
@@ -9771,7 +9774,7 @@ select_div_scale(const NumericVar *var1, const NumericVar 
*var2)
        firstdigit2 = 0;
        for (i = 0; i < var2->ndigits; i++)
        {
-               firstdigit2 = var2->digits[i];
+               firstdigit2 = numeric_digit(var2, i);
                if (firstdigit2 != 0)
                {
                        weight2 = var2->weight - i;
@@ -10166,7 +10169,7 @@ sqrt_var(const NumericVar *arg, NumericVar *result, int 
rscale)
        {
                /* Choose b so that a3 >= b/4, as described above */
                blen = src_ndigits / 4;
-               if (blen * 4 == src_ndigits && arg->digits[0] < NBASE / 4)
+               if (blen * 4 == src_ndigits && numeric_digit(arg, 0) < NBASE / 
4)
                        blen--;
 
                /* Number of digits in the next step (inner square root) */
@@ -10182,12 +10185,12 @@ sqrt_var(const NumericVar *arg, NumericVar *result, 
int rscale)
         * arithmetic, which will in fact almost certainly return the correct
         * result with no further correction required.
         */
-       arg_int64 = arg->digits[0];
+       arg_int64 = numeric_digit(arg, 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];
+                       arg_int64 += numeric_digit(arg, src_idx);
        }
 
        s_int64 = (int64) sqrt((double) arg_int64);
@@ -10252,14 +10255,14 @@ sqrt_var(const NumericVar *arg, NumericVar *result, 
int rscale)
                        b *= NBASE;
                        a1 *= NBASE;
                        if (src_idx < arg->ndigits)
-                               a1 += arg->digits[src_idx];
+                               a1 += numeric_digit(arg, src_idx);
                }
 
                for (i = 0; i < blen; i++, src_idx++)
                {
                        a0 *= NBASE;
                        if (src_idx < arg->ndigits)
-                               a0 += arg->digits[src_idx];
+                               a0 += numeric_digit(arg, src_idx);
                }
 
                /* Compute (q,u) = DivRem(r*b + a1, 2*s) */
@@ -10326,14 +10329,14 @@ sqrt_var(const NumericVar *arg, NumericVar *result, 
int rscale)
                                b *= NBASE;
                                a1 *= NBASE;
                                if (src_idx < arg->ndigits)
-                                       a1 += arg->digits[src_idx];
+                                       a1 += numeric_digit(arg, src_idx);
                        }
 
                        for (i = 0; i < blen; i++, src_idx++)
                        {
                                a0 *= NBASE;
                                if (src_idx < arg->ndigits)
-                                       a0 += arg->digits[src_idx];
+                                       a0 += numeric_digit(arg, src_idx);
                        }
 
                        /* Compute (q,u) = DivRem(r*b + a1, 2*s) */
@@ -10654,7 +10657,7 @@ estimate_ln_dweight(const NumericVar *var)
                if (x.ndigits > 0)
                {
                        /* Use weight of most significant decimal digit of x */
-                       ln_dweight = x.weight * DEC_DIGITS + (int) 
log10(x.digits[0]);
+                       ln_dweight = x.weight * DEC_DIGITS + (int) 
log10(numeric_digit(&x, 0));
                }
                else
                {
@@ -10677,12 +10680,12 @@ estimate_ln_dweight(const NumericVar *var)
                        int                     dweight;
                        double          ln_var;
 
-                       digits = var->digits[0];
+                       digits = numeric_digit(var, 0);
                        dweight = var->weight * DEC_DIGITS;
 
                        if (var->ndigits > 1)
                        {
-                               digits = digits * NBASE + var->digits[1];
+                               digits = digits * NBASE + numeric_digit(var, 1);
                                dweight -= DEC_DIGITS;
                        }
 
@@ -10960,7 +10963,7 @@ power_var(const NumericVar *base, const NumericVar 
*exp, NumericVar *result)
 
                /* Test if exp is odd or even */
                if (exp->ndigits > 0 && exp->ndigits == exp->weight + 1 &&
-                       (exp->digits[exp->ndigits - 1] & 1))
+                       (numeric_digit(exp, exp->ndigits - 1) & 1))
                        res_sign = NUMERIC_NEG;
                else
                        res_sign = NUMERIC_POS;
@@ -11090,12 +11093,12 @@ power_var_int(const NumericVar *base, int exp, int 
exp_dscale,
                 * Then log10(result) = log10(base^exp) ~= exp * (log10(f) + p).
                 *----------
                 */
-               f = base->digits[0];
+               f = numeric_digit(base, 0);
                p = base->weight * DEC_DIGITS;
 
                for (i = 1; i < base->ndigits && i * DEC_DIGITS < 16; i++)
                {
-                       f = f * NBASE + base->digits[i];
+                       f = f * NBASE + numeric_digit(base, i);
                        p -= DEC_DIGITS;
                }
 
@@ -11284,7 +11287,7 @@ power_ten_int(int exp, NumericVar *result)
 
        /* Final adjustment of the result's single NBASE digit */
        while (exp-- > 0)
-               result->digits[0] *= 10;
+               result->digits[0] = numeric_digit(result, 0) * 10;
 }
 
 /*
@@ -11363,13 +11366,13 @@ random_var(pg_prng_state *state, const NumericVar 
*rmin,
         * 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 = (uint64) numeric_digit(&rlen, 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 += numeric_digit(&rlen, rlen64_ndigits);
                rlen64_ndigits++;
        }
 
@@ -11475,37 +11478,26 @@ random_var(pg_prng_state *state, const NumericVar 
*rmin,
  */
 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;
+       int                     var1weight = var1->weight;
+       int                     var2weight = var2->weight;
 
        /* Check any digits before the first common digit */
 
-       while (var1weight > var2weight && i1 < var1ndigits)
+       while (var1weight > var2weight && i1 < var1->ndigits)
        {
-               if (var1digits[i1++] != 0)
+               if (numeric_digit(var1, i1) != 0)
                        return 1;
+               i1++;
                var1weight--;
        }
-       while (var2weight > var1weight && i2 < var2ndigits)
+       while (var2weight > var1weight && i2 < var2->ndigits)
        {
-               if (var2digits[i2++] != 0)
+               if (numeric_digit(var2, i2) != 0)
                        return -1;
+               i2++;
                var2weight--;
        }
 
@@ -11513,9 +11505,12 @@ cmp_abs_common(const NumericDigit *var1digits, int 
var1ndigits, int var1weight,
 
        if (var1weight == var2weight)
        {
-               while (i1 < var1ndigits && i2 < var2ndigits)
+               while (i1 < var1->ndigits && i2 < var2->ndigits)
                {
-                       int                     stat = var1digits[i1++] - 
var2digits[i2++];
+                       int stat = numeric_digit(var1, i1) - 
numeric_digit(var2, i2);
+
+                       i1++;
+                       i2++;
 
                        if (stat)
                        {
@@ -11530,15 +11525,17 @@ cmp_abs_common(const NumericDigit *var1digits, int 
var1ndigits, int var1weight,
         * 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)
+       while (i1 < var1->ndigits)
        {
-               if (var1digits[i1++] != 0)
+               if (numeric_digit(var1, i1) != 0)
                        return 1;
+               i1++;
        }
-       while (i2 < var2ndigits)
+       while (i2 < var2->ndigits)
        {
-               if (var2digits[i2++] != 0)
+               if (numeric_digit(var2, i2) != 0)
                        return -1;
+               i2++;
        }
 
        return 0;
@@ -11570,8 +11567,6 @@ add_abs(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result)
        /* 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;
 
@@ -11597,9 +11592,9 @@ add_abs(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result)
                i1--;
                i2--;
                if (i1 >= 0 && i1 < var1ndigits)
-                       carry += var1digits[i1];
+                       carry += numeric_digit(var1, i1);
                if (i2 >= 0 && i2 < var2ndigits)
-                       carry += var2digits[i2];
+                       carry += numeric_digit(var2, i2);
 
                if (carry >= NBASE)
                {
@@ -11655,8 +11650,6 @@ sub_abs(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result)
        /* 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;
 
@@ -11682,9 +11675,9 @@ sub_abs(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result)
                i1--;
                i2--;
                if (i1 >= 0 && i1 < var1ndigits)
-                       borrow += var1digits[i1];
+                       borrow += numeric_digit(var1, i1);
                if (i2 >= 0 && i2 < var2ndigits)
-                       borrow -= var2digits[i2];
+                       borrow -= numeric_digit(var2, i2);
 
                if (borrow < 0)
                {
@@ -11721,7 +11714,6 @@ sub_abs(const NumericVar *var1, const NumericVar *var2, 
NumericVar *result)
 static void
 round_var(NumericVar *var, int rscale)
 {
-       NumericDigit *digits = var->digits;
        int                     di;
        int                     ndigits;
        int                     carry;
@@ -11756,10 +11748,10 @@ round_var(NumericVar *var, int rscale)
 
 #if DEC_DIGITS == 1
                        /* di must be zero */
-                       carry = (digits[ndigits] >= HALF_NBASE) ? 1 : 0;
+                       carry = (numeric_digit(var, ndigits) >= HALF_NBASE) ? 1 
: 0;
 #else
                        if (di == 0)
-                               carry = (digits[ndigits] >= HALF_NBASE) ? 1 : 0;
+                               carry = (numeric_digit(var, ndigits) >= 
HALF_NBASE) ? 1 : 0;
                        else
                        {
                                /* Must round within last NBASE digit */
@@ -11773,18 +11765,18 @@ round_var(NumericVar *var, int rscale)
 #else
 #error unsupported NBASE
 #endif
-                               extra = digits[--ndigits] % pow10;
-                               digits[ndigits] -= extra;
+                               extra = numeric_digit(var, --ndigits) % pow10;
+                               var->digits[ndigits] = numeric_digit(var, 
ndigits) - extra;
                                carry = 0;
                                if (extra >= pow10 / 2)
                                {
-                                       pow10 += digits[ndigits];
+                                       pow10 += numeric_digit(var, ndigits);
                                        if (pow10 >= NBASE)
                                        {
                                                pow10 -= NBASE;
                                                carry = 1;
                                        }
-                                       digits[ndigits] = pow10;
+                                       var->digits[ndigits] = pow10;
                                }
                        }
 #endif
@@ -11792,15 +11784,15 @@ round_var(NumericVar *var, int rscale)
                        /* Propagate carry if needed */
                        while (carry)
                        {
-                               carry += digits[--ndigits];
+                               carry += numeric_digit(var, --ndigits);
                                if (carry >= NBASE)
                                {
-                                       digits[ndigits] = carry - NBASE;
+                                       var->digits[ndigits] = carry - NBASE;
                                        carry = 1;
                                }
                                else
                                {
-                                       digits[ndigits] = carry;
+                                       var->digits[ndigits] = carry;
                                        carry = 0;
                                }
                        }
@@ -11862,7 +11854,6 @@ trunc_var(NumericVar *var, int rscale)
                        if (di > 0)
                        {
                                /* Must truncate within last NBASE digit */
-                               NumericDigit *digits = var->digits;
                                int                     extra,
                                                        pow10;
 
@@ -11873,8 +11864,8 @@ trunc_var(NumericVar *var, int rscale)
 #else
 #error unsupported NBASE
 #endif
-                               extra = digits[--ndigits] % pow10;
-                               digits[ndigits] -= extra;
+                               extra = numeric_digit(var, --ndigits) % pow10;
+                               var->digits[ndigits] = numeric_digit(var, 
ndigits) - extra;
                        }
 #endif
                }
@@ -11889,19 +11880,19 @@ trunc_var(NumericVar *var, int rscale)
 static void
 strip_var(NumericVar *var)
 {
-       NumericDigit *digits = var->digits;
        int                     ndigits = var->ndigits;
+       int                     start = 0;
 
        /* Strip leading zeroes */
-       while (ndigits > 0 && *digits == 0)
+       while (ndigits > 0 && numeric_digit(var, start) == 0)
        {
-               digits++;
+               start++;
                var->weight--;
                ndigits--;
        }
 
        /* Strip trailing zeroes */
-       while (ndigits > 0 && digits[ndigits - 1] == 0)
+       while (ndigits > 0 && numeric_digit(var, start + ndigits - 1) == 0)
                ndigits--;
 
        /* If it's zero, normalize the sign and weight */
@@ -11911,7 +11902,7 @@ strip_var(NumericVar *var)
                var->weight = 0;
        }
 
-       var->digits = digits;
+       var->digits += start;
        var->ndigits = ndigits;
 }
 
@@ -11948,7 +11939,6 @@ 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
@@ -11972,13 +11962,12 @@ accum_sum_add(NumericSumAccum *accum, const 
NumericVar *val)
        else
                accum_digits = accum->neg_digits;
 
-       /* copy these values into local vars for speed in loop */
+       /* copy this value into a local var 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_digits[i] += (int32) numeric_digit(val, i);
 
        accum->num_uncarried++;
 }
diff --git a/src/include/utils/numeric.h b/src/include/utils/numeric.h
index ea289dabfeb..07f01f8b25c 100644
--- a/src/include/utils/numeric.h
+++ b/src/include/utils/numeric.h
@@ -52,9 +52,7 @@ typedef struct Node Node;
  */
 #define NUMERIC_MIN_SIG_DIGITS         16
 
-/* The actual contents of Numeric are private to numeric.c */
-struct NumericData;
-typedef struct NumericData *Numeric;
+typedef struct varlena *Numeric;
 
 /*
  * fmgr interface macros
@@ -66,6 +64,12 @@ DatumGetNumeric(Datum X)
        return (Numeric) PG_DETOAST_DATUM(X);
 }
 
+static inline Numeric
+DatumGetNumericPacked(Datum X)
+{
+       return (Numeric) PG_DETOAST_DATUM_PACKED(X);
+}
+
 static inline Numeric
 DatumGetNumericCopy(Datum X)
 {
@@ -79,6 +83,7 @@ NumericGetDatum(Numeric X)
 }
 
 #define PG_GETARG_NUMERIC(n)     DatumGetNumeric(PG_GETARG_DATUM(n))
+#define PG_GETARG_NUMERIC_PACKED(n) DatumGetNumericPacked(PG_GETARG_DATUM(n))
 #define PG_GETARG_NUMERIC_COPY(n) DatumGetNumericCopy(PG_GETARG_DATUM(n))
 #define PG_RETURN_NUMERIC(x)     return NumericGetDatum(x)
 
-- 
2.55.0

Reply via email to