Back-patch critical fixes for NUMERIC...

diff --git a/src/backend/catalog/pg_aggregate.c b/src/backend/catalog/pg_aggregate.c
index c3a421cbb6f9b4fb1a33633726a1132f177f03f3..e1c94849d08fc34bc943e4c7a49bdbd2e433c3e4 100644 (file)
--- a/src/backend/catalog/pg_aggregate.c
+++ b/src/backend/catalog/pg_aggregate.c
@@ -7,7 +7,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.20.2.1 1999/08/02 05:56:55 scrappy Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.20.2.2 2000/01/16 00:44:04 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -313,7 +313,10 @@ AggNameGetInitVal(char *aggName, Oid basetype, int xfuncno, bool *isNull)
                pfree(strInitVal);
                elog(ERROR, "AggNameGetInitVal: cache lookup failed on aggregate transition function return type");
        }
-       initVal = fmgr(((Form_pg_type) GETSTRUCT(tup))->typinput, strInitVal, -1);
+       initVal = fmgr(((Form_pg_type) GETSTRUCT(tup))->typinput,
+                                  strInitVal,
+                                  ((Form_pg_type) GETSTRUCT(tup))->typelem,
+                                  -1);
        pfree(strInitVal);
        return initVal;
 }

diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index eaee00fbd1b118dd3813dd97a3ee5637c396ee1d..fe1d8671e536bf062ba338838604201ff1c5e8c1 100644 (file)
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -5,7 +5,7 @@
  *
  *     1998 Jan Wieck
  *
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.16.2.1 1999/08/02 05:24:55 scrappy Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/numeric.c,v 1.16.2.2 2000/01/16 00:44:06 tgl Exp $
  *
  * ----------
  */
@@ -249,46 +249,50 @@ numeric_out(Numeric num)
        init_var(&x);
        set_var_from_num(num, &x);
 
-       /* ----------
-        * Allocate space for the result
-        * ----------
-        */
-       str = palloc(x.dscale + MAX(0, x.weight) + 5);
-       cp = str;
-
-       /* ----------
-        * Output a dash for negative values
-        * ----------
-        */
-       if (x.sign == NUMERIC_NEG)
-               *cp++ = '-';
-
        /* ----------
         * Check if we must round up before printing the value and
         * do so.
         * ----------
         */
-       if (x.dscale < x.rscale && (x.dscale + x.weight + 1) < x.ndigits)
+       i = x.dscale + x.weight + 1;
+       if (i >= 0 && x.ndigits > i)
        {
-               int                     j;
-               int                     carry;
+               int             carry = (x.digits[i] > 4) ? 1 : 0;
 
-               j = x.dscale + x.weight + 1;
-               carry = (x.digits[j] > 4) ? 1 : 0;
+               x.ndigits = i;
 
                while (carry)
                {
-                       j--;
-                       carry += x.digits[j];
-                       x.digits[j] = carry % 10;
+                       carry += x.digits[--i];
+                       x.digits[i] = carry % 10;
                        carry /= 10;
                }
-               if (j < 0)
+
+               if (i < 0)
                {
+                       Assert(i == -1);        /* better not have added more than 1 digit */
+                       Assert(x.digits > (NumericDigit *) (x.buf + 1));
                        x.digits--;
+                       x.ndigits++;
                        x.weight++;
                }
        }
+       else
+               x.ndigits = MAX(0, MIN(i, x.ndigits));
+
+       /* ----------
+        * Allocate space for the result
+        * ----------
+        */
+       str = palloc(MAX(0, x.dscale) + MAX(0, x.weight) + 4);
+       cp = str;
+
+       /* ----------
+        * Output a dash for negative values
+        * ----------
+        */
+       if (x.sign == NUMERIC_NEG)
+               *cp++ = '-';
 
        /* ----------
         * Output all digits before the decimal point
@@ -2212,7 +2216,8 @@ set_var_from_str(char *str, NumericVar *dest)
 
        if (*cp == 'e' || *cp == 'E')
        {
-               /* Handle ...Ennn */
+               /* XXX Should handle ...Ennn */
+               elog(ERROR, "Bad numeric input format '%s'", str);
        }
 
        while (dest->ndigits > 0 && *(dest->digits) == 0)
@@ -2378,20 +2383,14 @@ apply_typmod(NumericVar *var, int32 typmod)
        scale = typmod & 0xffff;
        maxweight = precision - scale;
 
-       if (var->weight >= maxweight)
-       {
-               free_allvars();
-               elog(ERROR, "overflow on numeric "
-                        "ABS(value) >= 10^%d for field with precision %d scale %d",
-                        var->weight, precision, scale);
-       }
-
+       /* Round to target scale */
        i = scale + var->weight + 1;
        if (i >= 0 && var->ndigits > i)
        {
-               long            carry = (var->digits[i] > 4) ? 1 : 0;
+               int             carry = (var->digits[i] > 4) ? 1 : 0;
 
                var->ndigits = i;
+
                while (carry)
                {
                        carry += var->digits[--i];
@@ -2401,6 +2400,8 @@ apply_typmod(NumericVar *var, int32 typmod)
 
                if (i < 0)
                {
+                       Assert(i == -1);        /* better not have added more than 1 digit */
+                       Assert(var->digits > (NumericDigit *) (var->buf + 1));
                        var->digits--;
                        var->ndigits++;
                        var->weight++;
@@ -2410,16 +2411,33 @@ apply_typmod(NumericVar *var, int32 typmod)
                var->ndigits = MAX(0, MIN(i, var->ndigits));
 
        /* ----------
-        * Check for overflow again - rounding could have raised the
-        * weight.
+        * Check for overflow - note we can't do this before rounding,
+        * because rounding could raise the weight.  Also note that the
+        * var's weight could be inflated by leading zeroes, which will
+        * be stripped before storage but perhaps might not have been yet.
+        * In any case, we must recognize a true zero, whose weight doesn't
+        * mean anything.
         * ----------
         */
        if (var->weight >= maxweight)
        {
-               free_allvars();
-               elog(ERROR, "overflow on numeric "
-                        "ABS(value) >= 10^%d for field with precision %d scale %d",
-                        var->weight, precision, scale);
+               /* Determine true weight; and check for all-zero result */
+               int             tweight = var->weight;
+
+               for (i = 0; i < var->ndigits; i++)
+               {
+                       if (var->digits[i])
+                               break;
+                       tweight--;
+               }
+               
+               if (tweight >= maxweight && i < var->ndigits)
+               {
+                       free_allvars();
+                       elog(ERROR, "overflow on numeric "
+                                "ABS(value) >= 10^%d for field with precision %d scale %d",
+                                tweight, precision, scale);
+               }
        }
 
        var->rscale = scale;