From c50838533bf4cca813e0a6f60808041f551ce606 Mon Sep 17 00:00:00 2001 From: Tom Lane Date: Mon, 7 Jul 2008 18:09:46 +0000 Subject: [PATCH] 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.) --- src/backend/utils/adt/date.c | 49 ++++++----- src/backend/utils/adt/timestamp.c | 140 ++++++++++++++++-------------- 2 files changed, 100 insertions(+), 89 deletions(-) diff --git a/src/backend/utils/adt/date.c b/src/backend/utils/adt/date.c index e7374388dd..6f10b666ca 100644 --- a/src/backend/utils/adt/date.c +++ b/src/backend/utils/adt/date.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $PostgreSQL: pgsql/src/backend/utils/adt/date.c,v 1.141 2008/03/25 22:42:43 tgl Exp $ + * $PostgreSQL: pgsql/src/backend/utils/adt/date.c,v 1.142 2008/07/07 18:09:46 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -2441,37 +2441,40 @@ timetz_zone(PG_FUNCTION_ARGS) TimeTzADT *result; int tz; char tzname[TZ_STRLEN_MAX + 1]; + 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.) */ text_to_cstring_buffer(zone, tzname, sizeof(tzname)); - tzp = pg_tzset(tzname); - if (tzp) - { - /* Get the offset-from-GMT that is valid today for the selected zone */ - pg_time_t now = (pg_time_t) time(NULL); - struct pg_tm *tm; + lowzone = downcase_truncate_identifier(tzname, + strlen(tzname), + false); - tm = pg_localtime(&now, tzp); - tz = -tm->tm_gmtoff; - } + type = DecodeSpecial(0, lowzone, &val); + + if (type == TZ || type == DTZ) + tz = val * 60; else { - char *lowzone; - int type, - val; + tzp = pg_tzset(tzname); + if (tzp) + { + /* Get the offset-from-GMT that is valid today for the zone */ + pg_time_t now = (pg_time_t) time(NULL); + struct pg_tm *tm; - lowzone = downcase_truncate_identifier(tzname, - strlen(tzname), - false); - type = DecodeSpecial(0, lowzone, &val); - - if (type == TZ || type == DTZ) - tz = val * 60; + 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 c266ed0f38..d6a5dee084 100644 --- a/src/backend/utils/adt/timestamp.c +++ b/src/backend/utils/adt/timestamp.c @@ -8,7 +8,7 @@ * * * IDENTIFICATION - * $PostgreSQL: pgsql/src/backend/utils/adt/timestamp.c,v 1.189 2008/05/04 23:19:23 tgl Exp $ + * $PostgreSQL: pgsql/src/backend/utils/adt/timestamp.c,v 1.190 2008/07/07 18:09:46 tgl Exp $ * *------------------------------------------------------------------------- */ @@ -4410,58 +4410,62 @@ timestamp_zone(PG_FUNCTION_ARGS) Timestamp timestamp = PG_GETARG_TIMESTAMP(1); TimestampTz result; int tz; - pg_tz *tzp; char tzname[TZ_STRLEN_MAX + 1]; + 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.) */ text_to_cstring_buffer(zone, tzname, sizeof(tzname)); - tzp = pg_tzset(tzname); - if (tzp) - { - /* Apply the timezone change */ - struct pg_tm tm; - fsec_t fsec; + lowzone = downcase_truncate_identifier(tzname, + strlen(tzname), + false); - 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))); + type = DecodeSpecial(0, lowzone, &val); + + if (type == TZ || type == DTZ) + { + tz = -(val * 60); + result = dt2local(timestamp, tz); } else { - char *lowzone; - int type, - val; + tzp = pg_tzset(tzname); + if (tzp) + { + /* Apply the timezone change */ + struct pg_tm tm; + fsec_t fsec; - lowzone = downcase_truncate_identifier(tzname, - strlen(tzname), - false); - type = DecodeSpecial(0, lowzone, &val); - - 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); @@ -4580,57 +4584,61 @@ timestamptz_zone(PG_FUNCTION_ARGS) TimestampTz timestamp = PG_GETARG_TIMESTAMPTZ(1); Timestamp result; int tz; - pg_tz *tzp; char tzname[TZ_STRLEN_MAX + 1]; + 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.) */ text_to_cstring_buffer(zone, tzname, sizeof(tzname)); - tzp = pg_tzset(tzname); - if (tzp) - { - /* Apply the timezone change */ - struct pg_tm tm; - fsec_t fsec; + lowzone = downcase_truncate_identifier(tzname, + strlen(tzname), + false); - 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))); + type = DecodeSpecial(0, lowzone, &val); + + if (type == TZ || type == DTZ) + { + tz = val * 60; + result = dt2local(timestamp, tz); } else { - char *lowzone; - int type, - val; + tzp = pg_tzset(tzname); + if (tzp) + { + /* Apply the timezone change */ + struct pg_tm tm; + fsec_t fsec; - lowzone = downcase_truncate_identifier(tzname, - strlen(tzname), - false); - type = DecodeSpecial(0, lowzone, &val); - - 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);