summaryrefslogtreecommitdiffstats
path: root/sql/tztime.cc
diff options
context:
space:
mode:
Diffstat (limited to 'sql/tztime.cc')
-rw-r--r--sql/tztime.cc3029
1 files changed, 3029 insertions, 0 deletions
diff --git a/sql/tztime.cc b/sql/tztime.cc
new file mode 100644
index 00000000..23c015e4
--- /dev/null
+++ b/sql/tztime.cc
@@ -0,0 +1,3029 @@
+/*
+ Copyright (c) 2004, 2010, Oracle and/or its affiliates.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; version 2 of the License.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
+
+/*
+ Most of the following code and structures were derived from
+ public domain code from ftp://elsie.nci.nih.gov/pub
+ (We will refer to this code as to elsie-code further.)
+*/
+
+/*
+ We should not include sql_priv.h in mysql_tzinfo_to_sql utility since
+ it creates unsolved link dependencies on some platforms.
+*/
+
+#ifdef USE_PRAGMA_IMPLEMENTATION
+#pragma implementation // gcc: Class implementation
+#endif
+
+#include "mariadb.h"
+#if !defined(TZINFO2SQL) && !defined(TESTTIME)
+#include "sql_priv.h"
+#include "unireg.h"
+#include "sql_time.h" // localtime_to_TIME
+#include "sql_base.h" // open_system_tables_for_read,
+ // close_system_tables
+#else
+#include <my_time.h>
+#include <my_sys.h>
+#include <mysql_version.h>
+#include <my_getopt.h>
+#endif
+
+#include "tztime.h"
+#include "tzfile.h"
+#include <m_string.h>
+#include <my_dir.h>
+#include <mysql/psi/mysql_file.h>
+#include "lock.h" // MYSQL_LOCK_IGNORE_FLUSH,
+ // MYSQL_LOCK_IGNORE_TIMEOUT
+
+/*
+ Now we don't use abbreviations in server but we will do this in future.
+*/
+#if defined(TZINFO2SQL) || defined(TESTTIME)
+#define ABBR_ARE_USED
+#else
+#if !defined(DBUG_OFF)
+/* Let use abbreviations for debug purposes */
+#undef ABBR_ARE_USED
+#define ABBR_ARE_USED
+#endif /* !defined(DBUG_OFF) */
+#endif /* defined(TZINFO2SQL) || defined(TESTTIME) */
+
+#define PROGRAM_VERSION "1.1"
+
+/* Structure describing local time type (e.g. Moscow summer time (MSD)) */
+typedef struct ttinfo
+{
+ long tt_gmtoff; // Offset from UTC in seconds
+ uint tt_isdst; // Is daylight saving time or not. Used to set tm_isdst
+#ifdef ABBR_ARE_USED
+ uint tt_abbrind; // Index of start of abbreviation for this time type.
+#endif
+ /*
+ We don't use tt_ttisstd and tt_ttisgmt members of original elsie-code
+ struct since we don't support POSIX-style TZ descriptions in variables.
+ */
+} TRAN_TYPE_INFO;
+
+/* Structure describing leap-second corrections. */
+typedef struct lsinfo
+{
+ my_time_t ls_trans; // Transition time
+ long ls_corr; // Correction to apply
+} LS_INFO;
+
+/*
+ Structure with information describing ranges of my_time_t shifted to local
+ time (my_time_t + offset). Used for local MYSQL_TIME -> my_time_t conversion.
+ See comments for TIME_to_gmt_sec() for more info.
+*/
+typedef struct revtinfo
+{
+ long rt_offset; // Offset of local time from UTC in seconds
+ uint rt_type; // Type of period 0 - Normal period. 1 - Spring time-gap
+} REVT_INFO;
+
+#ifdef TZNAME_MAX
+#define MY_TZNAME_MAX TZNAME_MAX
+#endif
+#ifndef TZNAME_MAX
+#define MY_TZNAME_MAX 255
+#endif
+
+/*
+ Structure which fully describes time zone which is
+ described in our db or in zoneinfo files.
+*/
+typedef struct st_time_zone_info
+{
+ uint leapcnt; // Number of leap-second corrections
+ uint timecnt; // Number of transitions between time types
+ uint typecnt; // Number of local time types
+ uint charcnt; // Number of characters used for abbreviations
+ uint revcnt; // Number of transition descr. for TIME->my_time_t conversion
+ /* The following are dynamical arrays are allocated in MEM_ROOT */
+ my_time_t *ats; // Times of transitions between time types
+ uchar *types; // Local time types for transitions
+ TRAN_TYPE_INFO *ttis; // Local time types descriptions
+#ifdef ABBR_ARE_USED
+ /* Storage for local time types abbreviations. They are stored as ASCIIZ */
+ char *chars;
+#endif
+ /*
+ Leap seconds corrections descriptions, this array is shared by
+ all time zones who use leap seconds.
+ */
+ LS_INFO *lsis;
+ /*
+ Starting points and descriptions of shifted my_time_t (my_time_t + offset)
+ ranges on which shifted my_time_t -> my_time_t mapping is linear or undefined.
+ Used for tm -> my_time_t conversion.
+ */
+ my_time_t *revts;
+ REVT_INFO *revtis;
+ /*
+ Time type which is used for times smaller than first transition or if
+ there are no transitions at all.
+ */
+ TRAN_TYPE_INFO *fallback_tti;
+
+} TIME_ZONE_INFO;
+
+
+static my_bool prepare_tz_info(TIME_ZONE_INFO *sp, MEM_ROOT *storage);
+
+my_bool opt_leap, opt_verbose, opt_skip_write_binlog;
+
+#if defined(TZINFO2SQL) || defined(TESTTIME)
+
+/*
+ Load time zone description from zoneinfo (TZinfo) file.
+
+ SYNOPSIS
+ tz_load()
+ name - path to zoneinfo file
+ sp - TIME_ZONE_INFO structure to fill
+
+ RETURN VALUES
+ 0 - Ok
+ 1 - Error
+*/
+static my_bool
+tz_load(const char *name, TIME_ZONE_INFO *sp, MEM_ROOT *storage)
+{
+ uchar *p;
+ ssize_t read_from_file;
+ uint i;
+ MYSQL_FILE *file;
+
+ if (!(file= mysql_file_fopen(0, name, O_RDONLY|O_BINARY, MYF(MY_WME))))
+ return 1;
+ {
+ union
+ {
+ struct tzhead tzhead;
+ uchar buf[sizeof(struct tzhead) + sizeof(my_time_t) * TZ_MAX_TIMES +
+ TZ_MAX_TIMES + sizeof(TRAN_TYPE_INFO) * TZ_MAX_TYPES +
+#ifdef ABBR_ARE_USED
+ MY_MAX(TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1))) +
+#endif
+ sizeof(LS_INFO) * TZ_MAX_LEAPS];
+ } u;
+ uint ttisstdcnt;
+ uint ttisgmtcnt;
+ char *tzinfo_buf;
+
+ read_from_file= (ssize_t)mysql_file_fread(file, u.buf, sizeof(u.buf), MYF(MY_WME));
+
+ if (mysql_file_fclose(file, MYF(MY_WME)) != 0)
+ return 1;
+
+ if (read_from_file < (int)sizeof(struct tzhead))
+ return 1;
+
+ ttisstdcnt= int4net(u.tzhead.tzh_ttisgmtcnt);
+ ttisgmtcnt= int4net(u.tzhead.tzh_ttisstdcnt);
+ sp->leapcnt= int4net(u.tzhead.tzh_leapcnt);
+ sp->timecnt= int4net(u.tzhead.tzh_timecnt);
+ sp->typecnt= int4net(u.tzhead.tzh_typecnt);
+ sp->charcnt= int4net(u.tzhead.tzh_charcnt);
+ p= u.tzhead.tzh_charcnt + sizeof(u.tzhead.tzh_charcnt);
+ if (sp->leapcnt > TZ_MAX_LEAPS ||
+ sp->typecnt == 0 || sp->typecnt > TZ_MAX_TYPES ||
+ sp->timecnt > TZ_MAX_TIMES ||
+ sp->charcnt > TZ_MAX_CHARS ||
+ (ttisstdcnt != sp->typecnt && ttisstdcnt != 0) ||
+ (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
+ return 1;
+ if ((uint)(read_from_file - (p - u.buf)) <
+ sp->timecnt * 4 + /* ats */
+ sp->timecnt + /* types */
+ sp->typecnt * (4 + 2) + /* ttinfos */
+ sp->charcnt + /* chars */
+ sp->leapcnt * (4 + 4) + /* lsinfos */
+ ttisstdcnt + /* ttisstds */
+ ttisgmtcnt) /* ttisgmts */
+ return 1;
+
+ if (!(tzinfo_buf= (char *)alloc_root(storage,
+ ALIGN_SIZE(sp->timecnt *
+ sizeof(my_time_t)) +
+ ALIGN_SIZE(sp->timecnt) +
+ ALIGN_SIZE(sp->typecnt *
+ sizeof(TRAN_TYPE_INFO)) +
+#ifdef ABBR_ARE_USED
+ ALIGN_SIZE(sp->charcnt+1) +
+#endif
+ sp->leapcnt * sizeof(LS_INFO))))
+ return 1;
+
+ sp->ats= (my_time_t *)tzinfo_buf;
+ tzinfo_buf+= ALIGN_SIZE(sp->timecnt * sizeof(my_time_t));
+ sp->types= (uchar *)tzinfo_buf;
+ tzinfo_buf+= ALIGN_SIZE(sp->timecnt);
+ sp->ttis= (TRAN_TYPE_INFO *)tzinfo_buf;
+ tzinfo_buf+= ALIGN_SIZE(sp->typecnt * sizeof(TRAN_TYPE_INFO));
+#ifdef ABBR_ARE_USED
+ sp->chars= tzinfo_buf;
+ tzinfo_buf+= ALIGN_SIZE(sp->charcnt+1);
+#endif
+ sp->lsis= (LS_INFO *)tzinfo_buf;
+
+ for (i= 0; i < sp->timecnt; i++, p+= 4)
+ sp->ats[i]= int4net(p);
+
+ for (i= 0; i < sp->timecnt; i++)
+ {
+ sp->types[i]= (uchar) *p++;
+ if (sp->types[i] >= sp->typecnt)
+ return 1;
+ }
+ for (i= 0; i < sp->typecnt; i++)
+ {
+ TRAN_TYPE_INFO * ttisp;
+
+ ttisp= &sp->ttis[i];
+ ttisp->tt_gmtoff= int4net(p);
+ p+= 4;
+ ttisp->tt_isdst= (uchar) *p++;
+ if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)
+ return 1;
+ ttisp->tt_abbrind= (uchar) *p++;
+ if (ttisp->tt_abbrind > sp->charcnt)
+ return 1;
+ }
+ for (i= 0; i < sp->charcnt; i++)
+ sp->chars[i]= *p++;
+ sp->chars[i]= '\0'; /* ensure '\0' at end */
+ for (i= 0; i < sp->leapcnt; i++)
+ {
+ LS_INFO *lsisp;
+
+ lsisp= &sp->lsis[i];
+ lsisp->ls_trans= int4net(p);
+ p+= 4;
+ lsisp->ls_corr= int4net(p);
+ p+= 4;
+ }
+ /*
+ Since we don't support POSIX style TZ definitions in variables we
+ don't read further like glibc or elsie code.
+ */
+ }
+
+ return prepare_tz_info(sp, storage);
+}
+#endif /* defined(TZINFO2SQL) || defined(TESTTIME) */
+
+
+/*
+ Finish preparation of time zone description for use in TIME_to_gmt_sec()
+ and gmt_sec_to_TIME() functions.
+
+ SYNOPSIS
+ prepare_tz_info()
+ sp - pointer to time zone description
+ storage - pointer to MEM_ROOT where arrays for map allocated
+
+ DESCRIPTION
+ First task of this function is to find fallback time type which will
+ be used if there are no transitions or we have moment in time before
+ any transitions.
+ Second task is to build "shifted my_time_t" -> my_time_t map used in
+ MYSQL_TIME -> my_time_t conversion.
+ Note: See description of TIME_to_gmt_sec() function first.
+ In order to perform MYSQL_TIME -> my_time_t conversion we need to build table
+ which defines "shifted by tz offset and leap seconds my_time_t" ->
+ my_time_t function which is almost the same (except ranges of ambiguity)
+ as reverse function to piecewise linear function used for my_time_t ->
+ "shifted my_time_t" conversion and which is also specified as table in
+ zoneinfo file or in our db (It is specified as start of time type ranges
+ and time type offsets). So basic idea is very simple - let us iterate
+ through my_time_t space from one point of discontinuity of my_time_t ->
+ "shifted my_time_t" function to another and build our approximation of
+ reverse function. (Actually we iterate through ranges on which
+ my_time_t -> "shifted my_time_t" is linear function).
+
+ RETURN VALUES
+ 0 Ok
+ 1 Error
+*/
+static my_bool
+prepare_tz_info(TIME_ZONE_INFO *sp, MEM_ROOT *storage)
+{
+ my_time_t cur_t= MY_TIME_T_MIN;
+ my_time_t cur_l, end_t, UNINIT_VAR(end_l);
+ my_time_t cur_max_seen_l= MY_TIME_T_MIN;
+ long cur_offset, cur_corr, cur_off_and_corr;
+ uint next_trans_idx, next_leap_idx;
+ uint i;
+ /*
+ Temporary arrays where we will store tables. Needed because
+ we don't know table sizes ahead. (Well we can estimate their
+ upper bound but this will take extra space.)
+ */
+ my_time_t revts[TZ_MAX_REV_RANGES];
+ REVT_INFO revtis[TZ_MAX_REV_RANGES];
+
+ /*
+ Let us setup fallback time type which will be used if we have not any
+ transitions or if we have moment of time before first transition.
+ We will find first non-DST local time type and use it (or use first
+ local time type if all of them are DST types).
+ */
+ for (i= 0; i < sp->typecnt && sp->ttis[i].tt_isdst; i++)
+ /* no-op */ ;
+ if (i == sp->typecnt)
+ i= 0;
+ sp->fallback_tti= &(sp->ttis[i]);
+
+
+ /*
+ Let us build shifted my_time_t -> my_time_t map.
+ */
+ sp->revcnt= 0;
+
+ /* Let us find initial offset */
+ if (sp->timecnt == 0 || cur_t < sp->ats[0])
+ {
+ /*
+ If we have not any transitions or t is before first transition we are using
+ already found fallback time type which index is already in i.
+ */
+ next_trans_idx= 0;
+ }
+ else
+ {
+ /* cur_t == sp->ats[0] so we found transition */
+ i= sp->types[0];
+ next_trans_idx= 1;
+ }
+
+ cur_offset= sp->ttis[i].tt_gmtoff;
+
+
+ /* let us find leap correction... unprobable, but... */
+ for (next_leap_idx= 0; next_leap_idx < sp->leapcnt &&
+ cur_t >= sp->lsis[next_leap_idx].ls_trans;
+ ++next_leap_idx)
+ continue;
+
+ if (next_leap_idx > 0)
+ cur_corr= sp->lsis[next_leap_idx - 1].ls_corr;
+ else
+ cur_corr= 0;
+
+ /* Iterate trough t space */
+ while (sp->revcnt < TZ_MAX_REV_RANGES - 1)
+ {
+ cur_off_and_corr= cur_offset - cur_corr;
+
+ /*
+ We assuming that cur_t could be only overflowed downwards,
+ we also assume that end_t won't be overflowed in this case.
+ */
+ if (cur_off_and_corr < 0 &&
+ cur_t < MY_TIME_T_MIN - cur_off_and_corr)
+ cur_t= MY_TIME_T_MIN - cur_off_and_corr;
+
+ cur_l= cur_t + cur_off_and_corr;
+
+ /*
+ Let us choose end_t as point before next time type change or leap
+ second correction.
+ */
+ end_t= MY_MIN((next_trans_idx < sp->timecnt) ? sp->ats[next_trans_idx] - 1:
+ MY_TIME_T_MAX,
+ (next_leap_idx < sp->leapcnt) ?
+ sp->lsis[next_leap_idx].ls_trans - 1: MY_TIME_T_MAX);
+ /*
+ again assuming that end_t can be overlowed only in positive side
+ we also assume that end_t won't be overflowed in this case.
+ */
+ if (cur_off_and_corr > 0 &&
+ end_t > MY_TIME_T_MAX - cur_off_and_corr)
+ end_t= MY_TIME_T_MAX - cur_off_and_corr;
+
+ end_l= end_t + cur_off_and_corr;
+
+
+ if (end_l > cur_max_seen_l)
+ {
+ /* We want special handling in the case of first range */
+ if (cur_max_seen_l == MY_TIME_T_MIN)
+ {
+ revts[sp->revcnt]= cur_l;
+ revtis[sp->revcnt].rt_offset= cur_off_and_corr;
+ revtis[sp->revcnt].rt_type= 0;
+ sp->revcnt++;
+ cur_max_seen_l= end_l;
+ }
+ else
+ {
+ if (cur_l > cur_max_seen_l + 1)
+ {
+ /* We have a spring time-gap and we are not at the first range */
+ revts[sp->revcnt]= cur_max_seen_l + 1;
+ revtis[sp->revcnt].rt_offset= revtis[sp->revcnt-1].rt_offset;
+ revtis[sp->revcnt].rt_type= 1;
+ sp->revcnt++;
+ if (sp->revcnt == TZ_MAX_TIMES + TZ_MAX_LEAPS + 1)
+ break; /* That was too much */
+ cur_max_seen_l= cur_l - 1;
+ }
+
+ /* Assume here end_l > cur_max_seen_l (because end_l>=cur_l) */
+
+ revts[sp->revcnt]= cur_max_seen_l + 1;
+ revtis[sp->revcnt].rt_offset= cur_off_and_corr;
+ revtis[sp->revcnt].rt_type= 0;
+ sp->revcnt++;
+ cur_max_seen_l= end_l;
+ }
+ }
+
+ if (end_t == MY_TIME_T_MAX ||
+ ((cur_off_and_corr > 0) &&
+ (end_t >= MY_TIME_T_MAX - cur_off_and_corr)))
+ /* end of t space */
+ break;
+
+ cur_t= end_t + 1;
+
+ /*
+ Let us find new offset and correction. Because of our choice of end_t
+ cur_t can only be point where new time type starts or/and leap
+ correction is performed.
+ */
+ if (sp->timecnt != 0 && cur_t >= sp->ats[0]) /* else reuse old offset */
+ if (next_trans_idx < sp->timecnt &&
+ cur_t == sp->ats[next_trans_idx])
+ {
+ /* We are at offset point */
+ cur_offset= sp->ttis[sp->types[next_trans_idx]].tt_gmtoff;
+ ++next_trans_idx;
+ }
+
+ if (next_leap_idx < sp->leapcnt &&
+ cur_t == sp->lsis[next_leap_idx].ls_trans)
+ {
+ /* we are at leap point */
+ cur_corr= sp->lsis[next_leap_idx].ls_corr;
+ ++next_leap_idx;
+ }
+ }
+
+ /* check if we have had enough space */
+ if (sp->revcnt == TZ_MAX_REV_RANGES - 1)
+ return 1;
+
+ /* set maximum end_l as finisher */
+ revts[sp->revcnt]= end_l;
+
+ /* Allocate arrays of proper size in sp and copy result there */
+ if (!(sp->revts= (my_time_t *)alloc_root(storage,
+ sizeof(my_time_t) * (sp->revcnt + 1))) ||
+ !(sp->revtis= (REVT_INFO *)alloc_root(storage,
+ sizeof(REVT_INFO) * sp->revcnt)))
+ return 1;
+
+ memcpy(sp->revts, revts, sizeof(my_time_t) * (sp->revcnt + 1));
+ memcpy(sp->revtis, revtis, sizeof(REVT_INFO) * sp->revcnt);
+
+ return 0;
+}
+
+
+#if !defined(TZINFO2SQL)
+
+static const uint mon_lengths[2][MONS_PER_YEAR]=
+{
+ { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
+ { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
+};
+
+static const uint mon_starts[2][MONS_PER_YEAR]=
+{
+ { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
+ { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
+};
+
+static const uint year_lengths[2]=
+{
+ DAYS_PER_NYEAR, DAYS_PER_LYEAR
+};
+
+#define LEAPS_THRU_END_OF(y) ((y) / 4 - (y) / 100 + (y) / 400)
+
+
+/*
+ Converts time from my_time_t representation (seconds in UTC since Epoch)
+ to broken down representation using given local time zone offset.
+
+ SYNOPSIS
+ sec_to_TIME()
+ tmp - pointer to structure for broken down representation
+ t - my_time_t value to be converted
+ offset - local time zone offset
+
+ DESCRIPTION
+ Convert my_time_t with offset to MYSQL_TIME struct. Differs from timesub
+ (from elsie code) because doesn't contain any leap correction and
+ TM_GMTOFF and is_dst setting and contains some MySQL specific
+ initialization. Funny but with removing of these we almost have
+ glibc's offtime function.
+*/
+static void
+sec_to_TIME(MYSQL_TIME * tmp, my_time_t t, long offset)
+{
+ long days;
+ long rem;
+ int y;
+ int yleap;
+ const uint *ip;
+
+ days= (long) (t / SECS_PER_DAY);
+ rem= (long) (t % SECS_PER_DAY);
+
+ /*
+ We do this as separate step after dividing t, because this
+ allows us handle times near my_time_t bounds without overflows.
+ */
+ rem+= offset;
+ while (rem < 0)
+ {
+ rem+= SECS_PER_DAY;
+ days--;
+ }
+ while (rem >= SECS_PER_DAY)
+ {
+ rem -= SECS_PER_DAY;
+ days++;
+ }
+ tmp->hour= (uint)(rem / SECS_PER_HOUR);
+ rem= rem % SECS_PER_HOUR;
+ tmp->minute= (uint)(rem / SECS_PER_MIN);
+ /*
+ A positive leap second requires a special
+ representation. This uses "... ??:59:60" et seq.
+ */
+ tmp->second= (uint)(rem % SECS_PER_MIN);
+
+ y= EPOCH_YEAR;
+ while (days < 0 || days >= (long)year_lengths[yleap= isleap(y)])
+ {
+ int newy;
+
+ newy= y + days / DAYS_PER_NYEAR;
+ if (days < 0)
+ newy--;
+ days-= (newy - y) * DAYS_PER_NYEAR +
+ LEAPS_THRU_END_OF(newy - 1) -
+ LEAPS_THRU_END_OF(y - 1);
+ y= newy;
+ }
+ tmp->year= y;
+
+ ip= mon_lengths[yleap];
+ for (tmp->month= 0; days >= (long) ip[tmp->month]; tmp->month++)
+ days= days - (long) ip[tmp->month];
+ tmp->month++;
+ tmp->day= (uint)(days + 1);
+
+ /* filling MySQL specific MYSQL_TIME members */
+ tmp->neg= 0; tmp->second_part= 0;
+ tmp->time_type= MYSQL_TIMESTAMP_DATETIME;
+}
+
+
+/*
+ Find time range which contains given my_time_t value
+
+ SYNOPSIS
+ find_time_range()
+ t - my_time_t value for which we looking for range
+ range_boundaries - sorted array of range starts.
+ higher_bound - number of ranges
+
+ DESCRIPTION
+ Performs binary search for range which contains given my_time_t value.
+ It has sense if number of ranges is greater than zero and my_time_t value
+ is greater or equal than beginning of first range. It also assumes that
+ t belongs to some range specified or end of last is MY_TIME_T_MAX.
+
+ With this localtime_r on real data may takes less time than with linear
+ search (I've seen 30% speed up).
+
+ RETURN VALUE
+ Index of range to which t belongs
+*/
+static uint
+find_time_range(my_time_t t, const my_time_t *range_boundaries,
+ uint higher_bound)
+{
+ uint i, lower_bound= 0;
+
+ /*
+ Function will work without this assertion but result would be meaningless.
+ */
+ DBUG_ASSERT(higher_bound > 0 && t >= range_boundaries[0]);
+
+ /*
+ Do binary search for minimal interval which contain t. We preserve:
+ range_boundaries[lower_bound] <= t < range_boundaries[higher_bound]
+ invariant and decrease this higher_bound - lower_bound gap twice
+ times on each step.
+ */
+
+ while (higher_bound - lower_bound > 1)
+ {
+ i= (lower_bound + higher_bound) >> 1;
+ if (range_boundaries[i] <= t)
+ lower_bound= i;
+ else
+ higher_bound= i;
+ }
+ return lower_bound;
+}
+
+/*
+ Find local time transition for given my_time_t.
+
+ SYNOPSIS
+ find_transition_type()
+ t - my_time_t value to be converted
+ sp - pointer to struct with time zone description
+
+ RETURN VALUE
+ Pointer to structure in time zone description describing
+ local time type for given my_time_t.
+*/
+static
+const TRAN_TYPE_INFO *
+find_transition_type(my_time_t t, const TIME_ZONE_INFO *sp)
+{
+ if (unlikely(sp->timecnt == 0 || t < sp->ats[0]))
+ {
+ /*
+ If we have not any transitions or t is before first transition let
+ us use fallback time type.
+ */
+ return sp->fallback_tti;
+ }
+
+ /*
+ Do binary search for minimal interval between transitions which
+ contain t. With this localtime_r on real data may takes less
+ time than with linear search (I've seen 30% speed up).
+ */
+ return &(sp->ttis[sp->types[find_time_range(t, sp->ats, sp->timecnt)]]);
+}
+
+
+/*
+ Converts time in my_time_t representation (seconds in UTC since Epoch) to
+ broken down MYSQL_TIME representation in local time zone.
+
+ SYNOPSIS
+ gmt_sec_to_TIME()
+ tmp - pointer to structure for broken down represenatation
+ sec_in_utc - my_time_t value to be converted
+ sp - pointer to struct with time zone description
+
+ TODO
+ We can improve this function by creating joined array of transitions and
+ leap corrections. This will require adding extra field to TRAN_TYPE_INFO
+ for storing number of "extra" seconds to minute occurred due to correction
+ (60th and 61st second, look how we calculate them as "hit" in this
+ function).
+ Under realistic assumptions about frequency of transitions the same array
+ can be used fot MYSQL_TIME -> my_time_t conversion. For this we need to
+ implement tweaked binary search which will take into account that some
+ MYSQL_TIME has two matching my_time_t ranges and some of them have none.
+*/
+static void
+gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t sec_in_utc, const TIME_ZONE_INFO *sp)
+{
+ const TRAN_TYPE_INFO *ttisp;
+ const LS_INFO *lp;
+ long corr= 0;
+ int hit= 0;
+ int i;
+
+ /*
+ Find proper transition (and its local time type) for our sec_in_utc value.
+ Funny but again by separating this step in function we receive code
+ which very close to glibc's code. No wonder since they obviously use
+ the same base and all steps are sensible.
+ */
+ ttisp= find_transition_type(sec_in_utc, sp);
+
+ /*
+ Let us find leap correction for our sec_in_utc value and number of extra
+ secs to add to this minute.
+ This loop is rarely used because most users will use time zones without
+ leap seconds, and even in case when we have such time zone there won't
+ be many iterations (we have about 22 corrections at this moment (2004)).
+ */
+ for ( i= sp->leapcnt; i-- > 0; )
+ {
+ lp= &sp->lsis[i];
+ if (sec_in_utc >= lp->ls_trans)
+ {
+ if (sec_in_utc == lp->ls_trans)
+ {
+ hit= ((i == 0 && lp->ls_corr > 0) ||
+ lp->ls_corr > sp->lsis[i - 1].ls_corr);
+ if (hit)
+ {
+ while (i > 0 &&
+ sp->lsis[i].ls_trans == sp->lsis[i - 1].ls_trans + 1 &&
+ sp->lsis[i].ls_corr == sp->lsis[i - 1].ls_corr + 1)
+ {
+ hit++;
+ i--;
+ }
+ }
+ }
+ corr= lp->ls_corr;
+ break;
+ }
+ }
+
+ sec_to_TIME(tmp, sec_in_utc, ttisp->tt_gmtoff - corr);
+
+ tmp->second+= hit;
+}
+
+
+/*
+ Converts local time in broken down representation to local
+ time zone analog of my_time_t represenation.
+
+ SYNOPSIS
+ sec_since_epoch()
+ year, mon, mday, hour, min, sec - broken down representation.
+
+ DESCRIPTION
+ Converts time in broken down representation to my_time_t representation
+ ignoring time zone. Note that we cannot convert back some valid _local_
+ times near ends of my_time_t range because of my_time_t overflow. But we
+ ignore this fact now since MySQL will never pass such argument.
+
+ RETURN VALUE
+ Seconds since epoch time representation.
+*/
+static my_time_t
+sec_since_epoch(int year, int mon, int mday, int hour, int min ,int sec)
+{
+ /* Guard against my_time_t overflow(on system with 32 bit my_time_t) */
+ DBUG_ASSERT(!(year == TIMESTAMP_MAX_YEAR && mon == 1 && mday > 17));
+#ifndef WE_WANT_TO_HANDLE_UNORMALIZED_DATES
+ /*
+ It turns out that only whenever month is normalized or unnormalized
+ plays role.
+ */
+ DBUG_ASSERT(mon > 0 && mon < 13);
+ long days= year * DAYS_PER_NYEAR - EPOCH_YEAR * DAYS_PER_NYEAR +
+ LEAPS_THRU_END_OF(year - 1) -
+ LEAPS_THRU_END_OF(EPOCH_YEAR - 1);
+ days+= mon_starts[isleap(year)][mon - 1];
+#else
+ long norm_month= (mon - 1) % MONS_PER_YEAR;
+ long a_year= year + (mon - 1)/MONS_PER_YEAR - (int)(norm_month < 0);
+ long days= a_year * DAYS_PER_NYEAR - EPOCH_YEAR * DAYS_PER_NYEAR +
+ LEAPS_THRU_END_OF(a_year - 1) -
+ LEAPS_THRU_END_OF(EPOCH_YEAR - 1);
+ days+= mon_starts[isleap(a_year)]
+ [norm_month + (norm_month < 0 ? MONS_PER_YEAR : 0)];
+#endif
+ days+= mday - 1;
+
+ return ((days * HOURS_PER_DAY + hour) * MINS_PER_HOUR + min) *
+ SECS_PER_MIN + sec;
+}
+
+/*
+ Converts local time in broken down MYSQL_TIME representation to my_time_t
+ representation.
+
+ SYNOPSIS
+ TIME_to_gmt_sec()
+ t - pointer to structure for broken down represenatation
+ sp - pointer to struct with time zone description
+ error_code - 0, if the conversion was successful;
+ ER_WARN_DATA_OUT_OF_RANGE, if t contains datetime value
+ which is out of TIMESTAMP range;
+ ER_WARN_INVALID_TIMESTAMP, if t represents value which
+ doesn't exists (falls into the spring time-gap).
+
+ DESCRIPTION
+ This is mktime analog for MySQL. It is essentially different
+ from mktime (or hypotetical my_mktime) because:
+ - It has no idea about tm_isdst member so if it
+ has two answers it will give the smaller one
+ - If we are in spring time gap then it will return
+ beginning of the gap
+ - It can give wrong results near the ends of my_time_t due to
+ overflows, but we are safe since in MySQL we will never
+ call this function for such dates (its restriction for year
+ between 1970 and 2038 gives us several days of reserve).
+ - By default it doesn't support un-normalized input. But if
+ sec_since_epoch() function supports un-normalized dates
+ then this function should handle un-normalized input right,
+ altough it won't normalize structure TIME.
+
+ Traditional approach to problem of conversion from broken down
+ representation to time_t is iterative. Both elsie's and glibc
+ implementation try to guess what time_t value should correspond to
+ this broken-down value. They perform localtime_r function on their
+ guessed value and then calculate the difference and try to improve
+ their guess. Elsie's code guesses time_t value in bit by bit manner,
+ Glibc's code tries to add difference between broken-down value
+ corresponding to guess and target broken-down value to current guess.
+ It also uses caching of last found correction... So Glibc's approach
+ is essentially faster but introduces some undetermenism (in case if
+ is_dst member of broken-down representation (tm struct) is not known
+ and we have two possible answers).
+
+ We use completely different approach. It is better since it is both
+ faster than iterative implementations and fully determenistic. If you
+ look at my_time_t to MYSQL_TIME conversion then you'll find that it consist
+ of two steps:
+ The first is calculating shifted my_time_t value and the second - TIME
+ calculation from shifted my_time_t value (well it is a bit simplified
+ picture). The part in which we are interested in is my_time_t -> shifted
+ my_time_t conversion. It is piecewise linear function which is defined
+ by combination of transition times as break points and times offset
+ as changing function parameter. The possible inverse function for this
+ converison would be ambiguos but with MySQL's restrictions we can use
+ some function which is the same as inverse function on unambigiuos
+ ranges and coincides with one of branches of inverse function in
+ other ranges. Thus we just need to build table which will determine
+ this shifted my_time_t -> my_time_t conversion similar to existing
+ (my_time_t -> shifted my_time_t table). We do this in
+ prepare_tz_info function.
+
+ TODO
+ If we can even more improve this function. For doing this we will need to
+ build joined map of transitions and leap corrections for gmt_sec_to_TIME()
+ function (similar to revts/revtis). Under realistic assumptions about
+ frequency of transitions we can use the same array for TIME_to_gmt_sec().
+ We need to implement special version of binary search for this. Such step
+ will be beneficial to CPU cache since we will decrease data-set used for
+ conversion twice.
+
+ RETURN VALUE
+ Seconds in UTC since Epoch.
+ 0 in case of error.
+*/
+
+static my_time_t
+TIME_to_gmt_sec(const MYSQL_TIME *t, const TIME_ZONE_INFO *sp, uint *error_code)
+{
+ my_time_t local_t;
+ uint saved_seconds;
+ uint i;
+ int shift= 0;
+ DBUG_ENTER("TIME_to_gmt_sec");
+
+ if (!validate_timestamp_range(t))
+ {
+ *error_code= ER_WARN_DATA_OUT_OF_RANGE;
+ DBUG_RETURN(0);
+ }
+
+ *error_code= 0;
+
+ /* We need this for correct leap seconds handling */
+ if (t->second < SECS_PER_MIN)
+ saved_seconds= 0;
+ else
+ saved_seconds= t->second;
+
+ /*
+ NOTE: to convert full my_time_t range we do a shift of the
+ boundary dates here to avoid overflow of my_time_t.
+ We use alike approach in my_system_gmt_sec().
+
+ However in that function we also have to take into account
+ overflow near 0 on some platforms. That's because my_system_gmt_sec
+ uses localtime_r(), which doesn't work with negative values correctly
+ on platforms with unsigned time_t (QNX). Here we don't use localtime()
+ => we negative values of local_t are ok.
+ */
+
+ if ((t->year == TIMESTAMP_MAX_YEAR) && (t->month == 1) && t->day > 4)
+ {
+ /*
+ We will pass (t->day - shift) to sec_since_epoch(), and
+ want this value to be a positive number, so we shift
+ only dates > 4.01.2038 (to avoid owerflow).
+ */
+ shift= 2;
+ }
+
+
+ local_t= sec_since_epoch(t->year, t->month, (t->day - shift),
+ t->hour, t->minute,
+ saved_seconds ? 0 : t->second);
+
+ /* We have at least one range */
+ DBUG_ASSERT(sp->revcnt >= 1);
+
+ if (local_t < sp->revts[0] || local_t > sp->revts[sp->revcnt])
+ {
+ /*
+ This means that source time can't be represented as my_time_t due to
+ limited my_time_t range.
+ */
+ *error_code= ER_WARN_DATA_OUT_OF_RANGE;
+ DBUG_RETURN(0);
+ }
+
+ /* binary search for our range */
+ i= find_time_range(local_t, sp->revts, sp->revcnt);
+
+ /*
+ As there are no offset switches at the end of TIMESTAMP range,
+ we could simply check for overflow here (and don't need to bother
+ about DST gaps etc)
+ */
+ if (shift)
+ {
+ if (local_t > (my_time_t) (TIMESTAMP_MAX_VALUE - shift * SECS_PER_DAY +
+ sp->revtis[i].rt_offset - saved_seconds))
+ {
+ *error_code= ER_WARN_DATA_OUT_OF_RANGE;
+ DBUG_RETURN(0); /* my_time_t overflow */
+ }
+ local_t+= shift * SECS_PER_DAY;
+ }
+
+ if (sp->revtis[i].rt_type)
+ {
+ /*
+ Oops! We are in spring time gap.
+ May be we should return error here?
+ Now we are returning my_time_t value corresponding to the
+ beginning of the gap.
+ */
+ *error_code= ER_WARN_INVALID_TIMESTAMP;
+ local_t= sp->revts[i] - sp->revtis[i].rt_offset + saved_seconds;
+ }
+ else
+ local_t= local_t - sp->revtis[i].rt_offset + saved_seconds;
+
+ /* check for TIMESTAMP_MAX_VALUE was already done above */
+ if (local_t < TIMESTAMP_MIN_VALUE)
+ {
+ local_t= 0;
+ *error_code= ER_WARN_DATA_OUT_OF_RANGE;
+ }
+
+ DBUG_RETURN(local_t);
+}
+
+
+/*
+ End of elsie derived code.
+*/
+#endif /* !defined(TZINFO2SQL) */
+
+
+#if !defined(TESTTIME) && !defined(TZINFO2SQL)
+
+/*
+ String with names of SYSTEM time zone.
+*/
+static const String tz_SYSTEM_name("SYSTEM", 6, &my_charset_latin1);
+
+
+/*
+ Instance of this class represents local time zone used on this system
+ (specified by TZ environment variable or via any other system mechanism).
+ It uses system functions (localtime_r, my_system_gmt_sec) for conversion
+ and is always available. Because of this it is used by default - if there
+ were no explicit time zone specified. On the other hand because of this
+ conversion methods provided by this class is significantly slower and
+ possibly less multi-threaded-friendly than corresponding Time_zone_db
+ methods so the latter should be preffered there it is possible.
+*/
+class Time_zone_system : public Time_zone
+{
+public:
+ Time_zone_system() {} /* Remove gcc warning */
+ virtual my_time_t TIME_to_gmt_sec(const MYSQL_TIME *t, uint *error_code) const;
+ virtual void gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const;
+ virtual const String * get_name() const;
+};
+
+
+/*
+ Converts local time in system time zone in MYSQL_TIME representation
+ to its my_time_t representation.
+
+ SYNOPSIS
+ TIME_to_gmt_sec()
+ t - pointer to MYSQL_TIME structure with local time in
+ broken-down representation.
+ error_code - 0, if the conversion was successful;
+ ER_WARN_DATA_OUT_OF_RANGE, if t contains datetime value
+ which is out of TIMESTAMP range;
+ ER_WARN_INVALID_TIMESTAMP, if t represents value which
+ doesn't exists (falls into the spring time-gap).
+
+ DESCRIPTION
+ This method uses system function (localtime_r()) for conversion
+ local time in system time zone in MYSQL_TIME structure to its my_time_t
+ representation. Unlike the same function for Time_zone_db class
+ it it won't handle unnormalized input properly. Still it will
+ return lowest possible my_time_t in case of ambiguity or if we
+ provide time corresponding to the time-gap.
+
+ You should call my_init_time() function before using this function.
+
+ RETURN VALUE
+ Corresponding my_time_t value or 0 in case of error
+*/
+my_time_t
+Time_zone_system::TIME_to_gmt_sec(const MYSQL_TIME *t, uint *error_code) const
+{
+ long not_used;
+ return my_system_gmt_sec(t, &not_used, error_code);
+}
+
+
+/*
+ Converts time from UTC seconds since Epoch (my_time_t) representation
+ to system local time zone broken-down representation.
+
+ SYNOPSIS
+ gmt_sec_to_TIME()
+ tmp - pointer to MYSQL_TIME structure to fill-in
+ t - my_time_t value to be converted
+
+ NOTE
+ We assume that value passed to this function will fit into time_t range
+ supported by localtime_r. This conversion is putting restriction on
+ TIMESTAMP range in MySQL. If we can get rid of SYSTEM time zone at least
+ for interaction with client then we can extend TIMESTAMP range down to
+ the 1902 easily.
+*/
+void
+Time_zone_system::gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const
+{
+ struct tm tmp_tm;
+ time_t tmp_t= (time_t)t;
+
+ localtime_r(&tmp_t, &tmp_tm);
+ localtime_to_TIME(tmp, &tmp_tm);
+ tmp->time_type= MYSQL_TIMESTAMP_DATETIME;
+ adjust_leap_second(tmp);
+}
+
+
+/*
+ Get name of time zone
+
+ SYNOPSIS
+ get_name()
+
+ RETURN VALUE
+ Name of time zone as String
+*/
+const String *
+Time_zone_system::get_name() const
+{
+ return &tz_SYSTEM_name;
+}
+
+
+/*
+ Instance of this class represents UTC time zone. It uses system gmtime_r
+ function for conversions and is always available. It is used only for
+ my_time_t -> MYSQL_TIME conversions in various UTC_... functions, it is not
+ intended for MYSQL_TIME -> my_time_t conversions and shouldn't be exposed to user.
+*/
+class Time_zone_utc : public Time_zone
+{
+public:
+ Time_zone_utc() {} /* Remove gcc warning */
+ virtual my_time_t TIME_to_gmt_sec(const MYSQL_TIME *t,
+ uint *error_code) const;
+ virtual void gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const;
+ virtual const String * get_name() const;
+};
+
+
+/*
+ Convert UTC time from MYSQL_TIME representation to its my_time_t representation.
+
+ DESCRIPTION
+ Since Time_zone_utc is used only internally for my_time_t -> TIME
+ conversions, this function of Time_zone interface is not implemented for
+ this class and should not be called.
+
+ RETURN VALUE
+ 0
+*/
+my_time_t
+Time_zone_utc::TIME_to_gmt_sec(const MYSQL_TIME *t, uint *error_code) const
+{
+ /* Should be never called */
+ DBUG_ASSERT(0);
+ *error_code= ER_WARN_DATA_OUT_OF_RANGE;
+ return 0;
+}
+
+
+/*
+ Converts time from UTC seconds since Epoch (my_time_t) representation
+ to broken-down representation (also in UTC).
+
+ SYNOPSIS
+ gmt_sec_to_TIME()
+ tmp - pointer to MYSQL_TIME structure to fill-in
+ t - my_time_t value to be converted
+
+ NOTE
+ See note for apropriate Time_zone_system method.
+*/
+void
+Time_zone_utc::gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const
+{
+ struct tm tmp_tm;
+ time_t tmp_t= (time_t)t;
+ gmtime_r(&tmp_t, &tmp_tm);
+ localtime_to_TIME(tmp, &tmp_tm);
+ tmp->time_type= MYSQL_TIMESTAMP_DATETIME;
+ adjust_leap_second(tmp);
+}
+
+
+/*
+ Get name of time zone
+
+ SYNOPSIS
+ get_name()
+
+ DESCRIPTION
+ Since Time_zone_utc is used only internally by SQL's UTC_* functions it
+ is not accessible directly, and hence this function of Time_zone
+ interface is not implemented for this class and should not be called.
+
+ RETURN VALUE
+ 0
+*/
+const String *
+Time_zone_utc::get_name() const
+{
+ /* Should be never called */
+ DBUG_ASSERT(0);
+ return 0;
+}
+
+
+/*
+ Instance of this class represents some time zone which is
+ described in mysql.time_zone family of tables.
+*/
+class Time_zone_db : public Time_zone
+{
+public:
+ Time_zone_db(TIME_ZONE_INFO *tz_info_arg, const String * tz_name_arg);
+ virtual my_time_t TIME_to_gmt_sec(const MYSQL_TIME *t, uint *error_code) const;
+ virtual void gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const;
+ virtual const String * get_name() const;
+private:
+ TIME_ZONE_INFO *tz_info;
+ const String *tz_name;
+};
+
+
+/*
+ Initializes object representing time zone described by mysql.time_zone
+ tables.
+
+ SYNOPSIS
+ Time_zone_db()
+ tz_info_arg - pointer to TIME_ZONE_INFO structure which is filled
+ according to db or other time zone description
+ (for example by my_tz_init()).
+ Several Time_zone_db instances can share one
+ TIME_ZONE_INFO structure.
+ tz_name_arg - name of time zone.
+*/
+Time_zone_db::Time_zone_db(TIME_ZONE_INFO *tz_info_arg,
+ const String *tz_name_arg):
+ tz_info(tz_info_arg), tz_name(tz_name_arg)
+{
+}
+
+
+/*
+ Converts local time in time zone described from TIME
+ representation to its my_time_t representation.
+
+ SYNOPSIS
+ TIME_to_gmt_sec()
+ t - pointer to MYSQL_TIME structure with local time
+ in broken-down representation.
+ error_code - 0, if the conversion was successful;
+ ER_WARN_DATA_OUT_OF_RANGE, if t contains datetime value
+ which is out of TIMESTAMP range;
+ ER_WARN_INVALID_TIMESTAMP, if t represents value which
+ doesn't exists (falls into the spring time-gap).
+
+ DESCRIPTION
+ Please see ::TIME_to_gmt_sec for function description and
+ parameter restrictions.
+
+ RETURN VALUE
+ Corresponding my_time_t value or 0 in case of error
+*/
+my_time_t
+Time_zone_db::TIME_to_gmt_sec(const MYSQL_TIME *t, uint *error_code) const
+{
+ return ::TIME_to_gmt_sec(t, tz_info, error_code);
+}
+
+
+/*
+ Converts time from UTC seconds since Epoch (my_time_t) representation
+ to local time zone described in broken-down representation.
+
+ SYNOPSIS
+ gmt_sec_to_TIME()
+ tmp - pointer to MYSQL_TIME structure to fill-in
+ t - my_time_t value to be converted
+*/
+void
+Time_zone_db::gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const
+{
+ ::gmt_sec_to_TIME(tmp, t, tz_info);
+ adjust_leap_second(tmp);
+}
+
+
+/*
+ Get name of time zone
+
+ SYNOPSIS
+ get_name()
+
+ RETURN VALUE
+ Name of time zone as ASCIIZ-string
+*/
+const String *
+Time_zone_db::get_name() const
+{
+ return tz_name;
+}
+
+
+/*
+ Instance of this class represents time zone which
+ was specified as offset from UTC.
+*/
+class Time_zone_offset : public Time_zone
+{
+public:
+ Time_zone_offset(long tz_offset_arg);
+ virtual my_time_t TIME_to_gmt_sec(const MYSQL_TIME *t,
+ uint *error_code) const;
+ virtual void gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const;
+ virtual const String * get_name() const;
+ /*
+ This have to be public because we want to be able to access it from
+ my_offset_tzs_get_key() function
+ */
+ long offset;
+private:
+ /* Extra reserve because of snprintf */
+ char name_buff[7+16];
+ String name;
+};
+
+
+/*
+ Initializes object representing time zone described by its offset from UTC.
+
+ SYNOPSIS
+ Time_zone_offset()
+ tz_offset_arg - offset from UTC in seconds.
+ Positive for direction to east.
+*/
+Time_zone_offset::Time_zone_offset(long tz_offset_arg):
+ offset(tz_offset_arg)
+{
+ uint hours= abs((int)(offset / SECS_PER_HOUR));
+ uint minutes= abs((int)(offset % SECS_PER_HOUR / SECS_PER_MIN));
+ size_t length= my_snprintf(name_buff, sizeof(name_buff), "%s%02d:%02d",
+ (offset>=0) ? "+" : "-", hours, minutes);
+ name.set(name_buff, length, &my_charset_latin1);
+}
+
+
+/*
+ Converts local time in time zone described as offset from UTC
+ from MYSQL_TIME representation to its my_time_t representation.
+
+ SYNOPSIS
+ TIME_to_gmt_sec()
+ t - pointer to MYSQL_TIME structure with local time
+ in broken-down representation.
+ error_code - 0, if the conversion was successful;
+ ER_WARN_DATA_OUT_OF_RANGE, if t contains datetime value
+ which is out of TIMESTAMP range;
+ ER_WARN_INVALID_TIMESTAMP, if t represents value which
+ doesn't exists (falls into the spring time-gap).
+
+ RETURN VALUE
+ Corresponding my_time_t value or 0 in case of error.
+*/
+
+my_time_t
+Time_zone_offset::TIME_to_gmt_sec(const MYSQL_TIME *t, uint *error_code) const
+{
+ my_time_t local_t;
+ int shift= 0;
+
+ /*
+ Check timestamp range.we have to do this as calling function relies on
+ us to make all validation checks here.
+ */
+ if (!validate_timestamp_range(t))
+ {
+ *error_code= ER_WARN_DATA_OUT_OF_RANGE;
+ return 0;
+ }
+ *error_code= 0;
+
+ /*
+ Do a temporary shift of the boundary dates to avoid
+ overflow of my_time_t if the time value is near it's
+ maximum range
+ */
+ if ((t->year == TIMESTAMP_MAX_YEAR) && (t->month == 1) && t->day > 4)
+ shift= 2;
+
+ local_t= sec_since_epoch(t->year, t->month, (t->day - shift),
+ t->hour, t->minute, t->second) -
+ offset;
+
+ if (shift)
+ {
+ /* Add back the shifted time */
+ local_t+= shift * SECS_PER_DAY;
+ }
+
+ if (local_t >= TIMESTAMP_MIN_VALUE && local_t <= TIMESTAMP_MAX_VALUE)
+ return local_t;
+
+ /* range error*/
+ *error_code= ER_WARN_DATA_OUT_OF_RANGE;
+ return 0;
+}
+
+
+/*
+ Converts time from UTC seconds since Epoch (my_time_t) representation
+ to local time zone described as offset from UTC and in broken-down
+ representation.
+
+ SYNOPSIS
+ gmt_sec_to_TIME()
+ tmp - pointer to MYSQL_TIME structure to fill-in
+ t - my_time_t value to be converted
+*/
+void
+Time_zone_offset::gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t t) const
+{
+ sec_to_TIME(tmp, t, offset);
+}
+
+
+/*
+ Get name of time zone
+
+ SYNOPSIS
+ get_name()
+
+ RETURN VALUE
+ Name of time zone as pointer to String object
+*/
+const String *
+Time_zone_offset::get_name() const
+{
+ return &name;
+}
+
+
+static Time_zone_utc tz_UTC;
+static Time_zone_system tz_SYSTEM;
+static Time_zone_offset tz_OFFSET0(0);
+
+Time_zone *my_tz_OFFSET0= &tz_OFFSET0;
+Time_zone *my_tz_UTC= &tz_UTC;
+Time_zone *my_tz_SYSTEM= &tz_SYSTEM;
+
+static HASH tz_names;
+static HASH offset_tzs;
+static MEM_ROOT tz_storage;
+
+/*
+ These mutex protects offset_tzs and tz_storage.
+ These protection needed only when we are trying to set
+ time zone which is specified as offset, and searching for existing
+ time zone in offset_tzs or creating if it didn't existed before in
+ tz_storage. So contention is low.
+*/
+static mysql_mutex_t tz_LOCK;
+static bool tz_inited= 0;
+
+/*
+ This two static variables are inteded for holding info about leap seconds
+ shared by all time zones.
+*/
+static uint tz_leapcnt= 0;
+static LS_INFO *tz_lsis= 0;
+
+/*
+ Shows whenever we have found time zone tables during start-up.
+ Used for avoiding of putting those tables to global table list
+ for queries that use time zone info.
+*/
+static bool time_zone_tables_exist= 1;
+
+
+/*
+ Names of tables (with their lengths) that are needed
+ for dynamical loading of time zone descriptions.
+*/
+
+static const LEX_CSTRING tz_tables_names[MY_TZ_TABLES_COUNT]=
+{
+ { STRING_WITH_LEN("time_zone_name")},
+ { STRING_WITH_LEN("time_zone")},
+ { STRING_WITH_LEN("time_zone_transition_type")},
+ { STRING_WITH_LEN("time_zone_transition")}
+};
+
+class Tz_names_entry: public Sql_alloc
+{
+public:
+ String name;
+ Time_zone *tz;
+};
+
+
+/*
+ We are going to call both of these functions from C code so
+ they should obey C calling conventions.
+*/
+
+extern "C" uchar *
+my_tz_names_get_key(Tz_names_entry *entry, size_t *length,
+ my_bool not_used __attribute__((unused)))
+{
+ *length= entry->name.length();
+ return (uchar*) entry->name.ptr();
+}
+
+extern "C" uchar *
+my_offset_tzs_get_key(Time_zone_offset *entry,
+ size_t *length,
+ my_bool not_used __attribute__((unused)))
+{
+ *length= sizeof(long);
+ return (uchar*) &entry->offset;
+}
+
+
+/*
+ Prepare table list with time zone related tables from preallocated array.
+
+ SYNOPSIS
+ tz_init_table_list()
+ tz_tabs - pointer to preallocated array of MY_TZ_TABLES_COUNT
+ TABLE_LIST objects
+
+ DESCRIPTION
+ This function prepares list of TABLE_LIST objects which can be used
+ for opening of time zone tables from preallocated array.
+*/
+
+static void
+tz_init_table_list(TABLE_LIST *tz_tabs)
+{
+ for (int i= 0; i < MY_TZ_TABLES_COUNT; i++)
+ {
+ tz_tabs[i].init_one_table(&MYSQL_SCHEMA_NAME, tz_tables_names + i,
+ NULL, TL_READ);
+ if (i != MY_TZ_TABLES_COUNT - 1)
+ tz_tabs[i].next_global= tz_tabs[i].next_local= &tz_tabs[i+1];
+ if (i != 0)
+ tz_tabs[i].prev_global= &tz_tabs[i-1].next_global;
+ }
+}
+
+static PSI_memory_key key_memory_tz_storage;
+
+#ifdef HAVE_PSI_INTERFACE
+static PSI_mutex_key key_tz_LOCK;
+
+static PSI_mutex_info all_tz_mutexes[]=
+{
+ { & key_tz_LOCK, "tz_LOCK", PSI_FLAG_GLOBAL}
+};
+
+static PSI_memory_info all_tz_memory[]=
+{
+ { &key_memory_tz_storage, "tz_storage", PSI_FLAG_GLOBAL}
+};
+
+static void init_tz_psi_keys(void)
+{
+ const char* category= "sql";
+ int count;
+
+ if (PSI_server == NULL)
+ return;
+
+ count= array_elements(all_tz_mutexes);
+ PSI_server->register_mutex(category, all_tz_mutexes, count);
+
+ count= array_elements(all_tz_memory);
+ mysql_memory_register(category, all_tz_memory, count);
+}
+#endif /* HAVE_PSI_INTERFACE */
+
+
+/*
+ Initialize time zone support infrastructure.
+
+ SYNOPSIS
+ my_tz_init()
+ thd - current thread object
+ default_tzname - default time zone or 0 if none.
+ bootstrap - indicates whenever we are in bootstrap mode
+
+ DESCRIPTION
+ This function will init memory structures needed for time zone support,
+ it will register mandatory SYSTEM time zone in them. It will try to open
+ mysql.time_zone* tables and load information about default time zone and
+ information which further will be shared among all time zones loaded.
+ If system tables with time zone descriptions don't exist it won't fail
+ (unless default_tzname is time zone from tables). If bootstrap parameter
+ is true then this routine assumes that we are in bootstrap mode and won't
+ load time zone descriptions unless someone specifies default time zone
+ which is supposedly stored in those tables.
+ It'll also set default time zone if it is specified.
+
+ RETURN VALUES
+ 0 - ok
+ 1 - Error
+*/
+my_bool
+my_tz_init(THD *org_thd, const char *default_tzname, my_bool bootstrap)
+{
+ THD *thd;
+ TABLE_LIST tz_tables[1+MY_TZ_TABLES_COUNT];
+ TABLE *table;
+ const LEX_CSTRING tmp_table_name= { STRING_WITH_LEN("time_zone_leap_second") };
+ Tz_names_entry *tmp_tzname;
+ my_bool return_val= 1;
+ int res;
+ DBUG_ENTER("my_tz_init");
+
+#ifdef HAVE_PSI_INTERFACE
+ init_tz_psi_keys();
+#endif
+
+ /*
+ To be able to run this from boot, we allocate a temporary THD
+ */
+ if (!(thd= new THD(0)))
+ DBUG_RETURN(1);
+ thd->thread_stack= (char*) &thd;
+ thd->store_globals();
+
+ /* Init all memory structures that require explicit destruction */
+ if (my_hash_init(key_memory_tz_storage, &tz_names, &my_charset_latin1, 20, 0,
+ 0, (my_hash_get_key) my_tz_names_get_key, 0, 0))
+ {
+ sql_print_error("Fatal error: OOM while initializing time zones");
+ goto end;
+ }
+ if (my_hash_init(key_memory_tz_storage, &offset_tzs, &my_charset_latin1, 26,
+ 0, 0, (my_hash_get_key)my_offset_tzs_get_key, 0, 0))
+ {
+ sql_print_error("Fatal error: OOM while initializing time zones");
+ my_hash_free(&tz_names);
+ goto end;
+ }
+ init_sql_alloc(key_memory_tz_storage, &tz_storage, 32 * 1024, 0, MYF(0));
+ mysql_mutex_init(key_tz_LOCK, &tz_LOCK, MY_MUTEX_INIT_FAST);
+ tz_inited= 1;
+
+ /* Add 'SYSTEM' time zone to tz_names hash */
+ if (!(tmp_tzname= new (&tz_storage) Tz_names_entry()))
+ {
+ sql_print_error("Fatal error: OOM while initializing time zones");
+ goto end_with_cleanup;
+ }
+ tmp_tzname->name.set(STRING_WITH_LEN("SYSTEM"), &my_charset_latin1);
+ tmp_tzname->tz= my_tz_SYSTEM;
+ if (my_hash_insert(&tz_names, (const uchar *)tmp_tzname))
+ {
+ sql_print_error("Fatal error: OOM while initializing time zones");
+ goto end_with_cleanup;
+ }
+
+ if (bootstrap)
+ {
+ /* If we are in bootstrap mode we should not load time zone tables */
+ return_val= time_zone_tables_exist= 0;
+ goto end_with_cleanup;
+ }
+
+ /*
+ After this point all memory structures are inited and we even can live
+ without time zone description tables. Now try to load information about
+ leap seconds shared by all time zones.
+ */
+
+ thd->set_db(&MYSQL_SCHEMA_NAME);
+ bzero((char*) &tz_tables[0], sizeof(TABLE_LIST));
+ tz_tables[0].alias= tz_tables[0].table_name= tmp_table_name;
+ tz_tables[0].db= MYSQL_SCHEMA_NAME;
+ tz_tables[0].lock_type= TL_READ;
+
+ tz_init_table_list(tz_tables+1);
+ tz_tables[0].next_global= tz_tables[0].next_local= &tz_tables[1];
+ tz_tables[1].prev_global= &tz_tables[0].next_global;
+ init_mdl_requests(tz_tables);
+
+ /*
+ We need to open only mysql.time_zone_leap_second, but we try to
+ open all time zone tables to see if they exist.
+ */
+ if (open_and_lock_tables(thd, tz_tables, FALSE,
+ MYSQL_OPEN_IGNORE_FLUSH | MYSQL_LOCK_IGNORE_TIMEOUT))
+ {
+ sql_print_warning("Can't open and lock time zone table: %s "
+ "trying to live without them",
+ thd->get_stmt_da()->message());
+ /* We will try emulate that everything is ok */
+ return_val= time_zone_tables_exist= 0;
+ goto end_with_setting_default_tz;
+ }
+
+ for (TABLE_LIST *tl= tz_tables; tl; tl= tl->next_global)
+ {
+ tl->table->use_all_columns();
+ /* Force close at the end of the function to free memory. */
+ tl->table->mark_table_for_reopen();
+ }
+
+ /*
+ Now we are going to load leap seconds descriptions that are shared
+ between all time zones that use them. We are using index for getting
+ records in proper order. Since we share the same MEM_ROOT between
+ all time zones we just allocate enough memory for it first.
+ */
+ if (!(tz_lsis= (LS_INFO*) alloc_root(&tz_storage,
+ sizeof(LS_INFO) * TZ_MAX_LEAPS)))
+ {
+ sql_print_error("Fatal error: Out of memory while loading "
+ "mysql.time_zone_leap_second table");
+ goto end_with_close;
+ }
+
+ table= tz_tables[0].table;
+
+ if (table->file->ha_index_init(0, 1))
+ goto end_with_close;
+
+ table->use_all_columns();
+ tz_leapcnt= 0;
+
+ res= table->file->ha_index_first(table->record[0]);
+
+ while (!res)
+ {
+ if (tz_leapcnt + 1 > TZ_MAX_LEAPS)
+ {
+ sql_print_error("Fatal error: While loading mysql.time_zone_leap_second"
+ " table: too much leaps");
+ table->file->ha_index_end();
+ goto end_with_close;
+ }
+
+ tz_lsis[tz_leapcnt].ls_trans= (my_time_t)table->field[0]->val_int();
+ tz_lsis[tz_leapcnt].ls_corr= (long)table->field[1]->val_int();
+
+ tz_leapcnt++;
+
+ DBUG_PRINT("info",
+ ("time_zone_leap_second table: tz_leapcnt: %u tt_time: %lu offset: %ld",
+ tz_leapcnt, (ulong) tz_lsis[tz_leapcnt-1].ls_trans,
+ tz_lsis[tz_leapcnt-1].ls_corr));
+
+ res= table->file->ha_index_next(table->record[0]);
+ }
+
+ (void)table->file->ha_index_end();
+
+ if (res != HA_ERR_END_OF_FILE)
+ {
+ sql_print_error("Fatal error: Error while loading "
+ "mysql.time_zone_leap_second table");
+ goto end_with_close;
+ }
+
+ /*
+ Loading of info about leap seconds succeeded
+ */
+
+ return_val= 0;
+
+
+end_with_setting_default_tz:
+ /* If we have default time zone try to load it */
+ if (default_tzname)
+ {
+ String tmp_tzname2(default_tzname, &my_charset_latin1);
+ /*
+ Time zone tables may be open here, and my_tz_find() may open
+ most of them once more, but this is OK for system tables open
+ for READ.
+ */
+ if (unlikely(!(global_system_variables.time_zone=
+ my_tz_find(thd, &tmp_tzname2))))
+ {
+ sql_print_error("Fatal error: Illegal or unknown default time zone '%s'",
+ default_tzname);
+ return_val= 1;
+ }
+ }
+
+end_with_close:
+ if (time_zone_tables_exist)
+ close_mysql_tables(thd);
+
+end_with_cleanup:
+
+ /* if there were error free time zone describing structs */
+ if (unlikely(return_val))
+ my_tz_free();
+end:
+ delete thd;
+ if (org_thd)
+ org_thd->store_globals(); /* purecov: inspected */
+
+ default_tz= default_tz_name ? global_system_variables.time_zone
+ : my_tz_SYSTEM;
+
+ DBUG_RETURN(return_val);
+}
+
+
+/*
+ Free resources used by time zone support infrastructure.
+
+ SYNOPSIS
+ my_tz_free()
+*/
+
+void my_tz_free()
+{
+ if (tz_inited)
+ {
+ tz_inited= 0;
+ mysql_mutex_destroy(&tz_LOCK);
+ my_hash_free(&offset_tzs);
+ my_hash_free(&tz_names);
+ free_root(&tz_storage, MYF(0));
+ }
+}
+
+
+/*
+ Load time zone description from system tables.
+
+ SYNOPSIS
+ tz_load_from_open_tables()
+ tz_name - name of time zone that should be loaded.
+ tz_tables - list of tables from which time zone description
+ should be loaded
+
+ DESCRIPTION
+ This function will try to load information about time zone specified
+ from the list of the already opened and locked tables (first table in
+ tz_tables should be time_zone_name, next time_zone, then
+ time_zone_transition_type and time_zone_transition should be last).
+ It will also update information in hash used for time zones lookup.
+
+ RETURN VALUES
+ Returns pointer to newly created Time_zone object or 0 in case of error.
+
+*/
+
+static Time_zone*
+tz_load_from_open_tables(const String *tz_name, TABLE_LIST *tz_tables)
+{
+ TABLE *table= 0;
+ TIME_ZONE_INFO *tz_info= NULL;
+ Tz_names_entry *tmp_tzname;
+ Time_zone *return_val= 0;
+ int res;
+ uint tzid, ttid;
+ my_time_t ttime;
+ char buff[MAX_FIELD_WIDTH];
+ uchar keybuff[32];
+ Field *field;
+ String abbr(buff, sizeof(buff), &my_charset_latin1);
+ char *alloc_buff= NULL;
+ char *tz_name_buff= NULL;
+ /*
+ Temporary arrays that are used for loading of data for filling
+ TIME_ZONE_INFO structure
+ */
+ my_time_t ats[TZ_MAX_TIMES];
+ uchar types[TZ_MAX_TIMES];
+ TRAN_TYPE_INFO ttis[TZ_MAX_TYPES];
+#ifdef ABBR_ARE_USED
+ char chars[MY_MAX(TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1)))];
+#endif
+ /*
+ Used as a temporary tz_info until we decide that we actually want to
+ allocate and keep the tz info and tz name in tz_storage.
+ */
+ TIME_ZONE_INFO tmp_tz_info;
+ memset(&tmp_tz_info, 0, sizeof(TIME_ZONE_INFO));
+
+ DBUG_ENTER("tz_load_from_open_tables");
+
+ /*
+ Let us find out time zone id by its name (there is only one index
+ and it is specifically for this purpose).
+ */
+ table= tz_tables->table;
+ tz_tables= tz_tables->next_local;
+ table->field[0]->store(tz_name->ptr(), tz_name->length(),
+ &my_charset_latin1);
+ if (table->file->ha_index_init(0, 1))
+ goto end;
+
+ if (table->file->ha_index_read_map(table->record[0], table->field[0]->ptr,
+ HA_WHOLE_KEY, HA_READ_KEY_EXACT))
+ {
+#ifdef EXTRA_DEBUG
+ /*
+ Most probably user has mistyped time zone name, so no need to bark here
+ unless we need it for debugging.
+ */
+ sql_print_error("Can't find description of time zone '%.*b'",
+ tz_name->length(), tz_name->ptr());
+#endif
+ goto end;
+ }
+
+ tzid= (uint)table->field[1]->val_int();
+
+ (void)table->file->ha_index_end();
+
+ /*
+ Now we need to lookup record in mysql.time_zone table in order to
+ understand whenever this timezone uses leap seconds (again we are
+ using the only index in this table).
+ */
+ table= tz_tables->table;
+ tz_tables= tz_tables->next_local;
+ field= table->field[0];
+ field->store((longlong) tzid, TRUE);
+ DBUG_ASSERT(field->key_length() <= sizeof(keybuff));
+ field->get_key_image(keybuff,
+ MY_MIN(field->key_length(), sizeof(keybuff)),
+ Field::itRAW);
+ if (table->file->ha_index_init(0, 1))
+ goto end;
+
+ if (table->file->ha_index_read_map(table->record[0], keybuff,
+ HA_WHOLE_KEY, HA_READ_KEY_EXACT))
+ {
+ sql_print_error("Can't find description of time zone '%u'", tzid);
+ goto end;
+ }
+
+ /* If Uses_leap_seconds == 'Y' */
+ if (table->field[1]->val_int() == 1)
+ {
+ tmp_tz_info.leapcnt= tz_leapcnt;
+ tmp_tz_info.lsis= tz_lsis;
+ }
+
+ (void)table->file->ha_index_end();
+
+ /*
+ Now we will iterate through records for out time zone in
+ mysql.time_zone_transition_type table. Because we want records
+ only for our time zone guess what are we doing?
+ Right - using special index.
+ */
+ table= tz_tables->table;
+ tz_tables= tz_tables->next_local;
+ field= table->field[0];
+ field->store((longlong) tzid, TRUE);
+ DBUG_ASSERT(field->key_length() <= sizeof(keybuff));
+ field->get_key_image(keybuff,
+ MY_MIN(field->key_length(), sizeof(keybuff)),
+ Field::itRAW);
+ if (table->file->ha_index_init(0, 1))
+ goto end;
+
+ res= table->file->ha_index_read_map(table->record[0], keybuff,
+ (key_part_map)1, HA_READ_KEY_EXACT);
+ while (!res)
+ {
+ ttid= (uint)table->field[1]->val_int();
+
+ if (ttid >= TZ_MAX_TYPES)
+ {
+ sql_print_error("Error while loading time zone description from "
+ "mysql.time_zone_transition_type table: too big "
+ "transition type id");
+ goto end;
+ }
+
+ ttis[ttid].tt_gmtoff= (long)table->field[2]->val_int();
+ ttis[ttid].tt_isdst= (table->field[3]->val_int() > 0);
+
+#ifdef ABBR_ARE_USED
+ // FIXME should we do something with duplicates here ?
+ table->field[4]->val_str(&abbr, &abbr);
+ if (tmp_tz_info.charcnt + abbr.length() + 1 > sizeof(chars))
+ {
+ sql_print_error("Error while loading time zone description from "
+ "mysql.time_zone_transition_type table: not enough "
+ "room for abbreviations");
+ goto end;
+ }
+ ttis[ttid].tt_abbrind= tmp_tz_info.charcnt;
+ memcpy(chars + tmp_tz_info.charcnt, abbr.ptr(), abbr.length());
+ tmp_tz_info.charcnt+= abbr.length();
+ chars[tmp_tz_info.charcnt]= 0;
+ tmp_tz_info.charcnt++;
+
+ DBUG_PRINT("info",
+ ("time_zone_transition_type table: tz_id=%u tt_id=%u tt_gmtoff=%ld "
+ "abbr='%s' tt_isdst=%u", tzid, ttid, ttis[ttid].tt_gmtoff,
+ chars + ttis[ttid].tt_abbrind, ttis[ttid].tt_isdst));
+#else
+ DBUG_PRINT("info",
+ ("time_zone_transition_type table: tz_id=%u tt_id=%u tt_gmtoff=%ld "
+ "tt_isdst=%u", tzid, ttid, ttis[ttid].tt_gmtoff, ttis[ttid].tt_isdst));
+#endif
+
+ /* ttid is increasing because we are reading using index */
+ DBUG_ASSERT(ttid >= tmp_tz_info.typecnt);
+
+ tmp_tz_info.typecnt= ttid + 1;
+
+ res= table->file->ha_index_next_same(table->record[0], keybuff, 4);
+ }
+
+ if (res != HA_ERR_END_OF_FILE)
+ {
+ sql_print_error("Error while loading time zone description from "
+ "mysql.time_zone_transition_type table");
+ goto end;
+ }
+
+ (void)table->file->ha_index_end();
+
+
+ /*
+ At last we are doing the same thing for records in
+ mysql.time_zone_transition table. Here we additionally need records
+ in ascending order by index scan also satisfies us.
+ */
+ table= tz_tables->table;
+ table->field[0]->store((longlong) tzid, TRUE);
+ if (table->file->ha_index_init(0, 1))
+ goto end;
+
+ res= table->file->ha_index_read_map(table->record[0], keybuff,
+ (key_part_map)1, HA_READ_KEY_EXACT);
+ while (!res)
+ {
+ ttime= (my_time_t)table->field[1]->val_int();
+ ttid= (uint)table->field[2]->val_int();
+
+ if (tmp_tz_info.timecnt + 1 > TZ_MAX_TIMES)
+ {
+ sql_print_error("Error while loading time zone description from "
+ "mysql.time_zone_transition table: "
+ "too much transitions");
+ goto end;
+ }
+ if (ttid + 1 > tmp_tz_info.typecnt)
+ {
+ sql_print_error("Error while loading time zone description from "
+ "mysql.time_zone_transition table: "
+ "bad transition type id");
+ goto end;
+ }
+
+ ats[tmp_tz_info.timecnt]= ttime;
+ types[tmp_tz_info.timecnt]= ttid;
+ tmp_tz_info.timecnt++;
+
+ DBUG_PRINT("info",
+ ("time_zone_transition table: tz_id: %u tt_time: %lu tt_id: %u",
+ tzid, (ulong) ttime, ttid));
+
+ res= table->file->ha_index_next_same(table->record[0], keybuff, 4);
+ }
+
+ /*
+ We have to allow HA_ERR_KEY_NOT_FOUND because some time zones
+ for example UTC have no transitons.
+ */
+ if (res != HA_ERR_END_OF_FILE && res != HA_ERR_KEY_NOT_FOUND)
+ {
+ sql_print_error("Error while loading time zone description from "
+ "mysql.time_zone_transition table");
+ goto end;
+ }
+
+ (void)table->file->ha_index_end();
+ table= 0;
+
+ /*
+ Let us check how correct our time zone description is. We don't check for
+ tz->timecnt < 1 since it is ok for GMT.
+ */
+ if (tmp_tz_info.typecnt < 1)
+ {
+ sql_print_error("loading time zone without transition types");
+ goto end;
+ }
+
+ /* Allocate memory for the timezone info and timezone name in tz_storage. */
+ if (!(alloc_buff= (char*) alloc_root(&tz_storage, sizeof(TIME_ZONE_INFO) +
+ tz_name->length() + 1)))
+ {
+ sql_print_error("Out of memory while loading time zone description");
+ return 0;
+ }
+
+ /* Move the temporary tz_info into the allocated area */
+ tz_info= (TIME_ZONE_INFO *)alloc_buff;
+ memcpy(tz_info, &tmp_tz_info, sizeof(TIME_ZONE_INFO));
+ tz_name_buff= alloc_buff + sizeof(TIME_ZONE_INFO);
+ /*
+ By writing zero to the end we guarantee that we can call ptr()
+ instead of c_ptr() for time zone name.
+ */
+ strmake(tz_name_buff, tz_name->ptr(), tz_name->length());
+
+ /*
+ Now we will allocate memory and init TIME_ZONE_INFO structure.
+ */
+ if (!(alloc_buff= (char*) alloc_root(&tz_storage,
+ ALIGN_SIZE(sizeof(my_time_t) *
+ tz_info->timecnt) +
+ ALIGN_SIZE(tz_info->timecnt) +
+#ifdef ABBR_ARE_USED
+ ALIGN_SIZE(tz_info->charcnt) +
+#endif
+ sizeof(TRAN_TYPE_INFO) *
+ tz_info->typecnt)))
+ {
+ sql_print_error("Out of memory while loading time zone description");
+ goto end;
+ }
+
+ tz_info->ats= (my_time_t *) alloc_buff;
+ memcpy(tz_info->ats, ats, tz_info->timecnt * sizeof(my_time_t));
+ alloc_buff+= ALIGN_SIZE(sizeof(my_time_t) * tz_info->timecnt);
+ tz_info->types= (uchar *)alloc_buff;
+ memcpy(tz_info->types, types, tz_info->timecnt);
+ alloc_buff+= ALIGN_SIZE(tz_info->timecnt);
+#ifdef ABBR_ARE_USED
+ tz_info->chars= alloc_buff;
+ memcpy(tz_info->chars, chars, tz_info->charcnt);
+ alloc_buff+= ALIGN_SIZE(tz_info->charcnt);
+#endif
+ tz_info->ttis= (TRAN_TYPE_INFO *)alloc_buff;
+ memcpy(tz_info->ttis, ttis, tz_info->typecnt * sizeof(TRAN_TYPE_INFO));
+
+ /* Build reversed map. */
+ if (prepare_tz_info(tz_info, &tz_storage))
+ {
+ sql_print_error("Unable to build mktime map for time zone");
+ goto end;
+ }
+
+
+ if (!(tmp_tzname= new (&tz_storage) Tz_names_entry()) ||
+ !(tmp_tzname->tz= new (&tz_storage) Time_zone_db(tz_info,
+ &(tmp_tzname->name))) ||
+ (tmp_tzname->name.set(tz_name_buff, tz_name->length(),
+ &my_charset_latin1),
+ my_hash_insert(&tz_names, (const uchar *)tmp_tzname)))
+ {
+ sql_print_error("Out of memory while loading time zone");
+ goto end;
+ }
+
+ /*
+ Loading of time zone succeeded
+ */
+ return_val= tmp_tzname->tz;
+
+end:
+
+ if (table && table->file->inited)
+ (void) table->file->ha_index_end();
+
+ DBUG_RETURN(return_val);
+}
+
+
+/*
+ Parse string that specifies time zone as offset from UTC.
+
+ SYNOPSIS
+ str_to_offset()
+ str - pointer to string which contains offset
+ length - length of string
+ offset - out parameter for storing found offset in seconds.
+
+ DESCRIPTION
+ This function parses string which contains time zone offset
+ in form similar to '+10:00' and converts found value to
+ seconds from UTC form (east is positive).
+
+ RETURN VALUE
+ 0 - Ok
+ 1 - String doesn't contain valid time zone offset
+*/
+my_bool
+str_to_offset(const char *str, uint length, long *offset)
+{
+ const char *end= str + length;
+ my_bool negative;
+ ulong number_tmp;
+ long offset_tmp;
+
+ if (length < 4)
+ return 1;
+
+ if (*str == '+')
+ negative= 0;
+ else if (*str == '-')
+ negative= 1;
+ else
+ return 1;
+ str++;
+
+ number_tmp= 0;
+
+ while (str < end && my_isdigit(&my_charset_latin1, *str))
+ {
+ number_tmp= number_tmp*10 + *str - '0';
+ str++;
+ }
+
+ if (str + 1 >= end || *str != ':')
+ return 1;
+ str++;
+
+ offset_tmp = number_tmp * MINS_PER_HOUR; number_tmp= 0;
+
+ while (str < end && my_isdigit(&my_charset_latin1, *str))
+ {
+ number_tmp= number_tmp * 10 + *str - '0';
+ str++;
+ }
+
+ if (str != end)
+ return 1;
+
+ offset_tmp= (offset_tmp + number_tmp) * SECS_PER_MIN;
+
+ if (negative)
+ offset_tmp= -offset_tmp;
+
+ /*
+ Check if offset is in range prescribed by standard
+ (from -12:59 to 13:00).
+ */
+
+ if (number_tmp > 59 || offset_tmp < -13 * SECS_PER_HOUR + 1 ||
+ offset_tmp > 13 * SECS_PER_HOUR)
+ return 1;
+
+ *offset= offset_tmp;
+
+ return 0;
+}
+
+
+/*
+ Get Time_zone object for specified time zone.
+
+ SYNOPSIS
+ my_tz_find()
+ thd - pointer to thread THD structure
+ name - time zone specification
+
+ DESCRIPTION
+ This function checks if name is one of time zones described in db,
+ predefined SYSTEM time zone or valid time zone specification as
+ offset from UTC (In last case it will create proper Time_zone_offset
+ object if there were not any.). If name is ok it returns corresponding
+ Time_zone object.
+
+ Clients of this function are not responsible for releasing resources
+ occupied by returned Time_zone object so they can just forget pointers
+ to Time_zone object if they are not needed longer.
+
+ Other important property of this function: if some Time_zone found once
+ it will be for sure found later, so this function can also be used for
+ checking if proper Time_zone object exists (and if there will be error
+ it will be reported during first call).
+
+ If name pointer is 0 then this function returns 0 (this allows to pass 0
+ values as parameter without additional external check and this property
+ is used by @@time_zone variable handling code).
+
+ It will perform lookup in system tables (mysql.time_zone*),
+ opening and locking them, and closing afterwards. It won't perform
+ such lookup if no time zone describing tables were found during
+ server start up.
+
+ RETURN VALUE
+ Pointer to corresponding Time_zone object. 0 - in case of bad time zone
+ specification or other error.
+
+*/
+Time_zone *
+my_tz_find(THD *thd, const String *name)
+{
+ Tz_names_entry *tmp_tzname;
+ Time_zone *result_tz= 0;
+ long offset;
+ DBUG_ENTER("my_tz_find");
+ DBUG_PRINT("enter", ("time zone name='%s'",
+ name ? ((String *)name)->c_ptr_safe() : "NULL"));
+
+ if (!name || name->is_empty())
+ DBUG_RETURN(0);
+
+ mysql_mutex_lock(&tz_LOCK);
+
+ if (!str_to_offset(name->ptr(), name->length(), &offset))
+ {
+ if (!(result_tz= (Time_zone_offset *)my_hash_search(&offset_tzs,
+ (const uchar *)&offset,
+ sizeof(long))))
+ {
+ DBUG_PRINT("info", ("Creating new Time_zone_offset object"));
+
+ if (!(result_tz= new (&tz_storage) Time_zone_offset(offset)) ||
+ my_hash_insert(&offset_tzs, (const uchar *) result_tz))
+ {
+ result_tz= 0;
+ sql_print_error("Fatal error: Out of memory "
+ "while setting new time zone");
+ }
+ }
+ }
+ else
+ {
+ result_tz= 0;
+ if ((tmp_tzname= (Tz_names_entry *)my_hash_search(&tz_names,
+ (const uchar *)
+ name->ptr(),
+ name->length())))
+ result_tz= tmp_tzname->tz;
+ else if (time_zone_tables_exist)
+ {
+ TABLE_LIST tz_tables[MY_TZ_TABLES_COUNT];
+
+ /*
+ Allocate start_new_trans with malloc as it's > 4000 bytes and this
+ function can be called deep inside a stored procedure
+ */
+ start_new_trans *new_trans= new start_new_trans(thd);
+ tz_init_table_list(tz_tables);
+ init_mdl_requests(tz_tables);
+ if (!open_system_tables_for_read(thd, tz_tables))
+ {
+ result_tz= tz_load_from_open_tables(name, tz_tables);
+ thd->commit_whole_transaction_and_close_tables();
+ }
+ new_trans->restore_old_transaction();
+ delete new_trans;
+ }
+ }
+
+ mysql_mutex_unlock(&tz_LOCK);
+
+ if (result_tz && result_tz != my_tz_SYSTEM && result_tz != my_tz_UTC)
+ status_var_increment(thd->status_var.feature_timezone);
+
+ DBUG_RETURN(result_tz);
+}
+
+
+/**
+ Convert leap seconds into non-leap
+
+ This function will convert the leap seconds added by the OS to
+ non-leap seconds, e.g. 23:59:59, 23:59:60 -> 23:59:59, 00:00:01 ...
+ This check is not checking for years on purpose : although it's not a
+ complete check this way it doesn't require looking (and having installed)
+ the leap seconds table.
+
+ @param[in,out] broken down time structure as filled in by the OS
+*/
+
+void Time_zone::adjust_leap_second(MYSQL_TIME *t)
+{
+ if (t->second == 60 || t->second == 61)
+ t->second= 59;
+}
+
+#endif /* !defined(TESTTIME) && !defined(TZINFO2SQL) */
+
+
+#ifdef TZINFO2SQL
+/*
+ This code belongs to mysql_tzinfo_to_sql converter command line utility.
+ This utility should be used by db admin for populating mysql.time_zone
+ tables.
+*/
+
+/*
+ Print info about time zone described by TIME_ZONE_INFO struct as
+ SQL statements populating mysql.time_zone* tables.
+
+ SYNOPSIS
+ print_tz_as_sql()
+ tz_name - name of time zone
+ sp - structure describing time zone
+*/
+void
+print_tz_as_sql(const char* tz_name, const TIME_ZONE_INFO *sp)
+{
+ uint i;
+
+ /* Here we assume that all time zones have same leap correction tables */
+ printf("INSERT INTO time_zone (Use_leap_seconds) VALUES ('%s');\n",
+ sp->leapcnt ? "Y" : "N");
+ printf("SET @time_zone_id= LAST_INSERT_ID();\n");
+ printf("INSERT INTO time_zone_name (Name, Time_zone_id) VALUES \
+('%s', @time_zone_id);\n", tz_name);
+
+ if (sp->timecnt)
+ {
+ printf("INSERT INTO time_zone_transition \
+(Time_zone_id, Transition_time, Transition_type_id) VALUES\n");
+ for (i= 0; i < sp->timecnt; i++)
+ printf("%s(@time_zone_id, %ld, %u)\n", (i == 0 ? " " : ","), sp->ats[i],
+ (uint)sp->types[i]);
+ printf(";\n");
+ }
+
+ printf("INSERT INTO time_zone_transition_type \
+(Time_zone_id, Transition_type_id, Offset, Is_DST, Abbreviation) VALUES\n");
+
+ for (i= 0; i < sp->typecnt; i++)
+ printf("%s(@time_zone_id, %u, %ld, %d, '%s')\n", (i == 0 ? " " : ","), i,
+ sp->ttis[i].tt_gmtoff, sp->ttis[i].tt_isdst,
+ sp->chars + sp->ttis[i].tt_abbrind);
+ printf(";\n");
+}
+
+
+/*
+ Print info about leap seconds in time zone as SQL statements
+ populating mysql.time_zone_leap_second table.
+
+ SYNOPSIS
+ print_tz_leaps_as_sql()
+ sp - structure describing time zone
+*/
+void
+print_tz_leaps_as_sql(const TIME_ZONE_INFO *sp)
+{
+ uint i;
+
+ /*
+ We are assuming that there are only one list of leap seconds
+ For all timezones.
+ */
+ if (!opt_skip_write_binlog)
+ printf("\\d |\n"
+ "IF (select count(*) from information_schema.global_variables where\n"
+ "variable_name='wsrep_on' and variable_value='ON') = 1 THEN\n"
+ "ALTER TABLE time_zone_leap_second ENGINE=InnoDB;\n"
+ "END IF|\n"
+ "\\d ;\n");
+
+ printf("TRUNCATE TABLE time_zone_leap_second;\n");
+
+ if (sp->leapcnt)
+ {
+ printf("INSERT INTO time_zone_leap_second \
+(Transition_time, Correction) VALUES\n");
+ for (i= 0; i < sp->leapcnt; i++)
+ printf("%s(%ld, %ld)\n", (i == 0 ? " " : ","),
+ sp->lsis[i].ls_trans, sp->lsis[i].ls_corr);
+ printf(";\n");
+ }
+
+ if (!opt_skip_write_binlog)
+ printf("\\d |\n"
+ "IF (select count(*) from information_schema.global_variables where\n"
+ "variable_name='wsrep_on' and variable_value='ON') = 1 THEN\n"
+ "ALTER TABLE time_zone_leap_second ENGINE=Aria;\n"
+ "END IF|\n"
+ "\\d ;\n");
+
+ printf("ALTER TABLE time_zone_leap_second ORDER BY Transition_time;\n");
+}
+
+
+/*
+ Some variables used as temporary or as parameters
+ in recursive scan_tz_dir() code.
+*/
+TIME_ZONE_INFO tz_info;
+MEM_ROOT tz_storage;
+char fullname[FN_REFLEN + 1];
+char *root_name_end;
+
+/*
+ known file types that exist in the zoneinfo directory that are safe to
+ silently skip
+*/
+const char *known_extensions[]= {
+ ".tab",
+ NullS
+};
+
+
+/*
+ Recursively scan zoneinfo directory and print all found time zone
+ descriptions as SQL.
+
+ SYNOPSIS
+ scan_tz_dir()
+ name_end - pointer to end of path to directory to be searched.
+ symlink_recursion_level How many symlink directory levels are used
+ verbose >0 if we should print warnings
+
+ DESCRIPTION
+ This auxiliary recursive function also uses several global
+ variables as in parameters and for storing temporary values.
+
+ fullname - path to directory that should be scanned.
+ root_name_end - pointer to place in fullname where part with
+ path to initial directory ends.
+ current_tz_id - last used time zone id
+
+ RETURN VALUE
+ 0 - Ok, 1 - Fatal error
+
+*/
+my_bool
+scan_tz_dir(char * name_end, uint symlink_recursion_level, uint verbose)
+{
+ MY_DIR *cur_dir;
+ char *name_end_tmp;
+ uint i;
+
+ /* Sort directory data, to pass mtr tests on different platforms. */
+ if (!(cur_dir= my_dir(fullname, MYF(MY_WANT_STAT|MY_WANT_SORT))))
+ return 1;
+
+ name_end= strmake(name_end, "/", FN_REFLEN - (name_end - fullname));
+
+ for (i= 0; i < cur_dir->number_of_files; i++)
+ {
+ if (cur_dir->dir_entry[i].name[0] != '.' &&
+ strcmp(cur_dir->dir_entry[i].name, "Factory"))
+ {
+ name_end_tmp= strmake(name_end, cur_dir->dir_entry[i].name,
+ FN_REFLEN - (name_end - fullname));
+
+ if (MY_S_ISDIR(cur_dir->dir_entry[i].mystat->st_mode))
+ {
+ my_bool is_symlink;
+ if ((is_symlink= my_is_symlink(fullname)) &&
+ symlink_recursion_level > 0)
+ {
+ /*
+ The timezone definition data in some Linux distributions
+ (e.g. the "timezone-data-2013f" package in Gentoo)
+ may have synlimks like:
+ /usr/share/zoneinfo/posix/ -> /usr/share/zoneinfo/,
+ so the same timezone files are available under two names
+ (e.g. "CET" and "posix/CET").
+
+ We allow one level of symlink recursion for backward
+ compatibility with earlier timezone data packages that have
+ duplicate copies of the same timezone files inside the root
+ directory and the "posix" subdirectory (instead of symlinking).
+ This makes "posix/CET" still available, but helps to avoid
+ following such symlinks infinitely:
+ /usr/share/zoneinfo/posix/posix/posix/.../posix/
+ */
+
+ /*
+ This is a normal case and not critical. only print warning if
+ verbose mode is chosen.
+ */
+ if (verbose > 0)
+ {
+ fflush(stdout);
+ fprintf(stderr, "Warning: Skipping directory '%s': "
+ "to avoid infinite symlink recursion.\n", fullname);
+ }
+ continue;
+ }
+ if (scan_tz_dir(name_end_tmp, symlink_recursion_level + is_symlink,
+ verbose))
+ {
+ my_dirend(cur_dir);
+ return 1;
+ }
+ }
+ else if (MY_S_ISREG(cur_dir->dir_entry[i].mystat->st_mode))
+ {
+ init_alloc_root(PSI_INSTRUMENT_ME, &tz_storage,
+ 32768, 0, MYF(MY_THREAD_SPECIFIC));
+ if (!tz_load(fullname, &tz_info, &tz_storage))
+ print_tz_as_sql(root_name_end + 1, &tz_info);
+ else
+ {
+ /*
+ Some systems (like debian, opensuse etc) have description
+ files (.tab). We skip these silently if verbose is > 0
+ */
+ const char *current_ext= fn_ext(fullname);
+ my_bool known_ext= 0;
+
+ for (const char **ext= known_extensions ; *ext ; ext++)
+ {
+ if (!strcmp(*ext, current_ext))
+ {
+ known_ext= 1;
+ break;
+ }
+ }
+ if (verbose > 0 || !known_ext)
+ {
+ fflush(stdout);
+ fprintf(stderr,
+ "Warning: Unable to load '%s' as time zone. Skipping it.\n",
+ fullname);
+ }
+ }
+ free_root(&tz_storage, MYF(0));
+ }
+ else
+ {
+ fflush(stdout);
+ fprintf(stderr, "Warning: '%s' is not regular file or directory\n",
+ fullname);
+ }
+ }
+ }
+
+ my_dirend(cur_dir);
+
+ return 0;
+}
+
+
+static const char *load_default_groups[]=
+{ "mysql_tzinfo_to_sql", 0};
+
+static struct my_option my_long_options[] =
+{
+ {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG,
+ 0, 0, 0, 0, 0, 0},
+#ifdef DBUG_OFF
+ {"debug", '#', "This is a non-debug version. Catch this and exit",
+ 0,0, 0, GET_DISABLED, OPT_ARG, 0, 0, 0, 0, 0, 0},
+#else
+ {"debug", '#', "Output debug log. Often this is 'd:t:o,filename'.",
+ 0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
+#endif
+ {"leap", 'l', "Print the leap second information from the given time zone file. By convention, when --leap is used the next argument is the timezonefile",
+ &opt_leap, &opt_leap, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+ {"verbose", 'v', "Write non critical warnings",
+ &opt_verbose, &opt_verbose, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+ {"version", 'V', "Output version information and exit.",
+ 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
+ {"skip-write-binlog", 'S', "Do not replicate changes to time zone tables to other nodes in a Galera cluster",
+ &opt_skip_write_binlog,&opt_skip_write_binlog, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
+ { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
+};
+
+
+C_MODE_START
+static my_bool get_one_option(const struct my_option *, const char *,
+ const char *);
+C_MODE_END
+
+static void print_version(void)
+{
+ printf("%s Ver %s Distrib %s, for %s (%s)\n",my_progname, PROGRAM_VERSION,
+ MYSQL_SERVER_VERSION,SYSTEM_TYPE,MACHINE_TYPE);
+}
+
+static void print_usage(void)
+{
+ fprintf(stderr, "Usage:\n");
+ fprintf(stderr, " %s [options] timezonedir\n", my_progname);
+ fprintf(stderr, " %s [options] timezonefile timezonename\n", my_progname);
+ print_defaults("my",load_default_groups);
+ puts("");
+ my_print_help(my_long_options);
+ my_print_variables(my_long_options);
+}
+
+
+static my_bool
+get_one_option(const struct my_option *opt, const char *argument, const char *)
+{
+ switch(opt->id) {
+ case '#':
+#ifndef DBUG_OFF
+ DBUG_PUSH(argument ? argument : "d:t:S:i:O,/tmp/mysq_tzinfo_to_sql.trace");
+#endif
+ break;
+ case '?':
+ print_version();
+ puts("");
+ print_usage();
+ exit(0);
+ case 'V':
+ print_version();
+ exit(0);
+ }
+ return 0;
+}
+
+
+int
+main(int argc, char **argv)
+{
+ char **default_argv;
+ MY_INIT(argv[0]);
+
+ load_defaults_or_exit("my", load_default_groups, &argc, &argv);
+ default_argv= argv;
+
+ if ((handle_options(&argc, &argv, my_long_options, get_one_option)))
+ exit(1);
+
+ if ((argc != 1 && argc != 2) || (opt_leap && argc != 1))
+ {
+ print_usage();
+ free_defaults(default_argv);
+ return 1;
+ }
+
+ if (opt_skip_write_binlog)
+ {
+ /* If skip_write_binlog is set and wsrep is compiled in we disable
+ sql_log_bin and wsrep_on to avoid Galera replicating below
+ truncate table clauses. This will allow user to set different
+ time zones to nodes in Galera cluster. */
+ printf("set @prep1=if((select count(*) from information_schema.global_variables where variable_name='wsrep_on' and variable_value='ON'), 'SET SESSION SQL_LOG_BIN=?, WSREP_ON=OFF;', 'do ?');\n"
+ "prepare set_wsrep_write_binlog from @prep1;\n"
+ "set @toggle=0; execute set_wsrep_write_binlog using @toggle;\n");
+ }
+ else
+ {
+ // Alter time zone tables to InnoDB if wsrep_on is enabled
+ // to allow changes to them to replicate with Galera
+ printf("\\d |\n"
+ "IF (select count(*) from information_schema.global_variables where\n"
+ "variable_name='wsrep_on' and variable_value='ON') = 1 THEN\n"
+ "ALTER TABLE time_zone ENGINE=InnoDB;\n"
+ "ALTER TABLE time_zone_name ENGINE=InnoDB;\n"
+ "ALTER TABLE time_zone_transition ENGINE=InnoDB;\n"
+ "ALTER TABLE time_zone_transition_type ENGINE=InnoDB;\n"
+ "END IF|\n"
+ "\\d ;\n");
+ }
+
+ if (argc == 1 && !opt_leap)
+ {
+ /* Argument is timezonedir */
+
+ root_name_end= strmake_buf(fullname, argv[0]);
+
+ printf("TRUNCATE TABLE time_zone;\n");
+ printf("TRUNCATE TABLE time_zone_name;\n");
+ printf("TRUNCATE TABLE time_zone_transition;\n");
+ printf("TRUNCATE TABLE time_zone_transition_type;\n");
+ printf("START TRANSACTION;\n");
+
+ if (scan_tz_dir(root_name_end, 0, opt_verbose))
+ {
+ printf("ROLLBACK;\n");
+ fflush(stdout);
+ fprintf(stderr,
+ "There were fatal errors during processing "
+ "of zoneinfo directory '%s'\n", fullname);
+ return 1;
+ }
+
+ printf("COMMIT;\n");
+ printf("ALTER TABLE time_zone_transition "
+ "ORDER BY Time_zone_id, Transition_time;\n");
+ printf("ALTER TABLE time_zone_transition_type "
+ "ORDER BY Time_zone_id, Transition_type_id;\n");
+ }
+ else
+ {
+ /*
+ First argument is timezonefile.
+ The second is timezonename if opt_leap is not given
+ */
+ init_alloc_root(PSI_INSTRUMENT_ME, &tz_storage, 32768, 0, MYF(0));
+
+ if (tz_load(argv[0], &tz_info, &tz_storage))
+ {
+ fflush(stdout);
+ fprintf(stderr, "Problems with zoneinfo file '%s'\n", argv[0]);
+ return 1;
+ }
+ if (opt_leap)
+ print_tz_leaps_as_sql(&tz_info);
+ else
+ print_tz_as_sql(argv[1], &tz_info);
+
+ free_root(&tz_storage, MYF(0));
+ }
+
+ if(!opt_skip_write_binlog)
+ {
+ // Fall back to Aria
+ printf("\\d |\n"
+ "IF (select count(*) from information_schema.global_variables where\n"
+ "variable_name='wsrep_on' and variable_value='ON') = 1 THEN\n"
+ "ALTER TABLE time_zone ENGINE=Aria;\n"
+ "ALTER TABLE time_zone_name ENGINE=Aria;\n"
+ "ALTER TABLE time_zone_transition ENGINE=Aria;\n"
+ "ALTER TABLE time_zone_transition_type ENGINE=Aria;\n"
+ "END IF|\n"
+ "\\d ;\n");
+ }
+
+ free_defaults(default_argv);
+ my_end(0);
+ return 0;
+}
+
+#endif /* defined(TZINFO2SQL) */
+
+
+#ifdef TESTTIME
+
+/*
+ Some simple brute-force test which allowed to catch a pair of bugs.
+ Also can provide interesting facts about system's time zone support
+ implementation.
+*/
+
+#ifndef CHAR_BIT
+#define CHAR_BIT 8
+#endif
+
+#ifndef TYPE_BIT
+#define TYPE_BIT(type) (sizeof (type) * CHAR_BIT)
+#endif
+
+#ifndef TYPE_SIGNED
+#define TYPE_SIGNED(type) (((type) -1) < 0)
+#endif
+
+my_bool
+is_equal_TIME_tm(const TIME* time_arg, const struct tm * tm_arg)
+{
+ return (time_arg->year == (uint)tm_arg->tm_year+TM_YEAR_BASE) &&
+ (time_arg->month == (uint)tm_arg->tm_mon+1) &&
+ (time_arg->day == (uint)tm_arg->tm_mday) &&
+ (time_arg->hour == (uint)tm_arg->tm_hour) &&
+ (time_arg->minute == (uint)tm_arg->tm_min) &&
+ (time_arg->second == (uint)tm_arg->tm_sec) &&
+ time_arg->second_part == 0;
+}
+
+
+int
+main(int argc, char **argv)
+{
+ my_bool localtime_negative;
+ TIME_ZONE_INFO tz_info;
+ struct tm tmp;
+ MYSQL_TIME time_tmp;
+ time_t t, t1, t2;
+ char fullname[FN_REFLEN+1];
+ char *str_end;
+ MEM_ROOT tz_storage;
+
+ MY_INIT(argv[0]);
+
+ init_alloc_root(&tz_storage, "timezone_storage", 32768, MYF(0));
+
+ /* let us set some well known timezone */
+ setenv("TZ", "MET", 1);
+ tzset();
+
+ /* Some initial time zone related system info */
+ printf("time_t: %s %u bit\n", TYPE_SIGNED(time_t) ? "signed" : "unsigned",
+ (uint)TYPE_BIT(time_t));
+ if (TYPE_SIGNED(time_t))
+ {
+ t= -100;
+ localtime_negative= MY_TEST(localtime_r(&t, &tmp) != 0);
+ printf("localtime_r %s negative params \
+ (time_t=%d is %d-%d-%d %d:%d:%d)\n",
+ (localtime_negative ? "supports" : "doesn't support"), (int)t,
+ TM_YEAR_BASE + tmp.tm_year, tmp.tm_mon + 1, tmp.tm_mday,
+ tmp.tm_hour, tmp.tm_min, tmp.tm_sec);
+
+ printf("mktime %s negative results (%d)\n",
+ (t == mktime(&tmp) ? "doesn't support" : "supports"),
+ (int)mktime(&tmp));
+ }
+
+ tmp.tm_year= 103; tmp.tm_mon= 2; tmp.tm_mday= 30;
+ tmp.tm_hour= 2; tmp.tm_min= 30; tmp.tm_sec= 0; tmp.tm_isdst= -1;
+ t= mktime(&tmp);
+ printf("mktime returns %s for spring time gap (%d)\n",
+ (t != (time_t)-1 ? "something" : "error"), (int)t);
+
+ tmp.tm_year= 103; tmp.tm_mon= 8; tmp.tm_mday= 1;
+ tmp.tm_hour= 0; tmp.tm_min= 0; tmp.tm_sec= 0; tmp.tm_isdst= 0;
+ t= mktime(&tmp);
+ printf("mktime returns %s for non existing date (%d)\n",
+ (t != (time_t)-1 ? "something" : "error"), (int)t);
+
+ tmp.tm_year= 103; tmp.tm_mon= 8; tmp.tm_mday= 1;
+ tmp.tm_hour= 25; tmp.tm_min=0; tmp.tm_sec=0; tmp.tm_isdst=1;
+ t= mktime(&tmp);
+ printf("mktime %s unnormalized input (%d)\n",
+ (t != (time_t)-1 ? "handles" : "doesn't handle"), (int)t);
+
+ tmp.tm_year= 103; tmp.tm_mon= 9; tmp.tm_mday= 26;
+ tmp.tm_hour= 0; tmp.tm_min= 30; tmp.tm_sec= 0; tmp.tm_isdst= 1;
+ mktime(&tmp);
+ tmp.tm_hour= 2; tmp.tm_isdst= -1;
+ t= mktime(&tmp);
+ tmp.tm_hour= 4; tmp.tm_isdst= 0;
+ mktime(&tmp);
+ tmp.tm_hour= 2; tmp.tm_isdst= -1;
+ t1= mktime(&tmp);
+ printf("mktime is %s (%d %d)\n",
+ (t == t1 ? "determenistic" : "is non-determenistic"),
+ (int)t, (int)t1);
+
+ /* Let us load time zone description */
+ str_end= strmake_buf(fullname, TZDIR);
+ strmake(str_end, "/MET", FN_REFLEN - (str_end - fullname));
+
+ if (tz_load(fullname, &tz_info, &tz_storage))
+ {
+ printf("Unable to load time zone info from '%s'\n", fullname);
+ free_root(&tz_storage, MYF(0));
+ return 1;
+ }
+
+ printf("Testing our implementation\n");
+
+ if (TYPE_SIGNED(time_t) && localtime_negative)
+ {
+ for (t= -40000; t < 20000; t++)
+ {
+ localtime_r(&t, &tmp);
+ gmt_sec_to_TIME(&time_tmp, (my_time_t)t, &tz_info);
+ if (!is_equal_TIME_tm(&time_tmp, &tmp))
+ {
+ printf("Problem with negative time_t = %d\n", (int)t);
+ free_root(&tz_storage, MYF(0));
+ return 1;
+ }
+ }
+ printf("gmt_sec_to_TIME = localtime for time_t in [-40000,20000) range\n");
+ }
+
+ for (t= 1000000000; t < 1100000000; t+= 13)
+ {
+ localtime_r(&t,&tmp);
+ gmt_sec_to_TIME(&time_tmp, (my_time_t)t, &tz_info);
+
+ if (!is_equal_TIME_tm(&time_tmp, &tmp))
+ {
+ printf("Problem with time_t = %d\n", (int)t);
+ free_root(&tz_storage, MYF(0));
+ return 1;
+ }
+ }
+ printf("gmt_sec_to_TIME = localtime for time_t in [1000000000,1100000000) range\n");
+
+ my_init_time();
+
+ /*
+ Be careful here! my_system_gmt_sec doesn't fully handle unnormalized
+ dates.
+ */
+ for (time_tmp.year= 1980; time_tmp.year < 2010; time_tmp.year++)
+ {
+ for (time_tmp.month= 1; time_tmp.month < 13; time_tmp.month++)
+ {
+ for (time_tmp.day= 1;
+ time_tmp.day < mon_lengths[isleap(time_tmp.year)][time_tmp.month-1];
+ time_tmp.day++)
+ {
+ for (time_tmp.hour= 0; time_tmp.hour < 24; time_tmp.hour++)
+ {
+ for (time_tmp.minute= 0; time_tmp.minute < 60; time_tmp.minute+= 5)
+ {
+ for (time_tmp.second=0; time_tmp.second<60; time_tmp.second+=25)
+ {
+ long not_used;
+ uint not_used_2;
+ t= (time_t)my_system_gmt_sec(&time_tmp, &not_used, &not_used_2);
+ t1= (time_t)TIME_to_gmt_sec(&time_tmp, &tz_info, &not_used_2);
+ if (t != t1)
+ {
+ /*
+ We need special handling during autumn since my_system_gmt_sec
+ prefers greater time_t values (in MET) for ambiguity.
+ And BTW that is a bug which should be fixed !!!
+ */
+ tmp.tm_year= time_tmp.year - TM_YEAR_BASE;
+ tmp.tm_mon= time_tmp.month - 1;
+ tmp.tm_mday= time_tmp.day;
+ tmp.tm_hour= time_tmp.hour;
+ tmp.tm_min= time_tmp.minute;
+ tmp.tm_sec= time_tmp.second;
+ tmp.tm_isdst= 1;
+
+ t2= mktime(&tmp);
+
+ if (t1 == t2)
+ continue;
+
+ printf("Problem: %u/%u/%u %u:%u:%u with times t=%d, t1=%d\n",
+ time_tmp.year, time_tmp.month, time_tmp.day,
+ time_tmp.hour, time_tmp.minute, time_tmp.second,
+ (int)t,(int)t1);
+
+ free_root(&tz_storage, MYF(0));
+ return 1;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ printf("TIME_to_gmt_sec = my_system_gmt_sec for test range\n");
+
+ free_root(&tz_storage, MYF(0));
+ return 0;
+}
+
+#endif /* defined(TESTTIME) */