Make int64_div_fast_to_numeric() more robust.

The prior coding of int64_div_fast_to_numeric() had a number of bugs
that would cause it to fail under different circumstances, such as
with log10val2 <= 0, or log10val2 a multiple of 4, or in the "slow"
numeric path with log10val2 >= 10.

None of those could be triggered by any of our current code, which
only uses log10val2 = 3 or 6. However, they made it a hazard for any
future code that might use it. Also, since this is exported by
numeric.c, users writing their own C code might choose to use it.

Therefore fix, and back- to v14, where it was introduced.

Dean Rasheed, reviewed by Tom Lane.

Discussion: https://postgr.es/m/CAEZATCW8gXgW0tgPxPgHDPhVX71%2BSWFRkhnXy%2BTfGDsKLepu2g%40mail.gmail.com

diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index 08c841675d883459680576fbf02a502087b93180..6bf6db6e27bbb0ca8fe904f41b37540c34aa6bf6 100644 (file)
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -4235,7 +4235,7 @@ int64_to_numeric(int64 val)
 }
 
 /*
- * Convert val1/(10**val2) to numeric.  This is much faster than normal
+ * Convert val1/(10**log10val2) to numeric.  This is much faster than normal
  * numeric division.
  */
 Numeric
@@ -4243,59 +4243,78 @@ int64_div_fast_to_numeric(int64 val1, int log10val2)
 {
    Numeric     res;
    NumericVar  result;
-   int64       saved_val1 = val1;
+   int         rscale;
    int         w;
    int         m;
 
+   init_var(&result);
+
+   /* result scale */
+   rscale = log10val2 < 0 ? 0 : log10val2;
+
    /* how much to decrease the weight by */
    w = log10val2 / DEC_DIGITS;
-   /* how much is left */
+   /* how much is left to divide by */
    m = log10val2 % DEC_DIGITS;
+   if (m < 0)
+   {
+       m += DEC_DIGITS;
+       w--;
+   }
 
    /*
-    * If there is anything left, multiply the dividend by what's left, then
-    * shift the weight by one more.
+    * If there is anything left to divide by (10^m with 0 < m < DEC_DIGITS),
+    * multiply the dividend by 10^(DEC_DIGITS - m), and shift the weight by
+    * one more.
     */
    if (m > 0)
    {
 #if DEC_DIGITS == 4
-       static int  pow10[] = {1, 10, 100, 1000};
+       static const int pow10[] = {1, 10, 100, 1000};
 #elif DEC_DIGITS == 2
-       static int  pow10[] = {1, 10};
+       static const int pow10[] = {1, 10};
 #elif DEC_DIGITS == 1
-       static int  pow10[] = {1};
+       static const int pow10[] = {1};
 #else
 #error unsupported NBASE
 #endif
+       int64       factor = pow10[DEC_DIGITS - m];
+       int64       new_val1;
 
        StaticAssertDecl(lengthof(pow10) == DEC_DIGITS, "mismatch with DEC_DIGITS");
 
-       if (unlikely(pg_mul_s64_overflow(val1, pow10[DEC_DIGITS - m], &val1)))
+       if (unlikely(pg_mul_s64_overflow(val1, factor, &new_val1)))
        {
-           /*
-            * If it doesn't fit, do the whole computation in numeric the slow
-            * way.  Note that va1l may have been overwritten, so use
-            * saved_val1 instead.
-            */
-           int         val2 = 1;
+#ifdef HAVE_INT128
+           /* do the multiplication using 128-bit integers */
+           int128      tmp;
 
-           for (int i = 0; i < log10val2; i++)
-               val2 *= 10;
-           res = numeric_div_opt_error(int64_to_numeric(saved_val1), int64_to_numeric(val2), NULL);
-           res = DatumGetNumeric(DirectFunctionCall2(numeric_round,
-                                                     NumericGetDatum(res),
-                                                     Int32GetDatum(log10val2)));
-           return res;
+           tmp = (int128) val1 * (int128) factor;
+
+           int128_to_numericvar(tmp, &result);
+#else
+           /* do the multiplication using numerics */
+           NumericVar  tmp;
+
+           init_var(&tmp);
+
+           int64_to_numericvar(val1, &result);
+           int64_to_numericvar(factor, &tmp);
+           mul_var(&result, &tmp, &result, 0);
+
+           free_var(&tmp);
+#endif
        }
+       else
+           int64_to_numericvar(new_val1, &result);
+
        w++;
    }
-
-   init_var(&result);
-
-   int64_to_numericvar(val1, &result);
+   else
+       int64_to_numericvar(val1, &result);
 
    result.weight -= w;
-   result.dscale += w * DEC_DIGITS - (DEC_DIGITS - m);
+   result.dscale = rscale;
 
    res = make_result(&result);