Fix AT TIME ZONE (in all three variants) so that we first try to interpret

the timezone argument as a timezone abbreviation, and only try it as a full
timezone name if that fails.  The zic database has four zones (CET, EET, MET,
WET) that are full daylight-savings zones and yet have names that are the
same as their abbreviations for standard time, resulting in ambiguity.
In the timestamp input functions we resolve the ambiguity by preferring the
abbreviation, and AT TIME ZONE should work the same way.  (No functionality
is lost because the zic database also has other names for these zones, eg
Europe/Zurich.)  Per gripe from Jaromir Talir.

Backpatch to 8.1.  Older releases did not have the issue because AT TIME ZONE
only accepted abbreviations not zone names.  (Thus, this patch also arguably
fixes a compatibility botch introduced at 8.1: in ambiguous cases we now
behave the same as 8.0 did.)

diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c
index 745d9d5b2e138676ac6a5d8f323d407c97cc605f..d68389b91b213a07c67c4cf9a593f26bbda33aaf 100644 (file)
--- a/src/backend/utils/adt/date.c
+++ b/src/backend/utils/adt/date.c
@@ -2452,40 +2452,42 @@ timetz_zone(PG_FUNCTION_ARGS)
        int                     tz;
        char            tzname[TZ_STRLEN_MAX + 1];
        int                     len;
+       char       *lowzone;
+       int                     type,
+                               val;
        pg_tz      *tzp;
 
        /*
-        * Look up the requested timezone.      First we look in the timezone database
-        * (to handle cases like "America/New_York"), and if that fails, we look
-        * in the date token table (to handle cases like "EST").
+        * Look up the requested timezone.  First we look in the date token table
+        * (to handle cases like "EST"), and if that fails, we look in the
+        * timezone database (to handle cases like "America/New_York").  (This
+        * matches the order in which timestamp input checks the cases; it's
+        * important because the timezone database unwisely uses a few zone names
+        * that are identical to offset abbreviations.)
         */
-       len = Min(VARSIZE(zone) - VARHDRSZ, TZ_STRLEN_MAX);
-       memcpy(tzname, VARDATA(zone), len);
-       tzname[len] = '\0';
-       tzp = pg_tzset(tzname);
-       if (tzp)
-       {
-               /* Get the offset-from-GMT that is valid today for the selected zone */
-               pg_time_t       now;
-               struct pg_tm *tm;
+       lowzone = downcase_truncate_identifier(VARDATA(zone),
+                                                                                  VARSIZE(zone) - VARHDRSZ,
+                                                                                  false);
+       type = DecodeSpecial(0, lowzone, &val);
 
-               now = time(NULL);
-               tm = pg_localtime(&now, tzp);
-               tz = -tm->tm_gmtoff;
-       }
+       if (type == TZ || type == DTZ)
+               tz = val * 60;
        else
        {
-               char       *lowzone;
-               int                     type,
-                                       val;
-
-               lowzone = downcase_truncate_identifier(VARDATA(zone),
-                                                                                          VARSIZE(zone) - VARHDRSZ,
-                                                                                          false);
-               type = DecodeSpecial(0, lowzone, &val);
+               len = Min(VARSIZE(zone) - VARHDRSZ, TZ_STRLEN_MAX);
+               memcpy(tzname, VARDATA(zone), len);
+               tzname[len] = '\0';
+               tzp = pg_tzset(tzname);
+               if (tzp)
+               {
+                       /* Get the offset-from-GMT that is valid today for the zone */
+                       pg_time_t       now;
+                       struct pg_tm *tm;
 
-               if (type == TZ || type == DTZ)
-                       tz = val * 60;
+                       now = time(NULL);
+                       tm = pg_localtime(&now, tzp);
+                       tz = -tm->tm_gmtoff;
+               }
                else
                {
                        ereport(ERROR,

diff --git a/src/backend/utils/adt/timestamp.c b/src/backend/utils/adt/timestamp.c
index 2883caf7167e81e19831d2eb6b4ca6d389b62fab..5e192890939a97d791e56262ca8d8130a1df7858 100644 (file)
--- a/src/backend/utils/adt/timestamp.c
+++ b/src/backend/utils/adt/timestamp.c
@@ -4428,61 +4428,64 @@ timestamp_zone(PG_FUNCTION_ARGS)
        Timestamp       timestamp = PG_GETARG_TIMESTAMP(1);
        TimestampTz result;
        int                     tz;
-       pg_tz      *tzp;
        char            tzname[TZ_STRLEN_MAX + 1];
        int                     len;
+       char       *lowzone;
+       int                     type,
+                               val;
+       pg_tz      *tzp;
 
        if (TIMESTAMP_NOT_FINITE(timestamp))
                PG_RETURN_TIMESTAMPTZ(timestamp);
 
        /*
-        * Look up the requested timezone.      First we look in the timezone database
-        * (to handle cases like "America/New_York"), and if that fails, we look
-        * in the date token table (to handle cases like "EST").
+        * Look up the requested timezone.  First we look in the date token table
+        * (to handle cases like "EST"), and if that fails, we look in the
+        * timezone database (to handle cases like "America/New_York").  (This
+        * matches the order in which timestamp input checks the cases; it's
+        * important because the timezone database unwisely uses a few zone names
+        * that are identical to offset abbreviations.)
         */
-       len = Min(VARSIZE(zone) - VARHDRSZ, TZ_STRLEN_MAX);
-       memcpy(tzname, VARDATA(zone), len);
-       tzname[len] = '\0';
-       tzp = pg_tzset(tzname);
-       if (tzp)
-       {
-               /* Apply the timezone change */
-               struct pg_tm tm;
-               fsec_t          fsec;
+       lowzone = downcase_truncate_identifier(VARDATA(zone),
+                                                                                  VARSIZE(zone) - VARHDRSZ,
+                                                                                  false);
+       type = DecodeSpecial(0, lowzone, &val);
 
-               if (timestamp2tm(timestamp, NULL, &tm, &fsec, NULL, tzp) != 0)
-                       ereport(ERROR,
-                                       (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
-                                        errmsg("timestamp out of range")));
-               tz = DetermineTimeZoneOffset(&tm, tzp);
-               if (tm2timestamp(&tm, fsec, &tz, &result) != 0)
-                       ereport(ERROR,
-                                       (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-                                        errmsg("could not convert to time zone \"%s\"",
-                                                       tzname)));
+       if (type == TZ || type == DTZ)
+       {
+               tz = -(val * 60);
+               result = dt2local(timestamp, tz);
        }
        else
        {
-               char       *lowzone;
-               int                     type,
-                                       val;
-
-               lowzone = downcase_truncate_identifier(VARDATA(zone),
-                                                                                          VARSIZE(zone) - VARHDRSZ,
-                                                                                          false);
-               type = DecodeSpecial(0, lowzone, &val);
+               len = Min(VARSIZE(zone) - VARHDRSZ, TZ_STRLEN_MAX);
+               memcpy(tzname, VARDATA(zone), len);
+               tzname[len] = '\0';
+               tzp = pg_tzset(tzname);
+               if (tzp)
+               {
+                       /* Apply the timezone change */
+                       struct pg_tm tm;
+                       fsec_t          fsec;
 
-               if (type == TZ || type == DTZ)
-                       tz = -(val * 60);
+                       if (timestamp2tm(timestamp, NULL, &tm, &fsec, NULL, tzp) != 0)
+                               ereport(ERROR,
+                                               (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
+                                                errmsg("timestamp out of range")));
+                       tz = DetermineTimeZoneOffset(&tm, tzp);
+                       if (tm2timestamp(&tm, fsec, &tz, &result) != 0)
+                               ereport(ERROR,
+                                               (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+                                                errmsg("could not convert to time zone \"%s\"",
+                                                               tzname)));
+               }
                else
                {
                        ereport(ERROR,
                                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                         errmsg("time zone \"%s\" not recognized", tzname)));
-                       tz = 0;                         /* keep compiler quiet */
+                       result = 0;                             /* keep compiler quiet */
                }
-
-               result = dt2local(timestamp, tz);
        }
 
        PG_RETURN_TIMESTAMPTZ(result);
@@ -4601,60 +4604,63 @@ timestamptz_zone(PG_FUNCTION_ARGS)
        TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1);
        Timestamp       result;
        int                     tz;
-       pg_tz      *tzp;
        char            tzname[TZ_STRLEN_MAX + 1];
        int                     len;
+       char       *lowzone;
+       int                     type,
+                               val;
+       pg_tz      *tzp;
 
        if (TIMESTAMP_NOT_FINITE(timestamp))
                PG_RETURN_TIMESTAMP(timestamp);
 
        /*
-        * Look up the requested timezone.      First we look in the timezone database
-        * (to handle cases like "America/New_York"), and if that fails, we look
-        * in the date token table (to handle cases like "EST").
+        * Look up the requested timezone.  First we look in the date token table
+        * (to handle cases like "EST"), and if that fails, we look in the
+        * timezone database (to handle cases like "America/New_York").  (This
+        * matches the order in which timestamp input checks the cases; it's
+        * important because the timezone database unwisely uses a few zone names
+        * that are identical to offset abbreviations.)
         */
-       len = Min(VARSIZE(zone) - VARHDRSZ, TZ_STRLEN_MAX);
-       memcpy(tzname, VARDATA(zone), len);
-       tzname[len] = '\0';
-       tzp = pg_tzset(tzname);
-       if (tzp)
-       {
-               /* Apply the timezone change */
-               struct pg_tm tm;
-               fsec_t          fsec;
+       lowzone = downcase_truncate_identifier(VARDATA(zone),
+                                                                                  VARSIZE(zone) - VARHDRSZ,
+                                                                                  false);
+       type = DecodeSpecial(0, lowzone, &val);
 
-               if (timestamp2tm(timestamp, &tz, &tm, &fsec, NULL, tzp) != 0)
-                       ereport(ERROR,
-                                       (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
-                                        errmsg("timestamp out of range")));
-               if (tm2timestamp(&tm, fsec, NULL, &result) != 0)
-                       ereport(ERROR,
-                                       (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-                                        errmsg("could not convert to time zone \"%s\"",
-                                                       tzname)));
+       if (type == TZ || type == DTZ)
+       {
+               tz = val * 60;
+               result = dt2local(timestamp, tz);
        }
        else
        {
-               char       *lowzone;
-               int                     type,
-                                       val;
-
-               lowzone = downcase_truncate_identifier(VARDATA(zone),
-                                                                                          VARSIZE(zone) - VARHDRSZ,
-                                                                                          false);
-               type = DecodeSpecial(0, lowzone, &val);
+               len = Min(VARSIZE(zone) - VARHDRSZ, TZ_STRLEN_MAX);
+               memcpy(tzname, VARDATA(zone), len);
+               tzname[len] = '\0';
+               tzp = pg_tzset(tzname);
+               if (tzp)
+               {
+                       /* Apply the timezone change */
+                       struct pg_tm tm;
+                       fsec_t          fsec;
 
-               if (type == TZ || type == DTZ)
-                       tz = val * 60;
+                       if (timestamp2tm(timestamp, &tz, &tm, &fsec, NULL, tzp) != 0)
+                               ereport(ERROR,
+                                               (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
+                                                errmsg("timestamp out of range")));
+                       if (tm2timestamp(&tm, fsec, NULL, &result) != 0)
+                               ereport(ERROR,
+                                               (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+                                                errmsg("could not convert to time zone \"%s\"",
+                                                               tzname)));
+               }
                else
                {
                        ereport(ERROR,
                                        (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                                         errmsg("time zone \"%s\" not recognized", tzname)));
-                       tz = 0;                         /* keep compiler quiet */
+                       result = 0;                             /* keep compiler quiet */
                }
-
-               result = dt2local(timestamp, tz);
        }
 
        PG_RETURN_TIMESTAMP(result);