Avoid unexpected conversion overflow in planner for distant date values.

The "date" type supports a wider range of dates than int64 timestamps do.
However, there is pre-int64-timestamp code in the planner that assumes that
all date values can be converted to timestamp with impunity.  Fortunately,
what we really need out of the conversion is always a double (float8)
value; so even when the date is out of timestamp's range it's possible to
produce a sane answer.  All we need is a code path that doesn't try to
force the result into int64.  Per trouble report from David Rericha.

Back-patch to all supported versions.  Although this is surely a corner
case, there's not much point in advertising a date range wider than
timestamp's if we will choke on such values in unexpected places.

diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c
index 014294f137d012eb06faffd3b833db20cf1e39ec..ee0b09f0491b5be863276b7bf2ce75de03f54a44 100644 (file)
--- a/src/backend/utils/adt/date.c
+++ b/src/backend/utils/adt/date.c
@@ -459,6 +459,39 @@ date2timestamptz(DateADT dateVal)
    return result;
 }
 
+/*
+ * date2timestamp_no_overflow
+ *
+ * This is chartered to produce a double value that is numerically
+ * equivalent to the corresponding Timestamp value, if the date is in the
+ * valid range of Timestamps, but in any case not throw an overflow error.
+ * We can do this since the numerical range of double is greater than
+ * that of non-erroneous timestamps.  The results are currently only
+ * used for statistical estimation purposes.
+ */
+double
+date2timestamp_no_overflow(DateADT dateVal)
+{
+   double  result;
+
+   if (DATE_IS_NOBEGIN(dateVal))
+       result = -DBL_MAX;
+   else if (DATE_IS_NOEND(dateVal))
+       result = DBL_MAX;
+   else
+   {
+#ifdef HAVE_INT64_TIMESTAMP
+       /* date is days since 2000, timestamp is microseconds since same... */
+       result = dateVal * (double) USECS_PER_DAY;
+#else
+       /* date is days since 2000, timestamp is seconds since same... */
+       result = dateVal * (double) SECS_PER_DAY;
+#endif
+   }
+
+   return result;
+}
+
 
 /*
  * Crosstype comparison functions for dates

diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c
index ef87f724ae99d0cb6c5a0ef8faf2d554767986af..cf8618dd9075dae55f1d0466ec1819b8f145454c 100644 (file)
--- a/src/backend/utils/adt/selfuncs.c
+++ b/src/backend/utils/adt/selfuncs.c
@@ -3866,8 +3866,7 @@ convert_timevalue_to_scalar(Datum value, Oid typid)
            return DatumGetTimestamp(DirectFunctionCall1(abstime_timestamp,
                                                         value));
        case DATEOID:
-           return DatumGetTimestamp(DirectFunctionCall1(date_timestamp,
-                                                        value));
+           return date2timestamp_no_overflow(DatumGetDateADT(value));
        case INTERVALOID:
            {
                Interval   *interval = DatumGetIntervalP(value);

diff --git a/src/include/utils/date.h b/src/include/utils/date.h
index dfa591b452f3f4ecfbce3523ae8c32256506d50b..9a6148b00dc702d7d9aa1afe71cd54fd3fb958b9 100644 (file)
--- a/src/include/utils/date.h
+++ b/src/include/utils/date.h
@@ -91,6 +91,8 @@ typedef struct
 
 
 /* date.c */
+extern double date2timestamp_no_overflow(DateADT dateVal);
+
 extern Datum date_in(PG_FUNCTION_ARGS);
 extern Datum date_out(PG_FUNCTION_ARGS);
 extern Datum date_recv(PG_FUNCTION_ARGS);