Fix NUMERIC modulus to properly truncate division in computation.

Division rounding was causing incorrect results.  Test case:

	test=> SELECT 12345678901234567890 % 123;
	 ?column?
	----------
	       78
	(1 row)

Was returning -45.

diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index 214f9ff7a347919008342a94d3724a5e7d68653c..8b39bb4248cc97caf4ce421b8db9d8ee180e0041 100644 (file)
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -14,7 +14,7 @@
  * Copyright (c) 1998-2005, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/utils/adt/numeric.c,v 1.83 2005/04/06 23:56:07 neilc Exp $
+ *       $PostgreSQL: pgsql/src/backend/utils/adt/numeric.c,v 1.84 2005/06/04 14:12:50 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -265,7 +265,7 @@ static void sub_var(NumericVar *var1, NumericVar *var2, NumericVar *result);
 static void mul_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
                int rscale);
 static void div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
-               int rscale);
+               int rscale, bool round);
 static int     select_div_scale(NumericVar *var1, NumericVar *var2);
 static void mod_var(NumericVar *var1, NumericVar *var2, NumericVar *result);
 static void ceil_var(NumericVar *var, NumericVar *result);
@@ -906,14 +906,14 @@ compute_bucket(Numeric operand, Numeric bound1, Numeric bound2,
                sub_var(&operand_var, &bound1_var, &operand_var);
                sub_var(&bound2_var, &bound1_var, &bound2_var);
                div_var(&operand_var, &bound2_var, result_var,
-                               select_div_scale(&operand_var, &bound2_var));
+                               select_div_scale(&operand_var, &bound2_var), true);
        }
        else
        {
                sub_var(&bound1_var, &operand_var, &operand_var);
                sub_var(&bound1_var, &bound2_var, &bound1_var);
                div_var(&operand_var, &bound1_var, result_var,
-                               select_div_scale(&operand_var, &bound1_var));
+                               select_div_scale(&operand_var, &bound1_var), true);
        }
 
        mul_var(result_var, count_var, result_var,
@@ -1266,7 +1266,7 @@ numeric_div(PG_FUNCTION_ARGS)
        /*
         * Do the divide and return the result
         */
-       div_var(&arg1, &arg2, &result, rscale);
+       div_var(&arg1, &arg2, &result, rscale, true);
 
        res = make_result(&result);
 
@@ -2246,7 +2246,7 @@ numeric_variance(PG_FUNCTION_ARGS)
        {
                mul_var(&vN, &vNminus1, &vNminus1, 0);  /* N * (N - 1) */
                rscale = select_div_scale(&vsumX2, &vNminus1);
-               div_var(&vsumX2, &vNminus1, &vsumX, rscale);    /* variance */
+               div_var(&vsumX2, &vNminus1, &vsumX, rscale, true);      /* variance */
 
                res = make_result(&vsumX);
        }
@@ -2322,7 +2322,7 @@ numeric_stddev(PG_FUNCTION_ARGS)
        {
                mul_var(&vN, &vNminus1, &vNminus1, 0);  /* N * (N - 1) */
                rscale = select_div_scale(&vsumX2, &vNminus1);
-               div_var(&vsumX2, &vNminus1, &vsumX, rscale);    /* variance */
+               div_var(&vsumX2, &vNminus1, &vsumX, rscale, true);      /* variance */
                sqrt_var(&vsumX, &vsumX, rscale);               /* stddev */
 
                res = make_result(&vsumX);
@@ -3840,7 +3840,7 @@ mul_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
  */
 static void
 div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
-               int rscale)
+               int rscale, bool round)
 {
        int                     div_ndigits;
        int                     res_sign;
@@ -4079,8 +4079,11 @@ div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
        result->sign = res_sign;
 
        /* Round to target rscale (and set result->dscale) */
-       round_var(result, rscale);
-
+       if (round)
+               round_var(result, rscale);
+       else
+               trunc_var(result, rscale);
+       
        /* Strip leading and trailing zeroes */
        strip_var(result);
 }
@@ -4178,7 +4181,7 @@ mod_var(NumericVar *var1, NumericVar *var2, NumericVar *result)
         */
        rscale = select_div_scale(var1, var2);
 
-       div_var(var1, var2, &tmp, rscale);
+       div_var(var1, var2, &tmp, rscale, false);
 
        trunc_var(&tmp, 0);
 
@@ -4294,7 +4297,7 @@ sqrt_var(NumericVar *arg, NumericVar *result, int rscale)
 
        for (;;)
        {
-               div_var(&tmp_arg, result, &tmp_val, local_rscale);
+               div_var(&tmp_arg, result, &tmp_val, local_rscale, true);
 
                add_var(result, &tmp_val, result);
                mul_var(result, &const_zero_point_five, result, local_rscale);
@@ -4384,7 +4387,7 @@ exp_var(NumericVar *arg, NumericVar *result, int rscale)
 
        /* Compensate for input sign, and round to requested rscale */
        if (xneg)
-               div_var(&const_one, result, result, rscale);
+               div_var(&const_one, result, result, rscale, true);
        else
                round_var(result, rscale);
 
@@ -4450,7 +4453,7 @@ exp_var_internal(NumericVar *arg, NumericVar *result, int rscale)
                add_var(&ni, &const_one, &ni);
                mul_var(&xpow, &x, &xpow, local_rscale);
                mul_var(&ifac, &ni, &ifac, 0);
-               div_var(&xpow, &ifac, &elem, local_rscale);
+               div_var(&xpow, &ifac, &elem, local_rscale, true);
 
                if (elem.ndigits == 0)
                        break;
@@ -4534,7 +4537,7 @@ ln_var(NumericVar *arg, NumericVar *result, int rscale)
         */
        sub_var(&x, &const_one, result);
        add_var(&x, &const_one, &elem);
-       div_var(result, &elem, result, local_rscale);
+       div_var(result, &elem, result, local_rscale, true);
        set_var_from_var(result, &xx);
        mul_var(result, result, &x, local_rscale);
 
@@ -4544,7 +4547,7 @@ ln_var(NumericVar *arg, NumericVar *result, int rscale)
        {
                add_var(&ni, &const_two, &ni);
                mul_var(&xx, &x, &xx, local_rscale);
-               div_var(&xx, &ni, &elem, local_rscale);
+               div_var(&xx, &ni, &elem, local_rscale, true);
 
                if (elem.ndigits == 0)
                        break;
@@ -4614,7 +4617,7 @@ log_var(NumericVar *base, NumericVar *num, NumericVar *result)
        /* Select scale for division result */
        rscale = select_div_scale(&ln_num, &ln_base);
 
-       div_var(&ln_num, &ln_base, result, rscale);
+       div_var(&ln_num, &ln_base, result, rscale, true);
 
        free_var(&ln_num);
        free_var(&ln_base);
@@ -4752,7 +4755,7 @@ power_var_int(NumericVar *base, int exp, NumericVar *result, int rscale)
                        round_var(result, rscale);
                        return;
                case -1:
-                       div_var(&const_one, base, result, rscale);
+                       div_var(&const_one, base, result, rscale, true);
                        return;
                case 2:
                        mul_var(base, base, result, rscale);
@@ -4790,7 +4793,7 @@ power_var_int(NumericVar *base, int exp, NumericVar *result, int rscale)
 
        /* Compensate for input sign, and round to requested rscale */
        if (neg)
-               div_var(&const_one, result, result, rscale);
+               div_var(&const_one, result, result, rscale, true);
        else
                round_var(result, rscale);
 }