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

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 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. /* Functions to handle date and time */
  14. #include "mysql_priv.h"
  15. #include <m_ctype.h>
  16. /* Some functions to calculate dates */
  17. #ifndef TESTTIME
  18. /* Calc weekday from daynr */
  19. /* Returns 0 for monday, 1 for tuesday .... */
  20. int calc_weekday(long daynr,bool sunday_first_day_of_week)
  21. {
  22.   DBUG_ENTER("calc_weekday");
  23.   DBUG_RETURN ((int) ((daynr + 5L + (sunday_first_day_of_week ? 1L : 0L)) % 7));
  24. }
  25. /* Calc days in one year. works with 0 <= year <= 99 */
  26. uint calc_days_in_year(uint year)
  27. {
  28.   return (year & 3) == 0 && (year%100 || (year%400 == 0 && year)) ?
  29.     366 : 365;
  30. }
  31. /*
  32.   The bits in week_format has the following meaning:
  33.    WEEK_MONDAY_FIRST (0)  If not set Sunday is first day of week
  34.              If set Monday is first day of week
  35.    WEEK_YEAR (1)   If not set Week is in range 0-53
  36.     Week 0 is returned for the the last week of the previous year (for
  37. a date at start of january) In this case one can get 53 for the
  38. first week of next year.  This flag ensures that the week is
  39. relevant for the given year. Note that this flag is only
  40. releveant if WEEK_JANUARY is not set.
  41.   If set  Week is in range 1-53.
  42. In this case one may get week 53 for a date in January (when
  43. the week is that last week of previous year) and week 1 for a
  44. date in December.
  45.   WEEK_FIRST_WEEKDAY (2)  If not set Weeks are numbered according
  46.     to ISO 8601:1988
  47.   If set The week that contains the first
  48. 'first-day-of-week' is week 1.
  49. ISO 8601:1988 means that if the week containing January 1 has
  50. four or more days in the new year, then it is week 1;
  51. Otherwise it is the last week of the previous year, and the
  52. next week is week 1.
  53. */
  54. uint calc_week(TIME *l_time, uint week_behaviour, uint *year)
  55. {
  56.   uint days;
  57.   ulong daynr=calc_daynr(l_time->year,l_time->month,l_time->day);
  58.   ulong first_daynr=calc_daynr(l_time->year,1,1);
  59.   bool monday_first= test(week_behaviour & WEEK_MONDAY_FIRST);
  60.   bool week_year= test(week_behaviour & WEEK_YEAR);
  61.   bool first_weekday= test(week_behaviour & WEEK_FIRST_WEEKDAY);
  62.   uint weekday=calc_weekday(first_daynr, !monday_first);
  63.   *year=l_time->year;
  64.   if (l_time->month == 1 && l_time->day <= 7-weekday)
  65.   {
  66.     if (!week_year && 
  67. (first_weekday && weekday != 0 ||
  68.  !first_weekday && weekday >= 4))
  69.       return 0;
  70.     week_year= 1;
  71.     (*year)--;
  72.     first_daynr-= (days=calc_days_in_year(*year));
  73.     weekday= (weekday + 53*7- days) % 7;
  74.   }
  75.   if ((first_weekday && weekday != 0) ||
  76.       (!first_weekday && weekday >= 4))
  77.     days= daynr - (first_daynr+ (7-weekday));
  78.   else
  79.     days= daynr - (first_daynr - weekday);
  80.   if (week_year && days >= 52*7)
  81.   {
  82.     weekday= (weekday + calc_days_in_year(*year)) % 7;
  83.     if (!first_weekday && weekday < 4 ||
  84. first_weekday && weekday == 0)
  85.     {
  86.       (*year)++;
  87.       return 1;
  88.     }
  89.   }
  90.   return days/7+1;
  91. }
  92. /* Change a daynr to year, month and day */
  93. /* Daynr 0 is returned as date 00.00.00 */
  94. void get_date_from_daynr(long daynr,uint *ret_year,uint *ret_month,
  95.  uint *ret_day)
  96. {
  97.   uint year,temp,leap_day,day_of_year,days_in_year;
  98.   uchar *month_pos;
  99.   DBUG_ENTER("get_date_from_daynr");
  100.   if (daynr <= 365L || daynr >= 3652500)
  101.   { /* Fix if wrong daynr */
  102.     *ret_year= *ret_month = *ret_day =0;
  103.   }
  104.   else
  105.   {
  106.     year= (uint) (daynr*100 / 36525L);
  107.     temp=(((year-1)/100+1)*3)/4;
  108.     day_of_year=(uint) (daynr - (long) year * 365L) - (year-1)/4 +temp;
  109.     while (day_of_year > (days_in_year= calc_days_in_year(year)))
  110.     {
  111.       day_of_year-=days_in_year;
  112.       (year)++;
  113.     }
  114.     leap_day=0;
  115.     if (days_in_year == 366)
  116.     {
  117.       if (day_of_year > 31+28)
  118.       {
  119. day_of_year--;
  120. if (day_of_year == 31+28)
  121.   leap_day=1; /* Handle leapyears leapday */
  122.       }
  123.     }
  124.     *ret_month=1;
  125.     for (month_pos= days_in_month ;
  126.  day_of_year > (uint) *month_pos ;
  127.  day_of_year-= *(month_pos++), (*ret_month)++)
  128.       ;
  129.     *ret_year=year;
  130.     *ret_day=day_of_year+leap_day;
  131.   }
  132.   DBUG_VOID_RETURN;
  133. }
  134. /* Functions to handle periods */
  135. ulong convert_period_to_month(ulong period)
  136. {
  137.   ulong a,b;
  138.   if (period == 0)
  139.     return 0L;
  140.   if ((a=period/100) < YY_PART_YEAR)
  141.     a+=2000;
  142.   else if (a < 100)
  143.     a+=1900;
  144.   b=period%100;
  145.   return a*12+b-1;
  146. }
  147. ulong convert_month_to_period(ulong month)
  148. {
  149.   ulong year;
  150.   if (month == 0L)
  151.     return 0L;
  152.   if ((year=month/12) < 100)
  153.   {
  154.     year+=(year < YY_PART_YEAR) ? 2000 : 1900;
  155.   }
  156.   return year*100+month%12+1;
  157. }
  158. /*
  159.   Convert a timestamp string to a TIME value and produce a warning 
  160.   if string was truncated during conversion.
  161.   NOTE
  162.     See description of str_to_datetime() for more information.
  163. */
  164. timestamp_type
  165. str_to_datetime_with_warn(const char *str, uint length, TIME *l_time,
  166.                           uint flags)
  167. {
  168.   int was_cut;
  169.   timestamp_type ts_type= str_to_datetime(str, length, l_time, flags, &was_cut);
  170.   if (was_cut)
  171.     make_truncated_value_warning(current_thd, str, length, ts_type);
  172.   return ts_type;
  173. }
  174. /*
  175.   Convert a datetime from broken-down TIME representation to corresponding 
  176.   TIMESTAMP value.
  177.   SYNOPSIS
  178.     TIME_to_timestamp()
  179.       thd             - current thread
  180.       t               - datetime in broken-down representation, 
  181.       in_dst_time_gap - pointer to bool which is set to true if t represents
  182.                         value which doesn't exists (falls into the spring 
  183.                         time-gap) or to false otherwise.
  184.    
  185.   RETURN
  186.      Number seconds in UTC since start of Unix Epoch corresponding to t.
  187.      0 - t contains datetime value which is out of TIMESTAMP range.
  188.      
  189. */
  190. my_time_t TIME_to_timestamp(THD *thd, const TIME *t, bool *in_dst_time_gap)
  191. {
  192.   my_time_t timestamp;
  193.   *in_dst_time_gap= 0;
  194.   if (t->year < TIMESTAMP_MAX_YEAR && t->year > TIMESTAMP_MIN_YEAR ||
  195.       t->year == TIMESTAMP_MAX_YEAR && t->month == 1 && t->day == 1 ||
  196.       t->year == TIMESTAMP_MIN_YEAR && t->month == 12 && t->day == 31)
  197.   {
  198.     thd->time_zone_used= 1;
  199.     timestamp= thd->variables.time_zone->TIME_to_gmt_sec(t, in_dst_time_gap);
  200.     if (timestamp >= TIMESTAMP_MIN_VALUE && timestamp <= TIMESTAMP_MAX_VALUE)
  201.       return timestamp;
  202.   }
  203.   /* If we are here we have range error. */
  204.   return(0);
  205. }
  206. /*
  207.   Convert a time string to a TIME struct and produce a warning
  208.   if string was cut during conversion.
  209.   NOTE
  210.     See str_to_time() for more info.
  211. */
  212. bool
  213. str_to_time_with_warn(const char *str, uint length, TIME *l_time)
  214. {
  215.   int was_cut;
  216.   bool ret_val= str_to_time(str, length, l_time, &was_cut);
  217.   if (was_cut)
  218.     make_truncated_value_warning(current_thd, str, length, MYSQL_TIMESTAMP_TIME);
  219.   return ret_val;
  220. }
  221. /*
  222.   Convert datetime value specified as number to broken-down TIME 
  223.   representation and form value of DATETIME type as side-effect.
  224.   SYNOPSIS
  225.     number_to_TIME()
  226.       nr         - datetime value as number 
  227.       time_res   - pointer for structure for broken-down representation
  228.       fuzzy_date - indicates whenever we allow fuzzy dates
  229.       was_cut    - set ot 1 if there was some kind of error during 
  230.                    conversion or to 0 if everything was OK.
  231.   
  232.   DESCRIPTION
  233.     Convert a datetime value of formats YYMMDD, YYYYMMDD, YYMMDDHHMSS, 
  234.     YYYYMMDDHHMMSS to broken-down TIME representation. Return value in
  235.     YYYYMMDDHHMMSS format as side-effect.
  236.   
  237.     This function also checks if datetime value fits in DATETIME range.
  238.   RETURN VALUE
  239.     Datetime value in YYYYMMDDHHMMSS format.
  240.     If input value is not valid datetime value then 0 is returned. 
  241. */
  242. longlong number_to_TIME(longlong nr, TIME *time_res, bool fuzzy_date, 
  243.                         int *was_cut)
  244. {
  245.   long part1,part2;
  246.   *was_cut= 0;
  247.   
  248.   if (nr == LL(0) || nr >= LL(10000101000000))
  249.     goto ok;
  250.   if (nr < 101)
  251.     goto err;
  252.   if (nr <= (YY_PART_YEAR-1)*10000L+1231L)
  253.   {
  254.     nr= (nr+20000000L)*1000000L;                 // YYMMDD, year: 2000-2069
  255.     goto ok;
  256.   }
  257.   if (nr < (YY_PART_YEAR)*10000L+101L)
  258.     goto err;
  259.   if (nr <= 991231L)
  260.   {
  261.     nr= (nr+19000000L)*1000000L;                 // YYMMDD, year: 1970-1999
  262.     goto ok;
  263.   }
  264.   if (nr < 10000101L)
  265.     goto err;
  266.   if (nr <= 99991231L)
  267.   {
  268.     nr= nr*1000000L;
  269.     goto ok;
  270.   }
  271.   if (nr < 101000000L)
  272.     goto err;
  273.   if (nr <= (YY_PART_YEAR-1)*LL(10000000000)+LL(1231235959))
  274.   {
  275.     nr= nr+LL(20000000000000);                   // YYMMDDHHMMSS, 2000-2069
  276.     goto ok;
  277.   }
  278.   if (nr <  YY_PART_YEAR*LL(10000000000)+ LL(101000000))
  279.     goto err;
  280.   if (nr <= LL(991231235959))
  281.     nr= nr+LL(19000000000000); // YYMMDDHHMMSS, 1970-1999
  282.  ok:
  283.   part1=(long) (nr/LL(1000000));
  284.   part2=(long) (nr - (longlong) part1*LL(1000000));
  285.   time_res->year=  (int) (part1/10000L);  part1%=10000L;
  286.   time_res->month= (int) part1 / 100;
  287.   time_res->day=   (int) part1 % 100;
  288.   time_res->hour=  (int) (part2/10000L);  part2%=10000L;
  289.   time_res->minute=(int) part2 / 100;
  290.   time_res->second=(int) part2 % 100;
  291.     
  292.   if (time_res->year <= 9999 && time_res->month <= 12 && 
  293.       time_res->day <= 31 && time_res->hour <= 23 && 
  294.       time_res->minute <= 59 && time_res->second <= 59 &&
  295.       (fuzzy_date || (time_res->month != 0 && time_res->day != 0) || nr==0))
  296.     return nr;
  297.   
  298.  err:
  299.   
  300.   *was_cut= 1;
  301.   return LL(0);
  302. }
  303. /*
  304.   Convert a system time structure to TIME
  305. */
  306. void localtime_to_TIME(TIME *to, struct tm *from)
  307. {
  308.   to->neg=0;
  309.   to->second_part=0;
  310.   to->year= (int) ((from->tm_year+1900) % 10000);
  311.   to->month= (int) from->tm_mon+1;
  312.   to->day= (int) from->tm_mday;
  313.   to->hour= (int) from->tm_hour;
  314.   to->minute= (int) from->tm_min;
  315.   to->second=   (int) from->tm_sec;
  316. }
  317. void calc_time_from_sec(TIME *to, long seconds, long microseconds)
  318. {
  319.   long t_seconds;
  320.   to->hour= seconds/3600L;
  321.   t_seconds= seconds%3600L;
  322.   to->minute= t_seconds/60L;
  323.   to->second= t_seconds%60L;
  324.   to->second_part= microseconds;
  325. }
  326. /*
  327.   Parse a format string specification
  328.   SYNOPSIS
  329.     parse_date_time_format()
  330.     format_type Format of string (time, date or datetime)
  331.     format_str String to parse
  332.     format_length Length of string
  333.     date_time_format Format to fill in
  334.   NOTES
  335.     Fills in date_time_format->positions for all date time parts.
  336.     positions marks the position for a datetime element in the format string.
  337.     The position array elements are in the following order:
  338.     YYYY-DD-MM HH-MM-DD.FFFFFF AM
  339.     0    1  2  3  4  5  6      7
  340.     If positions[0]= 5, it means that year will be the forth element to
  341.     read from the parsed date string.
  342.   RETURN
  343.     0 ok
  344.     1 error
  345. */
  346. bool parse_date_time_format(timestamp_type format_type, 
  347.     const char *format, uint format_length,
  348.     DATE_TIME_FORMAT *date_time_format)
  349. {
  350.   uint offset= 0, separators= 0;
  351.   const char *ptr= format, *format_str;
  352.   const char *end= ptr+format_length;
  353.   uchar *dt_pos= date_time_format->positions;
  354.   /* need_p is set if we are using AM/PM format */
  355.   bool need_p= 0, allow_separator= 0;
  356.   ulong part_map= 0, separator_map= 0;
  357.   const char *parts[16];
  358.   date_time_format->time_separator= 0;
  359.   date_time_format->flag= 0; // For future
  360.   /*
  361.     Fill position with 'dummy' arguments to found out if a format tag is
  362.     used twice (This limit's the format to 255 characters, but this is ok)
  363.   */
  364.   dt_pos[0]= dt_pos[1]= dt_pos[2]= dt_pos[3]=
  365.     dt_pos[4]= dt_pos[5]= dt_pos[6]= dt_pos[7]= 255;
  366.   for (; ptr != end; ptr++)
  367.   {
  368.     if (*ptr == '%' && ptr+1 != end)
  369.     {
  370.       uint position;
  371.       LINT_INIT(position);
  372.       switch (*++ptr) {
  373.       case 'y': // Year
  374.       case 'Y':
  375. position= 0;
  376. break;
  377.       case 'c': // Month
  378.       case 'm':
  379. position= 1;
  380. break;
  381.       case 'd':
  382.       case 'e':
  383. position= 2;
  384. break;
  385.       case 'h':
  386.       case 'I':
  387.       case 'l':
  388. need_p= 1; // Need AM/PM
  389. /* Fall through */
  390.       case 'k':
  391.       case 'H':
  392. position= 3;
  393. break;
  394.       case 'i':
  395. position= 4;
  396. break;
  397.       case 's':
  398.       case 'S':
  399. position= 5;
  400. break;
  401.       case 'f':
  402. position= 6;
  403. if (dt_pos[5] != offset-1 || ptr[-2] != '.')
  404.   return 1; // Wrong usage of %f
  405. break;
  406.       case 'p': // AM/PM
  407. if (offset == 0) // Can't be first
  408.   return 0;
  409. position= 7;
  410. break;
  411.       default:
  412. return 1; // Unknown controll char
  413.       }
  414.       if (dt_pos[position] != 255) // Don't allow same tag twice
  415. return 1;
  416.       parts[position]= ptr-1;
  417.       /*
  418. If switching from time to date, ensure that all time parts
  419. are used
  420.       */
  421.       if (part_map && position <= 2 && !(part_map & (1 | 2 | 4)))
  422. offset=5;
  423.       part_map|= (ulong) 1 << position;
  424.       dt_pos[position]= offset++;
  425.       allow_separator= 1;
  426.     }
  427.     else
  428.     {
  429.       /*
  430. Don't allow any characters in format as this could easily confuse
  431. the date reader
  432.       */
  433.       if (!allow_separator)
  434. return 1; // No separator here
  435.       allow_separator= 0; // Don't allow two separators
  436.       separators++;
  437.       /* Store in separator_map which parts are punct characters */
  438.       if (my_ispunct(&my_charset_latin1, *ptr))
  439. separator_map|= (ulong) 1 << (offset-1);
  440.       else if (!my_isspace(&my_charset_latin1, *ptr))
  441. return 1;
  442.     }
  443.   }
  444.   /* If no %f, specify it after seconds.  Move %p up, if necessary */
  445.   if ((part_map & 32) && !(part_map & 64))
  446.   {
  447.     dt_pos[6]= dt_pos[5] +1;
  448.     parts[6]= parts[5]; // For later test in (need_p)
  449.     if (dt_pos[6] == dt_pos[7]) // Move %p one step up if used
  450.       dt_pos[7]++;
  451.   }
  452.   /*
  453.     Check that we have not used a non legal format specifier and that all
  454.     format specifiers have been used
  455.     The last test is to ensure that %p is used if and only if
  456.     it's needed.
  457.   */
  458.   if ((format_type == MYSQL_TIMESTAMP_DATETIME &&
  459.        !test_all_bits(part_map, (1 | 2 | 4 | 8 | 16 | 32))) ||
  460.       (format_type == MYSQL_TIMESTAMP_DATE && part_map != (1 | 2 | 4)) ||
  461.       (format_type == MYSQL_TIMESTAMP_TIME &&
  462.        !test_all_bits(part_map, 8 | 16 | 32)) ||
  463.       !allow_separator || // %option should be last
  464.       (need_p && dt_pos[6] +1 != dt_pos[7]) ||
  465.       (need_p ^ (dt_pos[7] != 255)))
  466.     return 1;
  467.   if (dt_pos[6] != 255) // If fractional seconds
  468.   {
  469.     /* remove fractional seconds from later tests */
  470.     uint pos= dt_pos[6] -1;
  471.     /* Remove separator before %f from sep map */
  472.     separator_map= ((separator_map & ((ulong) (1 << pos)-1)) |
  473.     ((separator_map & ~((ulong) (1 << pos)-1)) >> 1));
  474.     if (part_map & 64)       
  475.     {
  476.       separators--; // There is always a separator
  477.       need_p= 1; // force use of separators
  478.     }
  479.   }
  480.   /*
  481.     Remove possible separator before %p from sep_map
  482.     (This can either be at position 3, 4, 6 or 7) h.m.d.%f %p
  483.   */
  484.   if (dt_pos[7] != 255)
  485.   {
  486.     if (need_p && parts[7] != parts[6]+2)
  487.       separators--;
  488.   }     
  489.   /*
  490.     Calculate if %p is in first or last part of the datetime field
  491.     At this point we have either %H-%i-%s %p 'year parts' or
  492.     'year parts' &H-%i-%s %p" as %f was removed above
  493.   */
  494.   offset= dt_pos[6] <= 3 ? 3 : 6;
  495.   /* Remove separator before %p from sep map */
  496.   separator_map= ((separator_map & ((ulong) (1 << offset)-1)) |
  497.   ((separator_map & ~((ulong) (1 << offset)-1)) >> 1));
  498.   format_str= 0;
  499.   switch (format_type) {
  500.   case MYSQL_TIMESTAMP_DATE:
  501.     format_str= known_date_time_formats[INTERNAL_FORMAT].date_format;
  502.     /* fall through */
  503.   case MYSQL_TIMESTAMP_TIME:
  504.     if (!format_str)
  505.       format_str=known_date_time_formats[INTERNAL_FORMAT].time_format;
  506.     /*
  507.       If there is no separators, allow the internal format as we can read
  508.       this.  If separators are used, they must be between each part
  509.     */
  510.     if (format_length == 6 && !need_p &&
  511. !my_strnncoll(&my_charset_bin,
  512.       (const uchar *) format, 6, 
  513.       (const uchar *) format_str, 6))
  514.       return 0;
  515.     if (separator_map == (1 | 2))
  516.     {
  517.       if (format_type == MYSQL_TIMESTAMP_TIME)
  518.       {
  519. if (*(format+2) != *(format+5))
  520.   break; // Error
  521. /* Store the character used for time formats */
  522. date_time_format->time_separator= *(format+2);
  523.       }
  524.       return 0;
  525.     }
  526.     break;
  527.   case MYSQL_TIMESTAMP_DATETIME:
  528.     /*
  529.       If there is no separators, allow the internal format as we can read
  530.       this.  If separators are used, they must be between each part.
  531.       Between DATE and TIME we also allow space as separator
  532.     */
  533.     if ((format_length == 12 && !need_p &&
  534.  !my_strnncoll(&my_charset_bin, 
  535.        (const uchar *) format, 12,
  536.        (const uchar*) known_date_time_formats[INTERNAL_FORMAT].datetime_format,
  537.        12)) ||
  538. (separators == 5 && separator_map == (1 | 2 | 8 | 16)))
  539.       return 0;
  540.     break;
  541.   default:
  542.     DBUG_ASSERT(1);
  543.     break;
  544.   }
  545.   return 1; // Error
  546. }
  547. /*
  548.   Create a DATE_TIME_FORMAT object from a format string specification
  549.   SYNOPSIS
  550.     date_time_format_make()
  551.     format_type Format to parse (time, date or datetime)
  552.     format_str String to parse
  553.     format_length Length of string
  554.   NOTES
  555.     The returned object should be freed with my_free()
  556.   RETURN
  557.     NULL ponter: Error
  558.     new object
  559. */
  560. DATE_TIME_FORMAT
  561. *date_time_format_make(timestamp_type format_type,
  562.        const char *format_str, uint format_length)
  563. {
  564.   DATE_TIME_FORMAT tmp;
  565.   if (format_length && format_length < 255 &&
  566.       !parse_date_time_format(format_type, format_str,
  567.       format_length, &tmp))
  568.   {
  569.     tmp.format.str=    (char*) format_str;
  570.     tmp.format.length= format_length;
  571.     return date_time_format_copy((THD *)0, &tmp);
  572.   }
  573.   return 0;
  574. }
  575. /*
  576.   Create a copy of a DATE_TIME_FORMAT object
  577.   SYNOPSIS
  578.     date_and_time_format_copy()
  579.     thd Set if variable should be allocated in thread mem
  580.     format format to copy
  581.   NOTES
  582.     The returned object should be freed with my_free()
  583.   RETURN
  584.     NULL ponter: Error
  585.     new object
  586. */
  587. DATE_TIME_FORMAT *date_time_format_copy(THD *thd, DATE_TIME_FORMAT *format)
  588. {
  589.   DATE_TIME_FORMAT *new_format;
  590.   ulong length= sizeof(*format) + format->format.length + 1;
  591.   if (thd)
  592.     new_format= (DATE_TIME_FORMAT *) thd->alloc(length);
  593.   else
  594.     new_format=  (DATE_TIME_FORMAT *) my_malloc(length, MYF(MY_WME));
  595.   if (new_format)
  596.   {
  597.     /* Put format string after current pos */
  598.     new_format->format.str= (char*) (new_format+1);
  599.     memcpy((char*) new_format->positions, (char*) format->positions,
  600.    sizeof(format->positions));
  601.     new_format->time_separator= format->time_separator;
  602.     /* We make the string null terminated for easy printf in SHOW VARIABLES */
  603.     memcpy((char*) new_format->format.str, format->format.str,
  604.    format->format.length);
  605.     new_format->format.str[format->format.length]= 0;
  606.     new_format->format.length= format->format.length;
  607.   }
  608.   return new_format;
  609. }
  610. KNOWN_DATE_TIME_FORMAT known_date_time_formats[6]=
  611. {
  612.   {"USA", "%m.%d.%Y", "%Y-%m-%d %H.%i.%s", "%h:%i:%s %p" },
  613.   {"JIS", "%Y-%m-%d", "%Y-%m-%d %H:%i:%s", "%H:%i:%s" },
  614.   {"ISO", "%Y-%m-%d", "%Y-%m-%d %H:%i:%s", "%H:%i:%s" },
  615.   {"EUR", "%d.%m.%Y", "%Y-%m-%d %H.%i.%s", "%H.%i.%s" },
  616.   {"INTERNAL", "%Y%m%d",   "%Y%m%d%H%i%s", "%H%i%s" },
  617.   { 0, 0, 0, 0 }
  618. };
  619. /*
  620.    Return format string according format name.
  621.    If name is unknown, result is NULL
  622. */
  623. const char *get_date_time_format_str(KNOWN_DATE_TIME_FORMAT *format,
  624.      timestamp_type type)
  625. {
  626.   switch (type) {
  627.   case MYSQL_TIMESTAMP_DATE:
  628.     return format->date_format;
  629.   case MYSQL_TIMESTAMP_DATETIME:
  630.     return format->datetime_format;
  631.   case MYSQL_TIMESTAMP_TIME:
  632.     return format->time_format;
  633.   default:
  634.     DBUG_ASSERT(0); // Impossible
  635.     return 0;
  636.   }
  637. }
  638. /****************************************************************************
  639.   Functions to create default time/date/datetime strings
  640.  
  641.   NOTE:
  642.     For the moment the DATE_TIME_FORMAT argument is ignored becasue
  643.     MySQL doesn't support comparing of date/time/datetime strings that
  644.     are not in arbutary order as dates are compared as strings in some
  645.     context)
  646.     This functions don't check that given TIME structure members are
  647.     in valid range. If they are not, return value won't reflect any 
  648.     valid date either. Additionally, make_time doesn't take into
  649.     account time->day member: it's assumed that days have been converted
  650.     to hours already.
  651. ****************************************************************************/
  652. void make_time(const DATE_TIME_FORMAT *format __attribute__((unused)),
  653.                const TIME *l_time, String *str)
  654. {
  655.   uint length= (uint) my_time_to_str(l_time, (char*) str->ptr());
  656.   str->length(length);
  657.   str->set_charset(&my_charset_bin);
  658. }
  659. void make_date(const DATE_TIME_FORMAT *format __attribute__((unused)),
  660.                const TIME *l_time, String *str)
  661. {
  662.   uint length= (uint) my_date_to_str(l_time, (char*) str->ptr());
  663.   str->length(length);
  664.   str->set_charset(&my_charset_bin);
  665. }
  666. void make_datetime(const DATE_TIME_FORMAT *format __attribute__((unused)),
  667.                    const TIME *l_time, String *str)
  668. {
  669.   uint length= (uint) my_datetime_to_str(l_time, (char*) str->ptr());
  670.   str->length(length);
  671.   str->set_charset(&my_charset_bin);
  672. }
  673. void make_truncated_value_warning(THD *thd, const char *str_val,
  674.   uint str_length, timestamp_type time_type)
  675. {
  676.   char warn_buff[MYSQL_ERRMSG_SIZE];
  677.   const char *type_str;
  678.   char buff[128];
  679.   String str(buff,(uint32) sizeof(buff), system_charset_info);
  680.   str.length(0);
  681.   str.append(str_val, str_length);
  682.   str.append('');
  683.   switch (time_type) {
  684.     case MYSQL_TIMESTAMP_DATE: 
  685.       type_str= "date";
  686.       break;
  687.     case MYSQL_TIMESTAMP_TIME:
  688.       type_str= "time";
  689.       break;
  690.     case MYSQL_TIMESTAMP_DATETIME:  // FALLTHROUGH
  691.     default:
  692.       type_str= "datetime";
  693.       break;
  694.   }
  695.   sprintf(warn_buff, ER(ER_TRUNCATED_WRONG_VALUE),
  696.   type_str, str.ptr());
  697.   push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  698.       ER_TRUNCATED_WRONG_VALUE, warn_buff);
  699. }
  700. /* Convert time value to integer in YYYYMMDDHHMMSS format */
  701. ulonglong TIME_to_ulonglong_datetime(const TIME *time)
  702. {
  703.   return ((ulonglong) (time->year * 10000UL +
  704.                        time->month * 100UL +
  705.                        time->day) * ULL(1000000) +
  706.           (ulonglong) (time->hour * 10000UL +
  707.                        time->minute * 100UL +
  708.                        time->second));
  709. }
  710. /* Convert TIME value to integer in YYYYMMDD format */
  711. ulonglong TIME_to_ulonglong_date(const TIME *time)
  712. {
  713.   return (ulonglong) (time->year * 10000UL + time->month * 100UL + time->day);
  714. }
  715. /*
  716.   Convert TIME value to integer in HHMMSS format.
  717.   This function doesn't take into account time->day member:
  718.   it's assumed that days have been converted to hours already.
  719. */
  720. ulonglong TIME_to_ulonglong_time(const TIME *time)
  721. {
  722.   return (ulonglong) (time->hour * 10000UL +
  723.                       time->minute * 100UL +
  724.                       time->second);
  725. }
  726. /*
  727.   Convert struct TIME (date and time split into year/month/day/hour/...
  728.   to a number in format YYYYMMDDHHMMSS (DATETIME),
  729.   YYYYMMDD (DATE)  or HHMMSS (TIME).
  730.   
  731.   SYNOPSIS
  732.     TIME_to_ulonglong()
  733.   DESCRIPTION
  734.     The function is used when we need to convert value of time item
  735.     to a number if it's used in numeric context, i. e.:
  736.     SELECT NOW()+1, CURDATE()+0, CURTIMIE()+0;
  737.     SELECT ?+1;
  738.   NOTE
  739.     This function doesn't check that given TIME structure members are
  740.     in valid range. If they are not, return value won't reflect any 
  741.     valid date either.
  742. */
  743. ulonglong TIME_to_ulonglong(const TIME *time)
  744. {
  745.   switch (time->time_type) {
  746.   case MYSQL_TIMESTAMP_DATETIME:
  747.     return TIME_to_ulonglong_datetime(time);
  748.   case MYSQL_TIMESTAMP_DATE:
  749.     return TIME_to_ulonglong_date(time);
  750.   case MYSQL_TIMESTAMP_TIME:
  751.     return TIME_to_ulonglong_time(time);
  752.   case MYSQL_TIMESTAMP_NONE:
  753.   case MYSQL_TIMESTAMP_ERROR:
  754.     return ULL(0);
  755.   default:
  756.     DBUG_ASSERT(0);
  757.   }
  758.   return 0;
  759. }
  760. #endif