Repair inconsistent rounding behavior for timestamp, time, interval,

per gripe from Csaba Nagy.  There is still potential for platform-specific
behavior for values that are exactly halfway between integers, but at
least we now get the expected answer for all other cases.

diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c
index 3b921258890d14fdef817f2d306e18be2162d661..b952480f2fe303991b397203fcc2e89be6b145a3 100644 (file)
--- a/src/backend/utils/adt/date.c
+++ b/src/backend/utils/adt/date.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.74 2002/11/21 23:31:20 tgl Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/utils/adt/date.c,v 1.75 2003/01/09 01:06:57 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -630,12 +630,12 @@ AdjustTimeForTypmod(TimeADT *time, int32 typmod)
    };
 
    static const int64 TimeOffsets[MAX_TIMESTAMP_PRECISION + 1] = {
-       INT64CONST(-500000),
-       INT64CONST(-50000),
-       INT64CONST(-5000),
-       INT64CONST(-500),
-       INT64CONST(-50),
-       INT64CONST(-5),
+       INT64CONST(500000),
+       INT64CONST(50000),
+       INT64CONST(5000),
+       INT64CONST(500),
+       INT64CONST(50),
+       INT64CONST(5),
        INT64CONST(0)
    };
 
@@ -649,52 +649,33 @@ AdjustTimeForTypmod(TimeADT *time, int32 typmod)
        100000,
        1000000
    };
-
-   static const double TimeOffsets[MAX_TIMESTAMP_PRECISION + 1] = {
-       0.5,
-       0.05,
-       0.005,
-       0.0005,
-       0.00005,
-       0.000005,
-       0.0000005
-   };
 #endif
 
    if ((typmod >= 0) && (typmod <= MAX_TIME_PRECISION))
    {
+       /*
+        * Note: this round-to-nearest code is not completely consistent
+        * about rounding values that are exactly halfway between integral
+        * values.  On most platforms, rint() will implement round-to-nearest,
+        * but the integer code always rounds up (away from zero).  Is it
+        * worth trying to be consistent?
+        */
 #ifdef HAVE_INT64_TIMESTAMP
-       /* we have different truncation behavior depending on sign */
        if (*time >= INT64CONST(0))
-       {
-           *time = ((*time / TimeScales[typmod])
-                    * TimeScales[typmod]);
-       }
-       else
        {
            *time = (((*time + TimeOffsets[typmod]) / TimeScales[typmod])
                     * TimeScales[typmod]);
        }
-#else
-       /* we have different truncation behavior depending on sign */
-       if (*time >= 0)
-       {
-           *time = (rint(((double) *time) * TimeScales[typmod])
-                    / TimeScales[typmod]);
-       }
        else
        {
-           /*
-            * Scale and truncate first, then add to help the rounding
-            * behavior
-            */
-           *time = (rint((((double) *time) * TimeScales[typmod]) + TimeOffsets[typmod])
-                    / TimeScales[typmod]);
+           *time = - ((((- *time) + TimeOffsets[typmod]) / TimeScales[typmod])
+                      * TimeScales[typmod]);
        }
+#else
+       *time = (rint(((double) *time) * TimeScales[typmod])
+                / TimeScales[typmod]);
 #endif
    }
-
-   return;
 }
 
 

diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index 885d3992fd44ab5304e7845ab23a89e9507b1a14..19fb9c118438135748919e75ba281b9f7d644ab8 100644 (file)
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.75 2002/11/12 00:39:08 tgl Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/utils/adt/timestamp.c,v 1.76 2003/01/09 01:06:57 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -175,12 +175,12 @@ AdjustTimestampForTypmod(Timestamp *time, int32 typmod)
    };
 
    static const int64 TimestampOffsets[MAX_TIMESTAMP_PRECISION + 1] = {
-       INT64CONST(-500000),
-       INT64CONST(-50000),
-       INT64CONST(-5000),
-       INT64CONST(-500),
-       INT64CONST(-50),
-       INT64CONST(-5),
+       INT64CONST(500000),
+       INT64CONST(50000),
+       INT64CONST(5000),
+       INT64CONST(500),
+       INT64CONST(50),
+       INT64CONST(5),
        INT64CONST(0)
    };
 
@@ -194,16 +194,6 @@ AdjustTimestampForTypmod(Timestamp *time, int32 typmod)
        100000,
        1000000
    };
-
-   static const double TimestampOffsets[MAX_TIMESTAMP_PRECISION + 1] = {
-       0.5,
-       0.05,
-       0.005,
-       0.0005,
-       0.00005,
-       0.000005,
-       0.0000005
-   };
 #endif
 
    if (!TIMESTAMP_NOT_FINITE(*time)
@@ -213,34 +203,27 @@ AdjustTimestampForTypmod(Timestamp *time, int32 typmod)
            elog(ERROR, "TIMESTAMP(%d) precision must be between %d and %d",
                 typmod, 0, MAX_TIMESTAMP_PRECISION);
 
+       /*
+        * Note: this round-to-nearest code is not completely consistent
+        * about rounding values that are exactly halfway between integral
+        * values.  On most platforms, rint() will implement round-to-nearest,
+        * but the integer code always rounds up (away from zero).  Is it
+        * worth trying to be consistent?
+        */
 #ifdef HAVE_INT64_TIMESTAMP
-       /* we have different truncation behavior depending on sign */
        if (*time >= INT64CONST(0))
-       {
-           *time = ((*time / TimestampScales[typmod])
-                    * TimestampScales[typmod]);
-       }
-       else
        {
            *time = (((*time + TimestampOffsets[typmod]) / TimestampScales[typmod])
                     * TimestampScales[typmod]);
        }
-#else
-       /* we have different truncation behavior depending on sign */
-       if (*time >= 0)
-       {
-           *time = (rint(((double) *time) * TimestampScales[typmod])
-                    / TimestampScales[typmod]);
-       }
        else
        {
-           /*
-            * Scale and truncate first, then add to help the rounding
-            * behavior
-            */
-           *time = (rint((((double) *time) * TimestampScales[typmod]) + TimestampOffsets[typmod])
-                    / TimestampScales[typmod]);
+           *time = - ((((- *time) + TimestampOffsets[typmod]) / TimestampScales[typmod])
+                      * TimestampScales[typmod]);
        }
+#else
+       *time = (rint(((double) *time) * TimestampScales[typmod])
+                / TimestampScales[typmod]);
 #endif
    }
 }
@@ -474,12 +457,12 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
    };
 
    static const int64 IntervalOffsets[MAX_INTERVAL_PRECISION + 1] = {
-       INT64CONST(-500000),
-       INT64CONST(-50000),
-       INT64CONST(-5000),
-       INT64CONST(-500),
-       INT64CONST(-50),
-       INT64CONST(-5),
+       INT64CONST(500000),
+       INT64CONST(50000),
+       INT64CONST(5000),
+       INT64CONST(500),
+       INT64CONST(50),
+       INT64CONST(5),
        INT64CONST(0)
    };
 
@@ -493,16 +476,6 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
        100000,
        1000000
    };
-
-   static const double IntervalOffsets[MAX_INTERVAL_PRECISION + 1] = {
-       0.5,
-       0.05,
-       0.005,
-       0.0005,
-       0.00005,
-       0.000005,
-       0.0000005
-   };
 #endif
 
    /*
@@ -701,30 +674,27 @@ AdjustIntervalForTypmod(Interval *interval, int32 typmod)
                elog(ERROR, "INTERVAL(%d) precision must be between %d and %d",
                     precision, 0, MAX_INTERVAL_PRECISION);
 
+           /*
+            * Note: this round-to-nearest code is not completely consistent
+            * about rounding values that are exactly halfway between integral
+            * values.  On most platforms, rint() will implement round-to-nearest,
+            * but the integer code always rounds up (away from zero).  Is it
+            * worth trying to be consistent?
+            */
 #ifdef HAVE_INT64_TIMESTAMP
-           /* we have different truncation behavior depending on sign */
            if (interval->time >= INT64CONST(0))
-           {
-               interval->time = ((interval->time / IntervalScales[precision])
-                                 * IntervalScales[precision]);
-           }
-           else
            {
                interval->time = (((interval->time + IntervalOffsets[precision]) / IntervalScales[precision])
                                  * IntervalScales[precision]);
            }
-#else
-           /* we have different truncation behavior depending on sign */
-           if (interval->time >= 0)
-           {
-               interval->time = (rint(((double) interval->time) * IntervalScales[precision])
-                                 / IntervalScales[precision]);
-           }
            else
            {
-               interval->time = (rint((((double) interval->time) + IntervalOffsets[precision])
-               * IntervalScales[precision]) / IntervalScales[precision]);
+               interval->time = - (((-interval->time + IntervalOffsets[precision]) / IntervalScales[precision])
+                                   * IntervalScales[precision]);
            }
+#else
+           interval->time = (rint(((double) interval->time) * IntervalScales[precision])
+                             / IntervalScales[precision]);
 #endif
        }
    }