Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

mysql/src/5.1-dbg/sql/mysql_tzinfo_to_sql.cc File Reference

#include <my_global.h>
#include "mysql_priv.h"
#include "tzfile.h"
#include <m_string.h>
#include <my_dir.h>

Include dependency graph for mysql_tzinfo_to_sql.cc:

Go to the source code of this file.

Classes
struct	ttinfo
struct	lsinfo
struct	revtinfo
struct	st_time_zone_info
class	Time_zone_system
class	Time_zone_utc
class	Time_zone_db
class	Time_zone_offset
class	Tz_names_entry
Defines
#define	ABBR_ARE_USED
#define	MY_TZNAME_MAX   255
#define	LEAPS_THRU_END_OF(y)   ((y) / 4 - (y) / 100 + (y) / 400)
Typedefs
typedef ttinfo	TRAN_TYPE_INFO
typedef lsinfo	LS_INFO
typedef revtinfo	REVT_INFO
typedef st_time_zone_info	TIME_ZONE_INFO
Functions
static my_bool	prepare_tz_info (TIME_ZONE_INFO *sp, MEM_ROOT *storage)
static void	sec_to_TIME (TIME *tmp, my_time_t t, long offset)
static uint	find_time_range (my_time_t t, const my_time_t *range_boundaries, uint higher_bound)
static const TRAN_TYPE_INFO *	find_transition_type (my_time_t t, const TIME_ZONE_INFO *sp)
static void	gmt_sec_to_TIME (TIME *tmp, my_time_t sec_in_utc, const TIME_ZONE_INFO *sp)
static my_time_t	sec_since_epoch (int year, int mon, int mday, int hour, int min, int sec)
my_time_t	sec_since_epoch_TIME (TIME *t)
static my_time_t	TIME_to_gmt_sec (const TIME *t, const TIME_ZONE_INFO *sp, my_bool *in_dst_time_gap)
byte *	my_tz_names_get_key (Tz_names_entry *entry, uint *length, my_bool not_used __attribute__((unused)))
byte *	my_offset_tzs_get_key (Time_zone_offset *entry, uint *length, my_bool not_used __attribute__((unused)))
static void	tz_init_table_list (TABLE_LIST *tz_tabs, TABLE_LIST ***global_next_ptr)
TABLE_LIST *	my_tz_get_table_list (THD *thd, TABLE_LIST ***global_next_ptr)
my_bool	my_tz_init (THD *org_thd, const char *default_tzname, my_bool bootstrap)
void	my_tz_free ()
static Time_zone *	tz_load_from_open_tables (const String *tz_name, TABLE_LIST *tz_tables)
my_bool	str_to_offset (const char *str, uint length, long *offset)
Time_zone *	my_tz_find (const String *name, TABLE_LIST *tz_tables)
Time_zone *	my_tz_find_with_opening_tz_tables (THD *thd, const String *name)
Variables
static const uint	mon_lengths [2][MONS_PER_YEAR]
static const uint	mon_starts [2][MONS_PER_YEAR]
static const uint	year_lengths [2]
static const String	tz_SYSTEM_name ("SYSTEM", 6,&my_charset_latin1)
static Time_zone_utc	tz_UTC
static Time_zone_system	tz_SYSTEM
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
static pthread_mutex_t	tz_LOCK
static bool	tz_inited = 0
static uint	tz_leapcnt = 0
static LS_INFO *	tz_lsis = 0
static bool	time_zone_tables_exist = 1
static const LEX_STRING	tz_tables_names [MY_TZ_TABLES_COUNT]
static const LEX_STRING	tz_tables_db_name = { C_STRING_WITH_LEN("mysql")}
TABLE_LIST	fake_time_zone_tables_list

---

Define Documentation

#define ABBR_ARE_USED

Definition at line 54 of file mysql_tzinfo_to_sql.cc.

#define LEAPS_THRU_END_OF

(

y

)

((y) / 4 - (y) / 100 + (y) / 400)

Definition at line 521 of file mysql_tzinfo_to_sql.cc.

Referenced by sec_since_epoch(), and sec_to_TIME().

#define MY_TZNAME_MAX   255

Definition at line 94 of file mysql_tzinfo_to_sql.cc.

Referenced by tz_load_from_open_tables().

---

Typedef Documentation

typedef struct lsinfo LS_INFO

typedef struct revtinfo REVT_INFO

typedef struct st_time_zone_info TIME_ZONE_INFO

typedef struct ttinfo TRAN_TYPE_INFO

---

Function Documentation

static uint find_time_range	(	my_time_t	t,
		const my_time_t *	range_boundaries,
		uint	higher_bound
	)			[static]

Definition at line 626 of file mysql_tzinfo_to_sql.cc.

References DBUG_ASSERT.

Referenced by find_transition_type(), and TIME_to_gmt_sec().

{
  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;
}

Here is the caller graph for this function:

static const TRAN_TYPE_INFO* find_transition_type	(	my_time_t	t,
		const TIME_ZONE_INFO *	sp
	)			[static]

Definition at line 668 of file mysql_tzinfo_to_sql.cc.

References st_time_zone_info::ats, st_time_zone_info::fallback_tti, find_time_range(), st_time_zone_info::timecnt, st_time_zone_info::ttis, st_time_zone_info::types, and unlikely.

Referenced by gmt_sec_to_TIME().

{
  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)]]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void gmt_sec_to_TIME	(	TIME *	tmp,
		my_time_t	sec_in_utc,
		const TIME_ZONE_INFO *	sp
	)			[static]

Definition at line 710 of file mysql_tzinfo_to_sql.cc.

References find_transition_type(), st_time_zone_info::leapcnt, lsinfo::ls_corr, lsinfo::ls_trans, st_time_zone_info::lsis, sec_to_TIME(), st_mysql_time::second, and ttinfo::tt_gmtoff.

{
  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;
}

Here is the call graph for this function:

byte* my_offset_tzs_get_key	(	Time_zone_offset *	entry,
		uint *	length,
		my_bool not_used	__attribute__((unused))
	)

Definition at line 1423 of file mysql_tzinfo_to_sql.cc.

Referenced by my_tz_init().

{
  *length= sizeof(long);
  return (byte*) &entry->offset;
}

Here is the caller graph for this function:

Time_zone* my_tz_find	(	const String *	name,
		TABLE_LIST *	tz_tables
	)

Definition at line 2213 of file mysql_tzinfo_to_sql.cc.

Referenced by sys_var_thd_time_zone::check(), my_tz_find_with_opening_tz_tables(), my_tz_init(), and sys_var_thd_time_zone::set_default().

{
  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"));
  DBUG_ASSERT(!time_zone_tables_exist || tz_tables ||
              current_thd->slave_thread);

  if (!name)
    DBUG_RETURN(0);

  VOID(pthread_mutex_lock(&tz_LOCK));

  if (!str_to_offset(name->ptr(), name->length(), &offset))
  {

    if (!(result_tz= (Time_zone_offset *)hash_search(&offset_tzs,
                                                     (const byte *)&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 byte *) 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 *)hash_search(&tz_names,
                                                   (const byte *)name->ptr(),
                                                   name->length())))
      result_tz= tmp_tzname->tz;
    else if (time_zone_tables_exist && tz_tables)
      result_tz= tz_load_from_open_tables(name, tz_tables);
  }

  VOID(pthread_mutex_unlock(&tz_LOCK));

  DBUG_RETURN(result_tz);
}

Here is the caller graph for this function:

Time_zone* my_tz_find_with_opening_tz_tables	(	THD *	thd,
		const String *	name
	)

Definition at line 2289 of file mysql_tzinfo_to_sql.cc.

{
  Time_zone *tz;
  DBUG_ENTER("my_tz_find_with_opening_tables");
  DBUG_ASSERT(thd);
  DBUG_ASSERT(thd->slave_thread); // intended for use with slave thread only

  if (!(tz= my_tz_find(name, 0)) && time_zone_tables_exist)
  {
    /*
      Probably we have not loaded this time zone yet so let us look it up in
      our time zone tables. Note that if we don't have tz tables on this
      slave, we don't even try.
    */
    TABLE_LIST tables[MY_TZ_TABLES_COUNT];
    TABLE_LIST *dummy;
    TABLE_LIST **dummyp= &dummy;
    tz_init_table_list(tables, &dummyp);
    if (simple_open_n_lock_tables(thd, tables))
      DBUG_RETURN(0);
    tz= my_tz_find(name, tables);
    /* We need to close tables _now_ to not pollute coming query */
    close_thread_tables(thd);
  }
  DBUG_RETURN(tz);
}

void my_tz_free

(

)

Definition at line 1752 of file mysql_tzinfo_to_sql.cc.

Referenced by clean_up(), and my_tz_init().

{
  if (tz_inited)
  {
    tz_inited= 0;
    VOID(pthread_mutex_destroy(&tz_LOCK));
    hash_free(&offset_tzs);
    hash_free(&tz_names);
    free_root(&tz_storage, MYF(0));
  }
}

Here is the caller graph for this function:

TABLE_LIST* my_tz_get_table_list	(	THD *	thd,
		TABLE_LIST ***	global_next_ptr
	)

Definition at line 1511 of file mysql_tzinfo_to_sql.cc.

{
  TABLE_LIST *tz_tabs;
  DBUG_ENTER("my_tz_get_table_list");

  if (!time_zone_tables_exist)
    DBUG_RETURN(0);

  if (!(tz_tabs= (TABLE_LIST *)thd->alloc(sizeof(TABLE_LIST) *
                                          MY_TZ_TABLES_COUNT)))
    DBUG_RETURN(&fake_time_zone_tables_list);

  tz_init_table_list(tz_tabs, global_next_ptr);

  DBUG_RETURN(tz_tabs);
}

my_bool my_tz_init	(	THD *	org_thd,
		const char *	default_tzname,
		my_bool	bootstrap
	)

Definition at line 1555 of file mysql_tzinfo_to_sql.cc.

Referenced by main().

{
  THD *thd;
  TABLE_LIST *tables= 0;
  TABLE_LIST tables_buff[1+MY_TZ_TABLES_COUNT], **last_global_next_ptr;
  TABLE *table;
  Tz_names_entry *tmp_tzname;
  my_bool return_val= 1;
  char db[]= "mysql";
  int res;
  DBUG_ENTER("my_tz_init");

  /*
    To be able to run this from boot, we allocate a temporary THD
  */
  if (!(thd= new THD))
    DBUG_RETURN(1);
  thd->thread_stack= (char*) &thd;
  thd->store_globals();

  /* Init all memory structures that require explicit destruction */
  if (hash_init(&tz_names, &my_charset_latin1, 20,
                0, 0, (hash_get_key)my_tz_names_get_key, 0, 0))
  {
    sql_print_error("Fatal error: OOM while initializing time zones");
    goto end;
  }
  if (hash_init(&offset_tzs, &my_charset_latin1, 26, 0, 0,
                (hash_get_key)my_offset_tzs_get_key, 0, 0))
  {
    sql_print_error("Fatal error: OOM while initializing time zones");
    hash_free(&tz_names);
    goto end;
  }
  init_alloc_root(&tz_storage, 32 * 1024, 0);
  VOID(pthread_mutex_init(&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 byte *)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_setting_default_tz;
  }

  /*
    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(db, sizeof(db)-1);
  bzero((char*) &tables_buff, sizeof(TABLE_LIST));
  tables_buff[0].alias= tables_buff[0].table_name=
    (char*)"time_zone_leap_second";
  tables_buff[0].lock_type= TL_READ;
  tables_buff[0].db= db;
  /*
    Fill TABLE_LIST for the rest of the time zone describing tables
    and link it to first one.
  */
  last_global_next_ptr= &(tables_buff[0].next_global);
  tz_init_table_list(tables_buff + 1, &last_global_next_ptr);

  if (simple_open_n_lock_tables(thd, tables_buff))
  {
    sql_print_warning("Can't open and lock time zone table: %s "
                      "trying to live without them", thd->net.last_error);
    /* We will try emulate that everything is ok */
    return_val= time_zone_tables_exist= 0;
    goto end_with_setting_default_tz;
  }
  tables= tables_buff + 1;

  /*
    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= tables_buff[0].table;
  /*
    It is OK to ignore ha_index_init()/ha_index_end() return values since
    mysql.time_zone* tables are MyISAM and these operations always succeed
    for MyISAM.
  */
  (void)table->file->ha_index_init(0, 1);
  table->use_all_columns();

  tz_leapcnt= 0;

  res= table->file->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=%lld offset=%ld",
       tz_leapcnt, (longlong)tz_lsis[tz_leapcnt-1].ls_trans,
       tz_lsis[tz_leapcnt-1].ls_corr));

    res= table->file->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_tzname(default_tzname, &my_charset_latin1);
    if (!(global_system_variables.time_zone= my_tz_find(&tmp_tzname, tables)))
    {
      sql_print_error("Fatal error: Illegal or unknown default time zone '%s'",
                      default_tzname);
      return_val= 1;
    }
  }

end_with_close:
  thd->version--; /* Force close to free memory */
  close_thread_tables(thd);

end_with_cleanup:

  /* if there were error free time zone describing structs */
  if (return_val)
    my_tz_free();
end:
  delete thd;
  if (org_thd)
    org_thd->store_globals();                   /* purecov: inspected */
  else
  {
    /* Remember that we don't have a THD */
    my_pthread_setspecific_ptr(THR_THD,  0);
    my_pthread_setspecific_ptr(THR_MALLOC,  0);
  }
  DBUG_RETURN(return_val);
}

Here is the caller graph for this function:

byte* my_tz_names_get_key	(	Tz_names_entry *	entry,
		uint *	length,
		my_bool not_used	__attribute__((unused))
	)

Definition at line 1416 of file mysql_tzinfo_to_sql.cc.

Referenced by my_tz_init().

{
  *length= entry->name.length();
  return (byte*) entry->name.ptr();
}

Here is the caller graph for this function:

static my_bool prepare_tz_info	(	TIME_ZONE_INFO *	sp,
		MEM_ROOT *	storage
	)			[static]

Definition at line 315 of file mysql_tzinfo_to_sql.cc.

References st_time_zone_info::fallback_tti, LINT_INIT, MY_TIME_T_MIN, st_time_zone_info::revcnt, st_time_zone_info::timecnt, ttinfo::tt_isdst, st_time_zone_info::ttis, st_time_zone_info::typecnt, and TZ_MAX_REV_RANGES.

Referenced by tz_load_from_open_tables().

{
  my_time_t cur_t= MY_TIME_T_MIN;
  my_time_t cur_l, end_t, 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];

  LINT_INIT(end_l);

  /*
    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= 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;
}

Here is the caller graph for this function:

static my_time_t sec_since_epoch	(	int	year,
		int	mon,
		int	mday,
		int	hour,
		int	min,
		int	sec
	)			[static]

Definition at line 782 of file mysql_tzinfo_to_sql.cc.

References DAYS_PER_NYEAR, DBUG_ASSERT, EPOCH_YEAR, HOURS_PER_DAY, isleap, LEAPS_THRU_END_OF, MINS_PER_HOUR, MONS_PER_YEAR, and SECS_PER_MIN.

Referenced by sec_since_epoch_TIME(), Time_zone_offset::TIME_to_gmt_sec(), and TIME_to_gmt_sec().

{
#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;
}

Here is the caller graph for this function:

my_time_t sec_since_epoch_TIME

(

TIME *

t

)

Definition at line 815 of file mysql_tzinfo_to_sql.cc.

Referenced by Event_scheduler::run().

{
  return sec_since_epoch(t->year, t->month, t->day,
                         t->hour, t->minute, t->second);
}

Here is the caller graph for this function:

static void sec_to_TIME	(	TIME *	tmp,
		my_time_t	t,
		long	offset
	)			[static]

Definition at line 542 of file mysql_tzinfo_to_sql.cc.

References st_mysql_time::day, DAYS_PER_NYEAR, EPOCH_YEAR, st_mysql_time::hour, isleap, LEAPS_THRU_END_OF, st_mysql_time::minute, st_mysql_time::month, MYSQL_TIMESTAMP_DATETIME, st_mysql_time::neg, st_mysql_time::second, st_mysql_time::second_part, SECS_PER_DAY, SECS_PER_HOUR, SECS_PER_MIN, st_mysql_time::time_type, and st_mysql_time::year.

Referenced by Time_zone_offset::gmt_sec_to_TIME(), and gmt_sec_to_TIME().

{
  long days;
  long rem;
  int y;
  int yleap;
  const uint *ip;

  days= t / SECS_PER_DAY;
  rem= 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 TIME members */
  tmp->neg= 0; tmp->second_part= 0;
  tmp->time_type= MYSQL_TIMESTAMP_DATETIME;
}

Here is the caller graph for this function:

my_bool str_to_offset	(	const char *	str,
		uint	length,
		long *	offset
	)

Definition at line 2112 of file mysql_tzinfo_to_sql.cc.

References MINS_PER_HOUR, my_charset_latin1, my_isdigit, SECS_PER_HOUR, and SECS_PER_MIN.

Referenced by my_tz_find().

{
  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;
}

Here is the caller graph for this function:

static my_time_t TIME_to_gmt_sec	(	const TIME *	t,
		const TIME_ZONE_INFO *	sp,
		my_bool *	in_dst_time_gap
	)			[static]

Definition at line 895 of file mysql_tzinfo_to_sql.cc.

References st_mysql_time::day, DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, find_time_range(), st_mysql_time::hour, st_mysql_time::minute, st_mysql_time::month, st_time_zone_info::revcnt, st_time_zone_info::revtis, st_time_zone_info::revts, revtinfo::rt_offset, revtinfo::rt_type, sec_since_epoch(), st_mysql_time::second, SECS_PER_MIN, and st_mysql_time::year.

Referenced by Time_zone_db::TIME_to_gmt_sec().

{
  my_time_t local_t;
  uint saved_seconds;
  uint i;
  DBUG_ENTER("TIME_to_gmt_sec");

  /* We need this for correct leap seconds handling */
  if (t->second < SECS_PER_MIN)
    saved_seconds= 0;
  else
    saved_seconds= t->second;

  /*
    NOTE If we want to convert full my_time_t range without MySQL
    restrictions we should catch overflow here somehow.
  */

  local_t= sec_since_epoch(t->year, t->month, t->day,
                           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.
    */
    DBUG_RETURN(0);
  }

  /* binary search for our range */
  i= find_time_range(local_t, sp->revts, sp->revcnt);

  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.
    */
    *in_dst_time_gap= 1;
    DBUG_RETURN(sp->revts[i] - sp->revtis[i].rt_offset + saved_seconds);
  }
  else
    DBUG_RETURN(local_t - sp->revtis[i].rt_offset + saved_seconds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void tz_init_table_list	(	TABLE_LIST *	tz_tabs,
		TABLE_LIST ***	global_next_ptr
	)			[static]

Definition at line 1451 of file mysql_tzinfo_to_sql.cc.

References bzero, st_table_list::db, st_table_list::db_length, LEX_STRING::length, st_table_list::lock_type, MY_TZ_TABLES_COUNT, st_table_list::next_global, st_table_list::prev_global, LEX_STRING::str, st_table_list::table_name_length, TL_READ, tz_tables_db_name, and tz_tables_names.

Referenced by my_tz_find_with_opening_tz_tables(), my_tz_get_table_list(), and my_tz_init().

{
  bzero(tz_tabs, sizeof(TABLE_LIST) * MY_TZ_TABLES_COUNT);

  for (int i= 0; i < MY_TZ_TABLES_COUNT; i++)
  {
    tz_tabs[i].alias= tz_tabs[i].table_name= tz_tables_names[i].str;
    tz_tabs[i].table_name_length= tz_tables_names[i].length;
    tz_tabs[i].db= tz_tables_db_name.str;
    tz_tabs[i].db_length= tz_tables_db_name.length;
    tz_tabs[i].lock_type= 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;
  }

  /* Link into global list */
  tz_tabs[0].prev_global= *global_next_ptr;
  **global_next_ptr= tz_tabs;
  /* Update last-global-pointer to point to pointer in last table */
  *global_next_ptr= &tz_tabs[MY_TZ_TABLES_COUNT-1].next_global;
}

Here is the caller graph for this function:

static Time_zone* tz_load_from_open_tables	(	const String *	tz_name,
		TABLE_LIST *	tz_tables
	)			[static]

Definition at line 1787 of file mysql_tzinfo_to_sql.cc.

References ALIGN_SIZE, alloc_root(), bzero, DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, EXTRA_DEBUG, HA_ERR_END_OF_FILE, HA_ERR_KEY_NOT_FOUND, HA_READ_KEY_EXACT, String::length(), max, MAX_FIELD_WIDTH, memcpy, my_charset_latin1, my_hash_insert(), MY_TZNAME_MAX, Tz_names_entry::name, new(), st_table_list::next_local, prepare_tz_info(), String::ptr(), String::set(), sql_print_error(), strmake(), st_table_list::table, TRUE, ttinfo::tt_abbrind, ttinfo::tt_gmtoff, ttinfo::tt_isdst, Tz_names_entry::tz, tz_lsis, TZ_MAX_CHARS, TZ_MAX_TIMES, TZ_MAX_TYPES, tz_names, tz_storage, and st_table::use_all_columns().

Referenced by my_tz_find().

{
  TABLE *table= 0;
  TIME_ZONE_INFO *tz_info;
  Tz_names_entry *tmp_tzname;
  Time_zone *return_val= 0;
  int res;
  uint tzid, ttid;
  my_time_t ttime;
  char buff[MAX_FIELD_WIDTH];
  String abbr(buff, sizeof(buff), &my_charset_latin1);
  char *alloc_buff, *tz_name_buff;
  /*
    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[max(TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1)))];
#endif
  DBUG_ENTER("tz_load_from_open_tables");

  /* Prepare tz_info for loading also let us make copy of time zone name */
  if (!(alloc_buff= 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;
  }
  tz_info= (TIME_ZONE_INFO *)alloc_buff;
  bzero(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());

  /*
    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->use_all_columns();
  table->field[0]->store(tz_name->ptr(), tz_name->length(),
                         &my_charset_latin1);
  /*
    It is OK to ignore ha_index_init()/ha_index_end() return values since
    mysql.time_zone* tables are MyISAM and these operations always succeed
    for MyISAM.
  */
  (void)table->file->ha_index_init(0, 1);

  if (table->file->index_read(table->record[0], (byte*)table->field[0]->ptr,
                              0, 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 '%s'", tz_name_buff);
#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;
  table->use_all_columns();
  tz_tables= tz_tables->next_local;
  table->field[0]->store((longlong) tzid, TRUE);
  (void)table->file->ha_index_init(0, 1);

  if (table->file->index_read(table->record[0], (byte*)table->field[0]->ptr,
                              0, 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)
  {
    tz_info->leapcnt= tz_leapcnt;
    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;
  table->use_all_columns();
  tz_tables= tz_tables->next_local;
  table->field[0]->store((longlong) tzid, TRUE);
  (void)table->file->ha_index_init(0, 1);

  // FIXME Is there any better approach than explicitly specifying 4 ???
  res= table->file->index_read(table->record[0], (byte*)table->field[0]->ptr,
                               4, 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 (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= tz_info->charcnt;
    memcpy(chars + tz_info->charcnt, abbr.ptr(), abbr.length());
    tz_info->charcnt+= abbr.length();
    chars[tz_info->charcnt]= 0;
    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 >= tz_info->typecnt);

    tz_info->typecnt= ttid + 1;

    res= table->file->index_next_same(table->record[0],
                                      (byte*)table->field[0]->ptr, 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 additionaly need records
    in ascending order by index scan also satisfies us.
  */
  table= tz_tables->table; 
  table->use_all_columns();
  table->field[0]->store((longlong) tzid, TRUE);
  (void)table->file->ha_index_init(0, 1);

  // FIXME Is there any better approach than explicitly specifying 4 ???
  res= table->file->index_read(table->record[0], (byte*)table->field[0]->ptr,
                               4, HA_READ_KEY_EXACT);
  while (!res)
  {
    ttime= (my_time_t)table->field[1]->val_int();
    ttid= (uint)table->field[2]->val_int();

    if (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 > 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[tz_info->timecnt]= ttime;
    types[tz_info->timecnt]= ttid;
    tz_info->timecnt++;

    DBUG_PRINT("info",
      ("time_zone_transition table: tz_id=%u tt_time=%lld tt_id=%u",
       tzid, (longlong)ttime, ttid));

    res= table->file->index_next_same(table->record[0],
                                      (byte*)table->field[0]->ptr, 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;

  /*
    Now we will allocate memory and init TIME_ZONE_INFO structure.
  */
  if (!(alloc_buff= 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));

  /*
    Let us check how correct our time zone description and build
    reversed map. We don't check for tz->timecnt < 1 since it ok for GMT.
  */
  if (tz_info->typecnt < 1)
  {
    sql_print_error("loading time zone without transition types");
    goto end;
  }
  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 byte *)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)
    (void)table->file->ha_index_end();

  DBUG_RETURN(return_val);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

TABLE_LIST fake_time_zone_tables_list

Definition at line 1481 of file mysql_tzinfo_to_sql.cc.

Referenced by my_tz_get_table_list().

const uint mon_lengths[2][MONS_PER_YEAR] [static]

Initial value:

{
  { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
  { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
}

Definition at line 504 of file mysql_tzinfo_to_sql.cc.

const uint mon_starts[2][MONS_PER_YEAR] [static]

Initial value:

{
  { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
  { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
}

Definition at line 510 of file mysql_tzinfo_to_sql.cc.

Time_zone* my_tz_SYSTEM = &tz_SYSTEM

Definition at line 1354 of file mysql_tzinfo_to_sql.cc.

Referenced by init_common_variables(), my_tz_init(), and sys_var_thd_time_zone::set_default().

Time_zone* my_tz_UTC = &tz_UTC

Definition at line 1353 of file mysql_tzinfo_to_sql.cc.

Referenced by Event_timed::compute_next_execution_time(), Event_timed::init_ends(), Event_timed::init_execute_at(), Event_timed::init_starts(), Event_timed::mark_last_executed(), Item_func_now_utc::store_now_in_TIME(), Item_func_curtime_utc::store_now_in_TIME(), and Item_func_curdate_utc::store_now_in_TIME().

HASH offset_tzs [static]

Definition at line 1357 of file mysql_tzinfo_to_sql.cc.

Referenced by my_tz_find(), my_tz_free(), and my_tz_init().

bool time_zone_tables_exist = 1 [static]

Definition at line 1382 of file mysql_tzinfo_to_sql.cc.

bool tz_inited = 0 [static]

Definition at line 1368 of file mysql_tzinfo_to_sql.cc.

uint tz_leapcnt = 0 [static]

Definition at line 1374 of file mysql_tzinfo_to_sql.cc.

pthread_mutex_t tz_LOCK [static]

Definition at line 1367 of file mysql_tzinfo_to_sql.cc.

LS_INFO* tz_lsis = 0 [static]

Definition at line 1375 of file mysql_tzinfo_to_sql.cc.

Referenced by my_tz_init(), and tz_load_from_open_tables().

HASH tz_names [static]

Definition at line 1356 of file mysql_tzinfo_to_sql.cc.

Referenced by my_tz_find(), my_tz_free(), my_tz_init(), and tz_load_from_open_tables().

MEM_ROOT tz_storage [static]

Definition at line 1358 of file mysql_tzinfo_to_sql.cc.

Referenced by my_tz_find(), my_tz_free(), my_tz_init(), and tz_load_from_open_tables().

Time_zone_system tz_SYSTEM [static]

Definition at line 1351 of file mysql_tzinfo_to_sql.cc.

const String tz_SYSTEM_name("SYSTEM", 6,&my_charset_latin1) [static]

Referenced by Time_zone_system::get_name().

const LEX_STRING tz_tables_db_name = { C_STRING_WITH_LEN("mysql")} [static]

Definition at line 1400 of file mysql_tzinfo_to_sql.cc.

Referenced by tz_init_table_list().

const LEX_STRING tz_tables_names[MY_TZ_TABLES_COUNT] [static]

Initial value:

{
  { C_STRING_WITH_LEN("time_zone_name")},
  { C_STRING_WITH_LEN("time_zone")},
  { C_STRING_WITH_LEN("time_zone_transition_type")},
  { C_STRING_WITH_LEN("time_zone_transition")}
}

Definition at line 1390 of file mysql_tzinfo_to_sql.cc.

Referenced by tz_init_table_list().

Time_zone_utc tz_UTC [static]

Definition at line 1350 of file mysql_tzinfo_to_sql.cc.

const uint year_lengths[2] [static]

Initial value:

{
  DAYS_PER_NYEAR, DAYS_PER_LYEAR
}

Definition at line 516 of file mysql_tzinfo_to_sql.cc.

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.