my_time.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:25k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2004 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.  This program is free software; you can redistribute it and/or modify
  3.  it under the terms of the GNU General Public License as published by
  4.  the Free Software Foundation; either version 2 of the License, or
  5.  (at your option) any later version.
  6.  This program is distributed in the hope that it will be useful,
  7.  but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.  GNU General Public License for more details.
  10.  You should have received a copy of the GNU General Public License
  11.  along with this program; if not, write to the Free Software
  12.  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #include <my_time.h>
  14. #include <m_string.h>
  15. #include <m_ctype.h>
  16. /* Windows version of localtime_r() is declared in my_ptrhead.h */
  17. #include <my_pthread.h>
  18. ulonglong log_10_int[20]=
  19. {
  20.   1, 10, 100, 1000, 10000UL, 100000UL, 1000000UL, 10000000UL,
  21.   ULL(100000000), ULL(1000000000), ULL(10000000000), ULL(100000000000),
  22.   ULL(1000000000000), ULL(10000000000000), ULL(100000000000000),
  23.   ULL(1000000000000000), ULL(10000000000000000), ULL(100000000000000000),
  24.   ULL(1000000000000000000), ULL(10000000000000000000)
  25. };
  26. /* Position for YYYY-DD-MM HH-MM-DD.FFFFFF AM in default format */
  27. static uchar internal_format_positions[]=
  28. {0, 1, 2, 3, 4, 5, 6, (uchar) 255};
  29. static char time_separator=':';
  30. static ulong const days_at_timestart=719528; /* daynr at 1970.01.01 */
  31. uchar days_in_month[]= {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0};
  32. /*
  33.   Offset of system time zone from UTC in seconds used to speed up 
  34.   work of my_system_gmt_sec() function.
  35. */
  36. static long my_time_zone=0;
  37. /*
  38.   Convert a timestamp string to a MYSQL_TIME value.
  39.   SYNOPSIS
  40.     str_to_datetime()
  41.     str                 String to parse
  42.     length              Length of string
  43.     l_time              Date is stored here
  44.     flags               Bitmap of following items
  45.                         TIME_FUZZY_DATE    Set if we should allow partial dates
  46.                         TIME_DATETIME_ONLY Set if we only allow full datetimes.
  47.     was_cut             Set to 1 if value was cut during conversion or to 0
  48.                         otherwise.
  49.   DESCRIPTION
  50.     At least the following formats are recogniced (based on number of digits)
  51.     YYMMDD, YYYYMMDD, YYMMDDHHMMSS, YYYYMMDDHHMMSS
  52.     YY-MM-DD, YYYY-MM-DD, YY-MM-DD HH.MM.SS
  53.     YYYYMMDDTHHMMSS  where T is a the character T (ISO8601)
  54.     Also dates where all parts are zero are allowed
  55.     The second part may have an optional .###### fraction part.
  56.   NOTES
  57.    This function should work with a format position vector as long as the
  58.    following things holds:
  59.    - All date are kept together and all time parts are kept together
  60.    - Date and time parts must be separated by blank
  61.    - Second fractions must come after second part and be separated
  62.      by a '.'.  (The second fractions are optional)
  63.    - AM/PM must come after second fractions (or after seconds if no fractions)
  64.    - Year must always been specified.
  65.    - If time is before date, then we will use datetime format only if
  66.      the argument consist of two parts, separated by space.
  67.      Otherwise we will assume the argument is a date.
  68.    - The hour part must be specified in hour-minute-second order.
  69.   RETURN VALUES
  70.     MYSQL_TIMESTAMP_NONE        String wasn't a timestamp, like
  71.                                 [DD [HH:[MM:[SS]]]].fraction.
  72.                                 l_time is not changed.
  73.     MYSQL_TIMESTAMP_DATE        DATE string (YY MM and DD parts ok)
  74.     MYSQL_TIMESTAMP_DATETIME    Full timestamp
  75.     MYSQL_TIMESTAMP_ERROR       Timestamp with wrong values.
  76.                                 All elements in l_time is set to 0
  77. */
  78. #define MAX_DATE_PARTS 8
  79. enum enum_mysql_timestamp_type
  80. str_to_datetime(const char *str, uint length, MYSQL_TIME *l_time,
  81.                 uint flags, int *was_cut)
  82. {
  83.   uint field_length, year_length, digits, i, number_of_fields;
  84.   uint date[MAX_DATE_PARTS], date_len[MAX_DATE_PARTS];
  85.   uint add_hours= 0, start_loop;
  86.   ulong not_zero_date, allow_space;
  87.   bool is_internal_format;
  88.   const char *pos, *last_field_pos;
  89.   const char *end=str+length;
  90.   const uchar *format_position;
  91.   bool found_delimitier= 0, found_space= 0;
  92.   uint frac_pos, frac_len;
  93.   DBUG_ENTER("str_to_datetime");
  94.   DBUG_PRINT("ENTER",("str: %.*s",length,str));
  95.   LINT_INIT(field_length);
  96.   LINT_INIT(year_length);
  97.   LINT_INIT(last_field_pos);
  98.   *was_cut= 0;
  99.   /* Skip space at start */
  100.   for (; str != end && my_isspace(&my_charset_latin1, *str) ; str++)
  101.     ;
  102.   if (str == end || ! my_isdigit(&my_charset_latin1, *str))
  103.   {
  104.     *was_cut= 1;
  105.     DBUG_RETURN(MYSQL_TIMESTAMP_NONE);
  106.   }
  107.   is_internal_format= 0;
  108.   /* This has to be changed if want to activate different timestamp formats */
  109.   format_position= internal_format_positions;
  110.   /*
  111.     Calculate number of digits in first part.
  112.     If length= 8 or >= 14 then year is of format YYYY.
  113.     (YYYY-MM-DD,  YYYYMMDD, YYYYYMMDDHHMMSS)
  114.   */
  115.   for (pos=str;
  116.        pos != end && (my_isdigit(&my_charset_latin1,*pos) || *pos == 'T');
  117.        pos++)
  118.     ;
  119.   digits= (uint) (pos-str);
  120.   start_loop= 0;                                /* Start of scan loop */
  121.   date_len[format_position[0]]= 0;              /* Length of year field */
  122.   if (pos == end)
  123.   {
  124.     /* Found date in internal format (only numbers like YYYYMMDD) */
  125.     year_length= (digits == 4 || digits == 8 || digits >= 14) ? 4 : 2;
  126.     field_length= year_length;
  127.     is_internal_format= 1;
  128.     format_position= internal_format_positions;
  129.   }
  130.   else
  131.   {
  132.     if (format_position[0] >= 3)                /* If year is after HHMMDD */
  133.     {
  134.       /*
  135.         If year is not in first part then we have to determinate if we got
  136.         a date field or a datetime field.
  137.         We do this by checking if there is two numbers separated by
  138.         space in the input.
  139.       */
  140.       while (pos < end && !my_isspace(&my_charset_latin1, *pos))
  141.         pos++;
  142.       while (pos < end && !my_isdigit(&my_charset_latin1, *pos))
  143.         pos++;
  144.       if (pos == end)
  145.       {
  146.         if (flags & TIME_DATETIME_ONLY)
  147.         {
  148.           *was_cut= 1;
  149.           DBUG_RETURN(MYSQL_TIMESTAMP_NONE);   /* Can't be a full datetime */
  150.         }
  151.         /* Date field.  Set hour, minutes and seconds to 0 */
  152.         date[0]= date[1]= date[2]= date[3]= date[4]= 0;
  153.         start_loop= 5;                         /* Start with first date part */
  154.       }
  155.     }
  156.     field_length= format_position[0] == 0 ? 4 : 2;
  157.   }
  158.   /*
  159.     Only allow space in the first "part" of the datetime field and:
  160.     - after days, part seconds
  161.     - before and after AM/PM (handled by code later)
  162.     2003-03-03 20:00:20 AM
  163.     20:00:20.000000 AM 03-03-2000
  164.   */
  165.   i= max((uint) format_position[0], (uint) format_position[1]);
  166.   set_if_bigger(i, (uint) format_position[2]);
  167.   allow_space= ((1 << i) | (1 << format_position[6]));
  168.   allow_space&= (1 | 2 | 4 | 8);
  169.   not_zero_date= 0;
  170.   for (i = start_loop;
  171.        i < MAX_DATE_PARTS-1 && str != end &&
  172.          my_isdigit(&my_charset_latin1,*str);
  173.        i++)
  174.   {
  175.     const char *start= str;
  176.     ulong tmp_value= (uint) (uchar) (*str++ - '0');
  177.     while (str != end && my_isdigit(&my_charset_latin1,str[0]) &&
  178.            (!is_internal_format || --field_length))
  179.     {
  180.       tmp_value=tmp_value*10 + (ulong) (uchar) (*str - '0');
  181.       str++;
  182.     }
  183.     date_len[i]= (uint) (str - start);
  184.     if (tmp_value > 999999)                     /* Impossible date part */
  185.     {
  186.       *was_cut= 1;
  187.       DBUG_RETURN(MYSQL_TIMESTAMP_NONE);
  188.     }
  189.     date[i]=tmp_value;
  190.     not_zero_date|= tmp_value;
  191.     /* Length of next field */
  192.     field_length= format_position[i+1] == 0 ? 4 : 2;
  193.     if ((last_field_pos= str) == end)
  194.     {
  195.       i++;                                      /* Register last found part */
  196.       break;
  197.     }
  198.     /* Allow a 'T' after day to allow CCYYMMDDT type of fields */
  199.     if (i == format_position[2] && *str == 'T')
  200.     {
  201.       str++;                                    /* ISO8601:  CCYYMMDDThhmmss */
  202.       continue;
  203.     }
  204.     if (i == format_position[5])                /* Seconds */
  205.     {
  206.       if (*str == '.')                          /* Followed by part seconds */
  207.       {
  208.         str++;
  209.         field_length= 6;                        /* 6 digits */
  210.       }
  211.       continue;
  212.       /* No part seconds */
  213.       date[++i]= 0;
  214.     }
  215.     while (str != end &&
  216.            (my_ispunct(&my_charset_latin1,*str) ||
  217.             my_isspace(&my_charset_latin1,*str)))
  218.     {
  219.       if (my_isspace(&my_charset_latin1,*str))
  220.       {
  221.         if (!(allow_space & (1 << i)))
  222.         {
  223.           *was_cut= 1;
  224.           DBUG_RETURN(MYSQL_TIMESTAMP_NONE);
  225.         }
  226.         found_space= 1;
  227.       }
  228.       str++;
  229.       found_delimitier= 1;                      /* Should be a 'normal' date */
  230.     }
  231.     /* Check if next position is AM/PM */
  232.     if (i == format_position[6])                /* Seconds, time for AM/PM */
  233.     {
  234.       i++;                                      /* Skip AM/PM part */
  235.       if (format_position[7] != 255)            /* If using AM/PM */
  236.       {
  237.         if (str+2 <= end && (str[1] == 'M' || str[1] == 'm'))
  238.         {
  239.           if (str[0] == 'p' || str[0] == 'P')
  240.             add_hours= 12;
  241.           else if (str[0] != 'a' || str[0] != 'A')
  242.             continue;                           /* Not AM/PM */
  243.           str+= 2;                              /* Skip AM/PM */
  244.           /* Skip space after AM/PM */
  245.           while (str != end && my_isspace(&my_charset_latin1,*str))
  246.             str++;
  247.         }
  248.       }
  249.     }
  250.     last_field_pos= str;
  251.   }
  252.   if (found_delimitier && !found_space && (flags & TIME_DATETIME_ONLY))
  253.   {
  254.     *was_cut= 1;
  255.     DBUG_RETURN(MYSQL_TIMESTAMP_NONE);          /* Can't be a datetime */
  256.   }
  257.   str= last_field_pos;
  258.   number_of_fields= i - start_loop;
  259.   while (i < MAX_DATE_PARTS)
  260.   {
  261.     date_len[i]= 0;
  262.     date[i++]= 0;
  263.   }
  264.   if (!is_internal_format)
  265.   {
  266.     year_length= date_len[(uint) format_position[0]];
  267.     if (!year_length)                           /* Year must be specified */
  268.     {
  269.       *was_cut= 1;
  270.       DBUG_RETURN(MYSQL_TIMESTAMP_NONE);
  271.     }
  272.     l_time->year=               date[(uint) format_position[0]];
  273.     l_time->month=              date[(uint) format_position[1]];
  274.     l_time->day=                date[(uint) format_position[2]];
  275.     l_time->hour=               date[(uint) format_position[3]];
  276.     l_time->minute=             date[(uint) format_position[4]];
  277.     l_time->second=             date[(uint) format_position[5]];
  278.     frac_pos= (uint) format_position[6];
  279.     frac_len= date_len[frac_pos];
  280.     if (frac_len < 6)
  281.       date[frac_pos]*= (uint) log_10_int[6 - frac_len];
  282.     l_time->second_part= date[frac_pos];
  283.     if (format_position[7] != (uchar) 255)
  284.     {
  285.       if (l_time->hour > 12)
  286.       {
  287.         *was_cut= 1;
  288.         goto err;
  289.       }
  290.       l_time->hour= l_time->hour%12 + add_hours;
  291.     }
  292.   }
  293.   else
  294.   {
  295.     l_time->year=       date[0];
  296.     l_time->month=      date[1];
  297.     l_time->day=        date[2];
  298.     l_time->hour=       date[3];
  299.     l_time->minute=     date[4];
  300.     l_time->second=     date[5];
  301.     if (date_len[6] < 6)
  302.       date[6]*= (uint) log_10_int[6 - date_len[6]];
  303.     l_time->second_part=date[6];
  304.   }
  305.   l_time->neg= 0;
  306.   if (year_length == 2 && not_zero_date)
  307.     l_time->year+= (l_time->year < YY_PART_YEAR ? 2000 : 1900);
  308.   if (number_of_fields < 3 ||
  309.       l_time->year > 9999 || l_time->month > 12 ||
  310.       l_time->day > 31 || l_time->hour > 23 ||
  311.       l_time->minute > 59 || l_time->second > 59 ||
  312.       (!(flags & TIME_FUZZY_DATE) && (l_time->month == 0 || l_time->day == 0)))
  313.   {
  314.     /* Only give warning for a zero date if there is some garbage after */
  315.     if (!not_zero_date)                         /* If zero date */
  316.     {
  317.       for (; str != end ; str++)
  318.       {
  319.         if (!my_isspace(&my_charset_latin1, *str))
  320.         {
  321.           not_zero_date= 1;                     /* Give warning */
  322.           break;
  323.         }
  324.       }
  325.     }
  326.     if (not_zero_date)
  327.       *was_cut= 1;
  328.     goto err;
  329.   }
  330.   l_time->time_type= (number_of_fields <= 3 ?
  331.                       MYSQL_TIMESTAMP_DATE : MYSQL_TIMESTAMP_DATETIME);
  332.   for (; str != end ; str++)
  333.   {
  334.     if (!my_isspace(&my_charset_latin1,*str))
  335.     {
  336.       *was_cut= 1;
  337.       break;
  338.     }
  339.   }
  340.   DBUG_RETURN(l_time->time_type=
  341.               (number_of_fields <= 3 ? MYSQL_TIMESTAMP_DATE :
  342.                                        MYSQL_TIMESTAMP_DATETIME));
  343. err:
  344.   bzero((char*) l_time, sizeof(*l_time));
  345.   DBUG_RETURN(MYSQL_TIMESTAMP_ERROR);
  346. }
  347. /*
  348.  Convert a time string to a TIME struct.
  349.   SYNOPSIS
  350.    str_to_time()
  351.    str                  A string in full TIMESTAMP format or
  352.                         [-] DAYS [H]H:MM:SS, [H]H:MM:SS, [M]M:SS, [H]HMMSS,
  353.                         [M]MSS or [S]S
  354.                         There may be an optional [.second_part] after seconds
  355.    length               Length of str
  356.    l_time               Store result here
  357.    was_cut              Set to 1 if value was cut during conversion or to 0
  358.                         otherwise.
  359.    NOTES
  360.      Because of the extra days argument, this function can only
  361.      work with times where the time arguments are in the above order.
  362.    RETURN
  363.      0  ok
  364.      1  error
  365. */
  366. bool str_to_time(const char *str, uint length, MYSQL_TIME *l_time,
  367.                  int *was_cut)
  368. {
  369.   long date[5],value;
  370.   const char *end=str+length, *end_of_days;
  371.   bool found_days,found_hours;
  372.   uint state;
  373.   l_time->neg=0;
  374.   *was_cut= 0;
  375.   for (; str != end && my_isspace(&my_charset_latin1,*str) ; str++)
  376.     length--;
  377.   if (str != end && *str == '-')
  378.   {
  379.     l_time->neg=1;
  380.     str++;
  381.     length--;
  382.   }
  383.   if (str == end)
  384.     return 1;
  385.   /* Check first if this is a full TIMESTAMP */
  386.   if (length >= 12)
  387.   {                                             /* Probably full timestamp */
  388.     enum enum_mysql_timestamp_type
  389.       res= str_to_datetime(str, length, l_time,
  390.                            (TIME_FUZZY_DATE | TIME_DATETIME_ONLY), was_cut);
  391.     if ((int) res >= (int) MYSQL_TIMESTAMP_ERROR)
  392.       return res == MYSQL_TIMESTAMP_ERROR;
  393.     /* We need to restore was_cut flag since str_to_datetime can modify it */
  394.     *was_cut= 0;
  395.   }
  396.   /* Not a timestamp. Try to get this as a DAYS_TO_SECOND string */
  397.   for (value=0; str != end && my_isdigit(&my_charset_latin1,*str) ; str++)
  398.     value=value*10L + (long) (*str - '0');
  399.   /* Skip all space after 'days' */
  400.   end_of_days= str;
  401.   for (; str != end && my_isspace(&my_charset_latin1, str[0]) ; str++)
  402.     ;
  403.   LINT_INIT(state);
  404.   found_days=found_hours=0;
  405.   if ((uint) (end-str) > 1 && str != end_of_days &&
  406.       my_isdigit(&my_charset_latin1, *str))
  407.   {                                             /* Found days part */
  408.     date[0]= value;
  409.     state= 1;                                   /* Assume next is hours */
  410.     found_days= 1;
  411.   }
  412.   else if ((end-str) > 1 &&  *str == time_separator &&
  413.            my_isdigit(&my_charset_latin1, str[1]))
  414.   {
  415.     date[0]=0;                                  /* Assume we found hours */
  416.     date[1]=value;
  417.     state=2;
  418.     found_hours=1;
  419.     str++;                                      /* skip ':' */
  420.   }
  421.   else
  422.   {
  423.     /* String given as one number; assume HHMMSS format */
  424.     date[0]= 0;
  425.     date[1]= value/10000;
  426.     date[2]= value/100 % 100;
  427.     date[3]= value % 100;
  428.     state=4;
  429.     goto fractional;
  430.   }
  431.   /* Read hours, minutes and seconds */
  432.   for (;;)
  433.   {
  434.     for (value=0; str != end && my_isdigit(&my_charset_latin1,*str) ; str++)
  435.       value=value*10L + (long) (*str - '0');
  436.     date[state++]=value;
  437.     if (state == 4 || (end-str) < 2 || *str != time_separator ||
  438.         !my_isdigit(&my_charset_latin1,str[1]))
  439.       break;
  440.     str++;                                      /* Skip time_separator (':') */
  441.   }
  442.   if (state != 4)
  443.   {                                             /* Not HH:MM:SS */
  444.     /* Fix the date to assume that seconds was given */
  445.     if (!found_hours && !found_days)
  446.     {
  447.       bmove_upp((char*) (date+4), (char*) (date+state),
  448.                 sizeof(long)*(state-1));
  449.       bzero((char*) date, sizeof(long)*(4-state));
  450.     }
  451.     else
  452.       bzero((char*) (date+state), sizeof(long)*(4-state));
  453.   }
  454. fractional:
  455.   /* Get fractional second part */
  456.   if ((end-str) >= 2 && *str == '.' && my_isdigit(&my_charset_latin1,str[1]))
  457.   {
  458.     uint field_length=5;
  459.     str++; value=(uint) (uchar) (*str - '0');
  460.     while (++str != end && 
  461.            my_isdigit(&my_charset_latin1,str[0]) && 
  462.            field_length--)
  463.       value=value*10 + (uint) (uchar) (*str - '0');
  464.     if (field_length)
  465.       value*= (long) log_10_int[field_length];
  466.     date[4]=value;
  467.   }
  468.   else
  469.     date[4]=0;
  470.   if (internal_format_positions[7] != 255)
  471.   {
  472.     /* Read a possible AM/PM */
  473.     while (str != end && my_isspace(&my_charset_latin1, *str))
  474.       str++;
  475.     if (str+2 <= end && (str[1] == 'M' || str[1] == 'm'))
  476.     {
  477.       if (str[0] == 'p' || str[0] == 'P')
  478.       {
  479.         str+= 2;
  480.         date[1]= date[1]%12 + 12;
  481.       }
  482.       else if (str[0] == 'a' || str[0] == 'A')
  483.         str+=2;
  484.     }
  485.   }
  486.   /* Some simple checks */
  487.   if (date[2] >= 60 || date[3] >= 60)
  488.   {
  489.     *was_cut= 1;
  490.     return 1;
  491.   }
  492.   l_time->year=         0;                      /* For protocol::store_time */
  493.   l_time->month=        0;
  494.   l_time->day=          date[0];
  495.   l_time->hour=         date[1];
  496.   l_time->minute=       date[2];
  497.   l_time->second=       date[3];
  498.   l_time->second_part=  date[4];
  499.   l_time->time_type= MYSQL_TIMESTAMP_TIME;
  500.   /* Check if there is garbage at end of the TIME specification */
  501.   if (str != end)
  502.   {
  503.     do
  504.     {
  505.       if (!my_isspace(&my_charset_latin1,*str))
  506.       {
  507.         *was_cut= 1;
  508.         break;
  509.       }
  510.     } while (++str != end);
  511.   }
  512.   return 0;
  513. }
  514. /*
  515.   Prepare offset of system time zone from UTC for my_system_gmt_sec() func.
  516.   SYNOPSIS
  517.     init_time()
  518. */
  519. void init_time(void)
  520. {
  521.   time_t seconds;
  522.   struct tm *l_time,tm_tmp;
  523.   MYSQL_TIME my_time;
  524.   bool not_used;
  525.   seconds= (time_t) time((time_t*) 0);
  526.   localtime_r(&seconds,&tm_tmp);
  527.   l_time= &tm_tmp;
  528.   my_time_zone= 3600; /* Comp. for -3600 in my_gmt_sec */
  529.   my_time.year= (uint) l_time->tm_year+1900;
  530.   my_time.month= (uint) l_time->tm_mon+1;
  531.   my_time.day= (uint) l_time->tm_mday;
  532.   my_time.hour= (uint) l_time->tm_hour;
  533.   my_time.minute= (uint) l_time->tm_min;
  534.   my_time.second= (uint) l_time->tm_sec;
  535.   my_system_gmt_sec(&my_time, &my_time_zone, &not_used); /* Init my_time_zone */
  536. }
  537. /* Calculate nr of day since year 0 in new date-system (from 1615) */
  538. long calc_daynr(uint year,uint month,uint day)
  539. {
  540.   long delsum;
  541.   int temp;
  542.   DBUG_ENTER("calc_daynr");
  543.   if (year == 0 && month == 0 && day == 0)
  544.     DBUG_RETURN(0); /* Skip errors */
  545.   if (year < 200)
  546.   {
  547.     if ((year=year+1900) < 1900+YY_PART_YEAR)
  548.       year+=100;
  549.   }
  550.   delsum= (long) (365L * year+ 31*(month-1) +day);
  551.   if (month <= 2)
  552.       year--;
  553.   else
  554.     delsum-= (long) (month*4+23)/10;
  555.   temp=(int) ((year/100+1)*3)/4;
  556.   DBUG_PRINT("exit",("year: %d  month: %d  day: %d -> daynr: %ld",
  557.      year+(month <= 2),month,day,delsum+year/4-temp));
  558.   DBUG_RETURN(delsum+(int) year/4-temp);
  559. } /* calc_daynr */
  560. /*
  561.   Convert time in MYSQL_TIME representation in system time zone to its
  562.   my_time_t form (number of seconds in UTC since begginning of Unix Epoch).
  563.   SYNOPSIS
  564.     my_system_gmt_sec()
  565.       t               - time value to be converted
  566.       my_timezone     - pointer to long where offset of system time zone
  567.                         from UTC will be stored for caching
  568.       in_dst_time_gap - set to true if time falls into spring time-gap
  569.   NOTES
  570.     The idea is to cache the time zone offset from UTC (including daylight 
  571.     saving time) for the next call to make things faster. But currently we 
  572.     just calculate this offset during startup (by calling init_time() 
  573.     function) and use it all the time.
  574.     Time value provided should be legal time value (e.g. '2003-01-01 25:00:00'
  575.     is not allowed).
  576.   RETURN VALUE
  577.     Time in UTC seconds since Unix Epoch representation.
  578. */
  579. my_time_t 
  580. my_system_gmt_sec(const MYSQL_TIME *t, long *my_timezone, bool *in_dst_time_gap)
  581. {
  582.   uint loop;
  583.   time_t tmp;
  584.   struct tm *l_time,tm_tmp;
  585.   long diff, current_timezone;
  586.   /*
  587.     Calculate the gmt time based on current time and timezone
  588.     The -1 on the end is to ensure that if have a date that exists twice
  589.     (like 2002-10-27 02:00:0 MET), we will find the initial date.
  590.     By doing -3600 we will have to call localtime_r() several times, but
  591.     I couldn't come up with a better way to get a repeatable result :(
  592.     We can't use mktime() as it's buggy on many platforms and not thread safe.
  593.     Note: this code assumes that our time_t estimation is not too far away
  594.     from real value (we assume that localtime_r(tmp) will return something
  595.     within 24 hrs from t) which is probably true for all current time zones.
  596.   */
  597.   tmp=(time_t) (((calc_daynr((uint) t->year,(uint) t->month,(uint) t->day) -
  598.   (long) days_at_timestart)*86400L + (long) t->hour*3600L +
  599.  (long) (t->minute*60 + t->second)) + (time_t) my_time_zone -
  600. 3600);
  601.   current_timezone= my_time_zone;
  602.   localtime_r(&tmp,&tm_tmp);
  603.   l_time=&tm_tmp;
  604.   for (loop=0;
  605.        loop < 2 &&
  606.  (t->hour != (uint) l_time->tm_hour ||
  607.   t->minute != (uint) l_time->tm_min ||
  608.           t->second != (uint) l_time->tm_sec);
  609.        loop++)
  610.   { /* One check should be enough ? */
  611.     /* Get difference in days */
  612.     int days= t->day - l_time->tm_mday;
  613.     if (days < -1)
  614.       days= 1; /* Month has wrapped */
  615.     else if (days > 1)
  616.       days= -1;
  617.     diff=(3600L*(long) (days*24+((int) t->hour - (int) l_time->tm_hour)) +
  618.           (long) (60*((int) t->minute - (int) l_time->tm_min)) +
  619.           (long) ((int) t->second - (int) l_time->tm_sec));
  620.     current_timezone+= diff+3600; /* Compensate for -3600 above */
  621.     tmp+= (time_t) diff;
  622.     localtime_r(&tmp,&tm_tmp);
  623.     l_time=&tm_tmp;
  624.   }
  625.   /*
  626.     Fix that if we are in the non existing daylight saving time hour
  627.     we move the start of the next real hour.
  628.     This code doesn't handle such exotical thing as time-gaps whose length
  629.     is more than one hour or non-integer (latter can theoretically happen
  630.     if one of seconds will be removed due leap correction, or because of
  631.     general time correction like it happened for Africa/Monrovia time zone
  632.     in year 1972).
  633.   */
  634.   if (loop == 2 && t->hour != (uint) l_time->tm_hour)
  635.   {
  636.     int days= t->day - l_time->tm_mday;
  637.     if (days < -1)
  638.       days=1; /* Month has wrapped */
  639.     else if (days > 1)
  640.       days= -1;
  641.     diff=(3600L*(long) (days*24+((int) t->hour - (int) l_time->tm_hour))+
  642.   (long) (60*((int) t->minute - (int) l_time->tm_min)) +
  643.           (long) ((int) t->second - (int) l_time->tm_sec));
  644.     if (diff == 3600)
  645.       tmp+=3600 - t->minute*60 - t->second; /* Move to next hour */
  646.     else if (diff == -3600)
  647.       tmp-=t->minute*60 + t->second; /* Move to previous hour */
  648.     *in_dst_time_gap= 1;
  649.   }
  650.   *my_timezone= current_timezone;
  651.   
  652.   return (my_time_t) tmp;
  653. } /* my_system_gmt_sec */
  654. /* Set MYSQL_TIME structure to 0000-00-00 00:00:00.000000 */
  655. void set_zero_time(MYSQL_TIME *tm, enum enum_mysql_timestamp_type time_type)
  656. {
  657.   bzero((void*) tm, sizeof(*tm));
  658.   tm->time_type= time_type;
  659. }
  660. /*
  661.   Functions to convert time/date/datetime value to a string,
  662.   using default format.
  663.   This functions don't check that given TIME structure members are
  664.   in valid range. If they are not, return value won't reflect any
  665.   valid date either. Additionally, make_time doesn't take into
  666.   account time->day member: it's assumed that days have been converted
  667.   to hours already.
  668.   RETURN
  669.     number of characters written to 'to'
  670. */
  671. int my_time_to_str(const MYSQL_TIME *l_time, char *to)
  672. {
  673.   uint extra_hours= 0;
  674.   return my_sprintf(to, (to, "%s%02d:%02d:%02d",
  675.                          (l_time->neg ? "-" : ""),
  676.                          extra_hours+ l_time->hour,
  677.                          l_time->minute,
  678.                          l_time->second));
  679. }
  680. int my_date_to_str(const MYSQL_TIME *l_time, char *to)
  681. {
  682.   return my_sprintf(to, (to, "%04d-%02d-%02d",
  683.                          l_time->year,
  684.                          l_time->month,
  685.                          l_time->day));
  686. }
  687. int my_datetime_to_str(const MYSQL_TIME *l_time, char *to)
  688. {
  689.   return my_sprintf(to, (to, "%04d-%02d-%02d %02d:%02d:%02d",
  690.                          l_time->year,
  691.                          l_time->month,
  692.                          l_time->day,
  693.                          l_time->hour,
  694.                          l_time->minute,
  695.                          l_time->second));
  696. }
  697. /*
  698.   Convert struct DATE/TIME/DATETIME value to string using built-in
  699.   MySQL time conversion formats.
  700.   SYNOPSIS
  701.     my_TIME_to_string()
  702.   NOTE
  703.     The string must have at least MAX_DATE_STRING_REP_LENGTH bytes reserved.
  704. */
  705. int my_TIME_to_str(const MYSQL_TIME *l_time, char *to)
  706. {
  707.   switch (l_time->time_type) {
  708.   case MYSQL_TIMESTAMP_DATETIME:
  709.     return my_datetime_to_str(l_time, to);
  710.   case MYSQL_TIMESTAMP_DATE:
  711.     return my_date_to_str(l_time, to);
  712.   case MYSQL_TIMESTAMP_TIME:
  713.     return my_time_to_str(l_time, to);
  714.   case MYSQL_TIMESTAMP_NONE:
  715.   case MYSQL_TIMESTAMP_ERROR:
  716.     to[0]='';
  717.     return 0;
  718.   default:
  719.     DBUG_ASSERT(0);
  720.     return 0;
  721.   }
  722. }