开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
item_timefunc.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：72k
源码类别：

MySQL数据库

开发平台：

Visual C++

item_timefunc.cpp：源码内容
  1. /* Copyright (C) 2000-2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  18. /* This file defines all time functions */
  20. #ifdef USE_PRAGMA_IMPLEMENTATION
  21. #pragma implementation // gcc: Class implementation
  22. #endif
  24. #include "mysql_priv.h"
  25. #include <m_ctype.h>
  26. #include <time.h>
  28. /* TODO: Move month and days to language files */
  30. #define MAX_DAY_NUMBER 3652424L
  32. static const char *month_names[]=
  33. {
  34.   "January", "February", "March", "April", "May", "June", "July", "August",
  35.   "September", "October", "November", "December", NullS
  36. };
  38. TYPELIB month_names_typelib=
  39. { array_elements(month_names)-1,"", month_names, NULL };
  41. static const char *day_names[]=
  42. {
  43.   "Monday", "Tuesday", "Wednesday",
  44.   "Thursday", "Friday", "Saturday" ,"Sunday", NullS
  45. };
  47. TYPELIB day_names_typelib=
  48. { array_elements(day_names)-1,"", day_names, NULL};
  51. /*
  52.   OPTIMIZATION TODO:
  53.    - Replace the switch with a function that should be called for each
  54.      date type.
  55.    - Remove sprintf and opencode the conversion, like we do in
  56.      Field_datetime.
  58.   The reason for this functions existence is that as we don't have a
  59.   way to know if a datetime/time value has microseconds in them
  60.   we are now only adding microseconds to the output if the
  61.   value has microseconds.
  63.   We can't use a standard make_date_time() for this as we don't know
  64.   if someone will use %f in the format specifier in which case we would get
  65.   the microseconds twice.
  66. */
  68. static bool make_datetime(date_time_format_types format, TIME *ltime,
  69.   String *str)
  70. {
  71.   char *buff;
  72.   CHARSET_INFO *cs= &my_charset_bin;
  73.   uint length= 30;
  75.   if (str->alloc(length))
  76.     return 1;
  77.   buff= (char*) str->ptr();
  79.   switch (format) {
  80.   case TIME_ONLY:
  81.     length= cs->cset->snprintf(cs, buff, length, "%s%02d:%02d:%02d",
  82.        ltime->neg ? "-" : "",
  83.        ltime->hour, ltime->minute, ltime->second);
  84.     break;
  85.   case TIME_MICROSECOND:
  86.     length= cs->cset->snprintf(cs, buff, length, "%s%02d:%02d:%02d.%06d",
  87.        ltime->neg ? "-" : "",
  88.        ltime->hour, ltime->minute, ltime->second,
  89.        ltime->second_part);
  90.     break;
  91.   case DATE_ONLY:
  92.     length= cs->cset->snprintf(cs, buff, length, "%04d-%02d-%02d",
  93.        ltime->year, ltime->month, ltime->day);
  94.     break;
  95.   case DATE_TIME:
  96.     length= cs->cset->snprintf(cs, buff, length,
  97.        "%04d-%02d-%02d %02d:%02d:%02d",
  98.        ltime->year, ltime->month, ltime->day,
  99.        ltime->hour, ltime->minute, ltime->second);
  100.     break;
  101.   case DATE_TIME_MICROSECOND:
  102.     length= cs->cset->snprintf(cs, buff, length,
  103.        "%04d-%02d-%02d %02d:%02d:%02d.%06d",
  104.        ltime->year, ltime->month, ltime->day,
  105.        ltime->hour, ltime->minute, ltime->second,
  106.        ltime->second_part);
  107.     break;
  108.   }
  110.   str->length(length);
  111.   str->set_charset(cs);
  112.   return 0;
  113. }
  116. /*
  117.   Date formats corresponding to compound %r and %T conversion specifiers
  119.   Note: We should init at least first element of "positions" array
  120.         (first member) or hpux11 compiler will die horribly.
  121. */
  122. static DATE_TIME_FORMAT time_ampm_format= {{0}, '', 0,
  123.                                            {(char *)"%I:%i:%S %p", 11}};
  124. static DATE_TIME_FORMAT time_24hrs_format= {{0}, '', 0,
  125.                                             {(char *)"%H:%i:%S", 8}};
  127. /*
  128.   Extract datetime value to TIME struct from string value
  129.   according to format string. 
  131.   SYNOPSIS
  132.     extract_date_time()
  133.     format date/time format specification
  134.     val String to decode
  135.     length Length of string
  136.     l_time Store result here
  137.     cached_timestamp_type 
  138.                        It uses to get an appropriate warning
  139.                        in the case when the value is truncated.
  140.     sub_pattern_end    if non-zero then we are parsing string which
  141.                        should correspond compound specifier (like %T or
  142.                        %r) and this parameter is pointer to place where
  143.                        pointer to end of string matching this specifier
  144.                        should be stored.
  145.     NOTE
  146.      Possibility to parse strings matching to patterns equivalent to compound
  147.      specifiers is mainly intended for use from inside of this function in
  148.      order to understand %T and %r conversion specifiers, so number of
  149.      conversion specifiers that can be used in such sub-patterns is limited.
  150.      Also most of checks are skipped in this case.
  152.      If one adds new format specifiers to this function he should also
  153.      consider adding them to get_date_time_result_type() function.
  155.     RETURN
  156.       0 ok
  157.       1 error
  158. */
  160. static bool extract_date_time(DATE_TIME_FORMAT *format,
  161.       const char *val, uint length, TIME *l_time,
  162.                               timestamp_type cached_timestamp_type,
  163.                               const char **sub_pattern_end)
  164. {
  165.   int weekday= 0, yearday= 0, daypart= 0;
  166.   int week_number= -1;
  167.   int error= 0;
  168.   int  strict_week_number_year= -1;
  169.   int frac_part;
  170.   bool usa_time= 0;
  171.   bool sunday_first_n_first_week_non_iso;
  172.   bool strict_week_number;
  173.   bool strict_week_number_year_type;
  174.   const char *val_begin= val;
  175.   const char *val_end= val + length;
  176.   const char *ptr= format->format.str;
  177.   const char *end= ptr + format->format.length;
  178.   CHARSET_INFO *cs= &my_charset_bin;
  179.   DBUG_ENTER("extract_date_time");
  181.   LINT_INIT(strict_week_number);
  182.   /* Remove valgrind varnings when using gcc 3.3 and -O1 */
  183.   PURIFY_OR_LINT_INIT(strict_week_number_year_type);
  184.   PURIFY_OR_LINT_INIT(sunday_first_n_first_week_non_iso);
  186.   if (!sub_pattern_end)
  187.     bzero((char*) l_time, sizeof(*l_time));
  189.   for (; ptr != end && val != val_end; ptr++)
  190.   {
  192.     if (*ptr == '%' && ptr+1 != end)
  193.     {
  194.       int val_len;
  195.       char *tmp;
  197.       /* Skip pre-space between each argument */
  198.       while (val != val_end && my_isspace(cs, *val))
  199. val++;
  201.       val_len= (uint) (val_end - val);
  202.       switch (*++ptr) {
  203. /* Year */
  204.       case 'Y':
  205. tmp= (char*) val + min(4, val_len);
  206. l_time->year= (int) my_strtoll10(val, &tmp, &error);
  207. val= tmp;
  208. break;
  209.       case 'y':
  210. tmp= (char*) val + min(2, val_len);
  211. l_time->year= (int) my_strtoll10(val, &tmp, &error);
  212. val= tmp;
  213. l_time->year+= (l_time->year < YY_PART_YEAR ? 2000 : 1900);
  214. break;
  216. /* Month */
  217.       case 'm':
  218.       case 'c':
  219. tmp= (char*) val + min(2, val_len);
  220. l_time->month= (int) my_strtoll10(val, &tmp, &error);
  221. val= tmp;
  222. break;
  223.       case 'M':
  224.       case 'b':
  225. if ((l_time->month= check_word(&month_names_typelib,
  226.        val, val_end, &val)) <= 0)
  227.   goto err;
  228. break;
  229. /* Day */
  230.       case 'd':
  231.       case 'e':
  232. tmp= (char*) val + min(2, val_len);
  233. l_time->day= (int) my_strtoll10(val, &tmp, &error);
  234. val= tmp;
  235. break;
  236.       case 'D':
  237. tmp= (char*) val + min(2, val_len);
  238. l_time->day= (int) my_strtoll10(val, &tmp, &error);
  239. /* Skip 'st, 'nd, 'th .. */
  240. val= tmp + min((int) (end-tmp), 2);
  241. break;
  243. /* Hour */
  244.       case 'h':
  245.       case 'I':
  246.       case 'l':
  247. usa_time= 1;
  248. /* fall through */
  249.       case 'k':
  250.       case 'H':
  251. tmp= (char*) val + min(2, val_len);
  252. l_time->hour= (int) my_strtoll10(val, &tmp, &error);
  253. val= tmp;
  254. break;
  256. /* Minute */
  257.       case 'i':
  258. tmp= (char*) val + min(2, val_len);
  259. l_time->minute= (int) my_strtoll10(val, &tmp, &error);
  260. val= tmp;
  261. break;
  263. /* Second */
  264.       case 's':
  265.       case 'S':
  266. tmp= (char*) val + min(2, val_len);
  267. l_time->second= (int) my_strtoll10(val, &tmp, &error);
  268. val= tmp;
  269. break;
  271. /* Second part */
  272.       case 'f':
  273. tmp= (char*) val_end;
  274. if (tmp - val > 6)
  275.   tmp= (char*) val + 6;
  276. l_time->second_part= (int) my_strtoll10(val, &tmp, &error);
  277. frac_part= 6 - (tmp - val);
  278. if (frac_part > 0)
  279.   l_time->second_part*= (ulong) log_10_int[frac_part];
  280. val= tmp;
  281. break;
  283. /* AM / PM */
  284.       case 'p':
  285. if (val_len < 2 || ! usa_time)
  286.   goto err;
  287. if (!my_strnncoll(&my_charset_latin1,
  288.   (const uchar *) val, 2, 
  289.   (const uchar *) "PM", 2))
  290.   daypart= 12;
  291. else if (my_strnncoll(&my_charset_latin1,
  292.       (const uchar *) val, 2, 
  293.       (const uchar *) "AM", 2))
  294.   goto err;
  295. val+= 2;
  296. break;
  298. /* Exotic things */
  299.       case 'W':
  300.       case 'a':
  301. if ((weekday= check_word(&day_names_typelib, val, val_end, &val)) <= 0)
  302.   goto err;
  303. break;
  304.       case 'w':
  305. tmp= (char*) val + 1;
  306. if ((weekday= (int) my_strtoll10(val, &tmp, &error)) < 0 ||
  307.     weekday >= 7)
  308.   goto err;
  309.         /* We should use the same 1 - 7 scale for %w as for %W */
  310.         if (!weekday)
  311.           weekday= 7;
  312. val= tmp;
  313. break;
  314.       case 'j':
  315. tmp= (char*) val + min(val_len, 3);
  316. yearday= (int) my_strtoll10(val, &tmp, &error);
  317. val= tmp;
  318. break;
  320.         /* Week numbers */
  321.       case 'V':
  322.       case 'U':
  323.       case 'v':
  324.       case 'u':
  325.         sunday_first_n_first_week_non_iso= (*ptr=='U' || *ptr== 'V');
  326.         strict_week_number= (*ptr=='V' || *ptr=='v');
  327. tmp= (char*) val + min(val_len, 2);
  328. if ((week_number= (int) my_strtoll10(val, &tmp, &error)) < 0 ||
  329.             strict_week_number && !week_number ||
  330.             week_number > 53)
  331.           goto err;
  332. val= tmp;
  333. break;
  335.         /* Year used with 'strict' %V and %v week numbers */
  336.       case 'X':
  337.       case 'x':
  338.         strict_week_number_year_type= (*ptr=='X');
  339.         tmp= (char*) val + min(4, val_len);
  340.         strict_week_number_year= (int) my_strtoll10(val, &tmp, &error);
  341.         val= tmp;
  342.         break;
  344.         /* Time in AM/PM notation */
  345.       case 'r':
  346.         error= extract_date_time(&time_ampm_format, val,
  347.                                  (uint)(val_end - val), l_time,
  348.                                  cached_timestamp_type, &val);
  349.         break;
  351.         /* Time in 24-hour notation */
  352.       case 'T':
  353.         error= extract_date_time(&time_24hrs_format, val,
  354.                                  (uint)(val_end - val), l_time,
  355.                                  cached_timestamp_type, &val);
  356.         break;
  358.         /* Conversion specifiers that match classes of characters */
  359.       case '.':
  360. while (my_ispunct(cs, *val) && val != val_end)
  361.   val++;
  362. break;
  363.       case '@':
  364. while (my_isalpha(cs, *val) && val != val_end)
  365.   val++;
  366. break;
  367.       case '#':
  368. while (my_isdigit(cs, *val) && val != val_end)
  369.   val++;
  370. break;
  371.       default:
  372. goto err;
  373.       }
  374.       if (error) // Error from my_strtoll10
  375. goto err;
  376.     }
  377.     else if (!my_isspace(cs, *ptr))
  378.     {
  379.       if (*val != *ptr)
  380. goto err;
  381.       val++;
  382.     }
  383.   }
  384.   if (usa_time)
  385.   {
  386.     if (l_time->hour > 12 || l_time->hour < 1)
  387.       goto err;
  388.     l_time->hour= l_time->hour%12+daypart;
  389.   }
  391.   /*
  392.     If we are recursively called for parsing string matching compound
  393.     specifiers we are already done.
  394.   */
  395.   if (sub_pattern_end)
  396.   {
  397.     *sub_pattern_end= val;
  398.     DBUG_RETURN(0);
  399.   }
  401.   if (yearday > 0)
  402.   {
  403.     uint days= calc_daynr(l_time->year,1,1) +  yearday - 1;
  404.     if (days <= 0 || days >= MAX_DAY_NUMBER)
  405.       goto err;
  406.     get_date_from_daynr(days,&l_time->year,&l_time->month,&l_time->day);
  407.   }
  409.   if (week_number >= 0 && weekday)
  410.   {
  411.     int days;
  412.     uint weekday_b;
  414.     /*
  415.       %V,%v require %X,%x resprectively,
  416.       %U,%u should be used with %Y and not %X or %x
  417.     */
  418.     if (strict_week_number &&
  419.         (strict_week_number_year < 0 ||
  420.          strict_week_number_year_type != sunday_first_n_first_week_non_iso) ||
  421.         !strict_week_number && strict_week_number_year >= 0)
  422.       goto err;
  424.     /* Number of days since year 0 till 1st Jan of this year */
  425.     days= calc_daynr((strict_week_number ? strict_week_number_year :
  426.                                            l_time->year),
  427.                      1, 1);
  428.     /* Which day of week is 1st Jan of this year */
  429.     weekday_b= calc_weekday(days, sunday_first_n_first_week_non_iso);
  431.     /*
  432.       Below we are going to sum:
  433.       1) number of days since year 0 till 1st day of 1st week of this year
  434.       2) number of days between 1st week and our week
  435.       3) and position of our day in the week
  436.     */
  437.     if (sunday_first_n_first_week_non_iso)
  438.     {
  439.       days+= ((weekday_b == 0) ? 0 : 7) - weekday_b +
  440.              (week_number - 1) * 7 +
  441.              weekday % 7;
  442.     }
  443.     else
  444.     {
  445.       days+= ((weekday_b <= 3) ? 0 : 7) - weekday_b +
  446.              (week_number - 1) * 7 +
  447.              (weekday - 1);
  448.     }
  450.     if (days <= 0 || days >= MAX_DAY_NUMBER)
  451.       goto err;
  452.     get_date_from_daynr(days,&l_time->year,&l_time->month,&l_time->day);
  453.   }
  455.   if (l_time->month > 12 || l_time->day > 31 || l_time->hour > 23 || 
  456.       l_time->minute > 59 || l_time->second > 59)
  457.     goto err;
  459.   if (val != val_end)
  460.   {
  461.     do
  462.     {
  463.       if (!my_isspace(&my_charset_latin1,*val))
  464.       {
  465. make_truncated_value_warning(current_thd, val_begin, length,
  466.      cached_timestamp_type);
  467. break;
  468.       }
  469.     } while (++val != val_end);
  470.   }
  471.   DBUG_RETURN(0);
  473. err:
  474.   DBUG_RETURN(1);
  475. }
  478. /*
  479.   Create a formated date/time value in a string
  480. */
  482. bool make_date_time(DATE_TIME_FORMAT *format, TIME *l_time,
  483.     timestamp_type type, String *str)
  484. {
  485.   char intbuff[15];
  486.   uint days_i;
  487.   uint hours_i;
  488.   uint weekday;
  489.   ulong length;
  490.   const char *ptr, *end;
  492.   str->length(0);
  493.   str->set_charset(&my_charset_bin);
  495.   if (l_time->neg)
  496.     str->append("-", 1);
  497.   
  498.   end= (ptr= format->format.str) + format->format.length;
  499.   for (; ptr != end ; ptr++)
  500.   {
  501.     if (*ptr != '%' || ptr+1 == end)
  502.       str->append(*ptr);
  503.     else
  504.     {
  505.       switch (*++ptr) {
  506.       case 'M':
  507. if (!l_time->month)
  508.   return 1;
  509. str->append(month_names[l_time->month-1]);
  510. break;
  511.       case 'b':
  512. if (!l_time->month)
  513.   return 1;
  514. str->append(month_names[l_time->month-1],3);
  515. break;
  516.       case 'W':
  517. if (type == MYSQL_TIMESTAMP_TIME)
  518.   return 1;
  519. weekday= calc_weekday(calc_daynr(l_time->year,l_time->month,
  520.  l_time->day),0);
  521. str->append(day_names[weekday]);
  522. break;
  523.       case 'a':
  524. if (type == MYSQL_TIMESTAMP_TIME)
  525.   return 1;
  526. weekday=calc_weekday(calc_daynr(l_time->year,l_time->month,
  527. l_time->day),0);
  528. str->append(day_names[weekday],3);
  529. break;
  530.       case 'D':
  531. if (type == MYSQL_TIMESTAMP_TIME)
  532.   return 1;
  533. length= int10_to_str(l_time->day, intbuff, 10) - intbuff;
  534. str->append_with_prefill(intbuff, length, 1, '0');
  535. if (l_time->day >= 10 &&  l_time->day <= 19)
  536.   str->append("th", 2);
  537. else
  538. {
  539.   switch (l_time->day %10) {
  540.   case 1:
  541.     str->append("st",2);
  542.     break;
  543.   case 2:
  544.     str->append("nd",2);
  545.     break;
  546.   case 3:
  547.     str->append("rd",2);
  548.     break;
  549.   default:
  550.     str->append("th",2);
  551.     break;
  552.   }
  553. }
  554. break;
  555.       case 'Y':
  556. length= int10_to_str(l_time->year, intbuff, 10) - intbuff;
  557. str->append_with_prefill(intbuff, length, 4, '0');
  558. break;
  559.       case 'y':
  560. length= int10_to_str(l_time->year%100, intbuff, 10) - intbuff;
  561. str->append_with_prefill(intbuff, length, 2, '0');
  562. break;
  563.       case 'm':
  564. length= int10_to_str(l_time->month, intbuff, 10) - intbuff;
  565. str->append_with_prefill(intbuff, length, 2, '0');
  566. break;
  567.       case 'c':
  568. length= int10_to_str(l_time->month, intbuff, 10) - intbuff;
  569. str->append_with_prefill(intbuff, length, 1, '0');
  570. break;
  571.       case 'd':
  572. length= int10_to_str(l_time->day, intbuff, 10) - intbuff;
  573. str->append_with_prefill(intbuff, length, 2, '0');
  574. break;
  575.       case 'e':
  576. length= int10_to_str(l_time->day, intbuff, 10) - intbuff;
  577. str->append_with_prefill(intbuff, length, 1, '0');
  578. break;
  579.       case 'f':
  580. length= int10_to_str(l_time->second_part, intbuff, 10) - intbuff;
  581. str->append_with_prefill(intbuff, length, 6, '0');
  582. break;
  583.       case 'H':
  584. length= int10_to_str(l_time->hour, intbuff, 10) - intbuff;
  585. str->append_with_prefill(intbuff, length, 2, '0');
  586. break;
  587.       case 'h':
  588.       case 'I':
  589. days_i= l_time->hour/24;
  590. hours_i= (l_time->hour%24 + 11)%12+1 + 24*days_i;
  591. length= int10_to_str(hours_i, intbuff, 10) - intbuff;
  592. str->append_with_prefill(intbuff, length, 2, '0');
  593. break;
  594.       case 'i': /* minutes */
  595. length= int10_to_str(l_time->minute, intbuff, 10) - intbuff;
  596. str->append_with_prefill(intbuff, length, 2, '0');
  597. break;
  598.       case 'j':
  599. if (type == MYSQL_TIMESTAMP_TIME)
  600.   return 1;
  601. length= int10_to_str(calc_daynr(l_time->year,l_time->month,
  602. l_time->day) - 
  603.      calc_daynr(l_time->year,1,1) + 1, intbuff, 10) - intbuff;
  604. str->append_with_prefill(intbuff, length, 3, '0');
  605. break;
  606.       case 'k':
  607. length= int10_to_str(l_time->hour, intbuff, 10) - intbuff;
  608. str->append_with_prefill(intbuff, length, 1, '0');
  609. break;
  610.       case 'l':
  611. days_i= l_time->hour/24;
  612. hours_i= (l_time->hour%24 + 11)%12+1 + 24*days_i;
  613. length= int10_to_str(hours_i, intbuff, 10) - intbuff;
  614. str->append_with_prefill(intbuff, length, 1, '0');
  615. break;
  616.       case 'p':
  617. hours_i= l_time->hour%24;
  618. str->append(hours_i < 12 ? "AM" : "PM",2);
  619. break;
  620.       case 'r':
  621. length= my_sprintf(intbuff, 
  622.    (intbuff, 
  623.     (l_time->hour < 12) ? "%02d:%02d:%02d AM" : "%02d:%02d:%02d PM",
  624.     (l_time->hour+11)%12+1,
  625.     l_time->minute,
  626.     l_time->second));
  627. str->append(intbuff, length);
  628. break;
  629.       case 'S':
  630.       case 's':
  631. length= int10_to_str(l_time->second, intbuff, 10) - intbuff;
  632. str->append_with_prefill(intbuff, length, 2, '0');
  633. break;
  634.       case 'T':
  635. length= my_sprintf(intbuff, 
  636.    (intbuff, 
  637.     "%02d:%02d:%02d", 
  638.     l_time->hour, 
  639.     l_time->minute,
  640.     l_time->second));
  641. str->append(intbuff, length);
  642. break;
  643.       case 'U':
  644.       case 'u':
  645.       {
  646. uint year;
  647. if (type == MYSQL_TIMESTAMP_TIME)
  648.   return 1;
  649. length= int10_to_str(calc_week(l_time,
  650.        (*ptr) == 'U' ?
  651.        WEEK_FIRST_WEEKDAY : WEEK_MONDAY_FIRST,
  652.        &year),
  653.      intbuff, 10) - intbuff;
  654. str->append_with_prefill(intbuff, length, 2, '0');
  655.       }
  656.       break;
  657.       case 'v':
  658.       case 'V':
  659.       {
  660. uint year;
  661. if (type == MYSQL_TIMESTAMP_TIME)
  662.   return 1;
  663. length= int10_to_str(calc_week(l_time,
  664.        ((*ptr) == 'V' ?
  665. (WEEK_YEAR | WEEK_FIRST_WEEKDAY) :
  666. (WEEK_YEAR | WEEK_MONDAY_FIRST)),
  667.        &year),
  668.      intbuff, 10) - intbuff;
  669. str->append_with_prefill(intbuff, length, 2, '0');
  670.       }
  671.       break;
  672.       case 'x':
  673.       case 'X':
  674.       {
  675. uint year;
  676. if (type == MYSQL_TIMESTAMP_TIME)
  677.   return 1;
  678. (void) calc_week(l_time,
  679.  ((*ptr) == 'X' ?
  680.   WEEK_YEAR | WEEK_FIRST_WEEKDAY :
  681.   WEEK_YEAR | WEEK_MONDAY_FIRST),
  682.  &year);
  683. length= int10_to_str(year, intbuff, 10) - intbuff;
  684. str->append_with_prefill(intbuff, length, 4, '0');
  685.       }
  686.       break;
  687.       case 'w':
  688. if (type == MYSQL_TIMESTAMP_TIME)
  689.   return 1;
  690. weekday=calc_weekday(calc_daynr(l_time->year,l_time->month,
  691. l_time->day),1);
  692. length= int10_to_str(weekday, intbuff, 10) - intbuff;
  693. str->append_with_prefill(intbuff, length, 1, '0');
  694. break;
  696.       default:
  697. str->append(*ptr);
  698. break;
  699.       }
  700.     }
  701.   }
  702.   return 0;
  703. }
  706. /*
  707.   Get a array of positive numbers from a string object.
  708.   Each number is separated by 1 non digit character
  709.   Return error if there is too many numbers.
  710.   If there is too few numbers, assume that the numbers are left out
  711.   from the high end. This allows one to give:
  712.   DAY_TO_SECOND as "D MM:HH:SS", "MM:HH:SS" "HH:SS" or as seconds.
  714.   SYNOPSIS
  715.     str:            string value
  716.     length:         length of str
  717.     cs:             charset of str
  718.     values:         array of results
  719.     count:          count of elements in result array
  720.     transform_msec: if value is true we suppose
  721.                     that the last part of string value is microseconds
  722.                     and we should transform value to six digit value.
  723.                     For example, '1.1' -> '1.100000'
  724. */
  726. static bool get_interval_info(const char *str,uint length,CHARSET_INFO *cs,
  727.                               uint count, ulonglong *values,
  728.                               bool transform_msec)
  729. {
  730.   const char *end=str+length;
  731.   uint i;
  732.   while (str != end && !my_isdigit(cs,*str))
  733.     str++;
  735.   for (i=0 ; i < count ; i++)
  736.   {
  737.     longlong value;
  738.     const char *start= str;
  739.     for (value=0; str != end && my_isdigit(cs,*str) ; str++)
  740.       value= value*LL(10) + (longlong) (*str - '0');
  741.     if (transform_msec && i == count - 1) // microseconds always last
  742.     {
  743.       long msec_length= 6 - (str - start);
  744.       if (msec_length > 0)
  745. value*= (long) log_10_int[msec_length];
  746.     }
  747.     values[i]= value;
  748.     while (str != end && !my_isdigit(cs,*str))
  749.       str++;
  750.     if (str == end && i != count-1)
  751.     {
  752.       i++;
  753.       /* Change values[0...i-1] -> values[0...count-1] */
  754.       bmove_upp((char*) (values+count), (char*) (values+i),
  755. sizeof(*values)*i);
  756.       bzero((char*) values, sizeof(*values)*(count-i));
  757.       break;
  758.     }
  759.   }
  760.   return (str != end);
  761. }
  764. /*
  765.   Calculate difference between two datetime values as seconds + microseconds.
  767.   SYNOPSIS
  768.     calc_time_diff()
  769.       l_time1         - TIME/DATE/DATETIME value
  770.       l_time2         - TIME/DATE/DATETIME value
  771.       l_sign          - 1 absolute values are substracted,
  772.                         -1 absolute values are added.
  773.       seconds_out     - Out parameter where difference between
  774.                         l_time1 and l_time2 in seconds is stored.
  775.       microseconds_out- Out parameter where microsecond part of difference
  776.                         between l_time1 and l_time2 is stored.
  778.   NOTE
  779.     This function calculates difference between l_time1 and l_time2 absolute
  780.     values. So one should set l_sign and correct result if he want to take
  781.     signs into account (i.e. for TIME values).
  783.   RETURN VALUES
  784.     Returns sign of difference.
  785.     1 means negative result
  786.     0 means positive result
  788. */
  790. static bool calc_time_diff(TIME *l_time1, TIME *l_time2, int l_sign,
  791.                            longlong *seconds_out, long *microseconds_out)
  792. {
  793.   long days;
  794.   bool neg;
  795.   longlong microseconds;
  797.   /*
  798.     We suppose that if first argument is MYSQL_TIMESTAMP_TIME
  799.     the second argument should be TIMESTAMP_TIME also.
  800.     We should check it before calc_time_diff call.
  801.   */
  802.   if (l_time1->time_type == MYSQL_TIMESTAMP_TIME)  // Time value
  803.     days= (long)l_time1->day - l_sign * (long)l_time2->day;
  804.   else
  805.   {
  806.     days= calc_daynr((uint) l_time1->year,
  807.      (uint) l_time1->month,
  808.      (uint) l_time1->day);
  809.     if (l_time2->time_type == MYSQL_TIMESTAMP_TIME)
  810.       days-= l_sign * (long)l_time2->day;
  811.     else
  812.       days-= l_sign*calc_daynr((uint) l_time2->year,
  813.        (uint) l_time2->month,
  814.        (uint) l_time2->day);
  815.   }
  817.   microseconds= ((longlong)days*LL(86400) +
  818.                  (longlong)(l_time1->hour*3600L +
  819.                             l_time1->minute*60L +
  820.                             l_time1->second) -
  821.                  l_sign*(longlong)(l_time2->hour*3600L +
  822.                                    l_time2->minute*60L +
  823.                                    l_time2->second)) * LL(1000000) +
  824.                 (longlong)l_time1->second_part -
  825.                 l_sign*(longlong)l_time2->second_part;
  827.   neg= 0;
  828.   if (microseconds < 0)
  829.   {
  830.     microseconds= -microseconds;
  831.     neg= 1;
  832.   }
  833.   *seconds_out= microseconds/1000000L;
  834.   *microseconds_out= (long) (microseconds%1000000L);
  835.   return neg;
  836. }
  839. longlong Item_func_period_add::val_int()
  840. {
  841.   DBUG_ASSERT(fixed == 1);
  842.   ulong period=(ulong) args[0]->val_int();
  843.   int months=(int) args[1]->val_int();
  845.   if ((null_value=args[0]->null_value || args[1]->null_value) ||
  846.       period == 0L)
  847.     return 0; /* purecov: inspected */
  848.   return (longlong)
  849.     convert_month_to_period((uint) ((int) convert_period_to_month(period)+
  850.     months));
  851. }
  854. longlong Item_func_period_diff::val_int()
  855. {
  856.   DBUG_ASSERT(fixed == 1);
  857.   ulong period1=(ulong) args[0]->val_int();
  858.   ulong period2=(ulong) args[1]->val_int();
  860.   if ((null_value=args[0]->null_value || args[1]->null_value))
  861.     return 0; /* purecov: inspected */
  862.   return (longlong) ((long) convert_period_to_month(period1)-
  863.      (long) convert_period_to_month(period2));
  864. }
  868. longlong Item_func_to_days::val_int()
  869. {
  870.   DBUG_ASSERT(fixed == 1);
  871.   TIME ltime;
  872.   if (get_arg0_date(&ltime,0))
  873.     return 0;
  874.   return (longlong) calc_daynr(ltime.year,ltime.month,ltime.day);
  875. }
  877. longlong Item_func_dayofyear::val_int()
  878. {
  879.   DBUG_ASSERT(fixed == 1);
  880.   TIME ltime;
  881.   if (get_arg0_date(&ltime,0))
  882.     return 0;
  883.   return (longlong) calc_daynr(ltime.year,ltime.month,ltime.day) -
  884.     calc_daynr(ltime.year,1,1) + 1;
  885. }
  887. longlong Item_func_dayofmonth::val_int()
  888. {
  889.   DBUG_ASSERT(fixed == 1);
  890.   TIME ltime;
  891.   (void) get_arg0_date(&ltime,1);
  892.   return (longlong) ltime.day;
  893. }
  895. longlong Item_func_month::val_int()
  896. {
  897.   DBUG_ASSERT(fixed == 1);
  898.   TIME ltime;
  899.   (void) get_arg0_date(&ltime,1);
  900.   return (longlong) ltime.month;
  901. }
  904. String* Item_func_monthname::val_str(String* str)
  905. {
  906.   DBUG_ASSERT(fixed == 1);
  907.   const char *month_name;
  908.   uint   month=(uint) Item_func_month::val_int();
  910.   if (!month) // This is also true for NULL
  911.   {
  912.     null_value=1;
  913.     return (String*) 0;
  914.   }
  915.   null_value=0;
  916.   month_name= month_names[month-1];
  917.   str->set(month_name, strlen(month_name), system_charset_info);
  918.   return str;
  919. }
  922. // Returns the quarter of the year
  924. longlong Item_func_quarter::val_int()
  925. {
  926.   DBUG_ASSERT(fixed == 1);
  927.   TIME ltime;
  928.   (void) get_arg0_date(&ltime,1);
  929.   return (longlong) ((ltime.month+2)/3);
  930. }
  932. longlong Item_func_hour::val_int()
  933. {
  934.   DBUG_ASSERT(fixed == 1);
  935.   TIME ltime;
  936.   (void) get_arg0_time(&ltime);
  937.   return ltime.hour;
  938. }
  940. longlong Item_func_minute::val_int()
  941. {
  942.   DBUG_ASSERT(fixed == 1);
  943.   TIME ltime;
  944.   (void) get_arg0_time(&ltime);
  945.   return ltime.minute;
  946. }
  947. // Returns the second in time_exp in the range of 0 - 59
  949. longlong Item_func_second::val_int()
  950. {
  951.   DBUG_ASSERT(fixed == 1);
  952.   TIME ltime;
  953.   (void) get_arg0_time(&ltime);
  954.   return ltime.second;
  955. }
  958. uint week_mode(uint mode)
  959. {
  960.   uint week_format= (mode & 7);
  961.   if (!(week_format & WEEK_MONDAY_FIRST))
  962.     week_format^= WEEK_FIRST_WEEKDAY;
  963.   return week_format;
  964. }
  966. /*
  967.   The bits in week_format(for calc_week() function) has the following meaning:
  968.    WEEK_MONDAY_FIRST (0)  If not set Sunday is first day of week
  969.              If set Monday is first day of week
  970.    WEEK_YEAR (1)   If not set Week is in range 0-53
  972.     Week 0 is returned for the the last week of the previous year (for
  973. a date at start of january) In this case one can get 53 for the
  974. first week of next year.  This flag ensures that the week is
  975. relevant for the given year. Note that this flag is only
  976. releveant if WEEK_JANUARY is not set.
  978.   If set  Week is in range 1-53.
  980. In this case one may get week 53 for a date in January (when
  981. the week is that last week of previous year) and week 1 for a
  982. date in December.
  984.   WEEK_FIRST_WEEKDAY (2)  If not set Weeks are numbered according
  985.     to ISO 8601:1988
  986.   If set The week that contains the first
  987. 'first-day-of-week' is week 1.
  989. ISO 8601:1988 means that if the week containing January 1 has
  990. four or more days in the new year, then it is week 1;
  991. Otherwise it is the last week of the previous year, and the
  992. next week is week 1.
  993. */
  995. longlong Item_func_week::val_int()
  996. {
  997.   DBUG_ASSERT(fixed == 1);
  998.   uint year;
  999.   TIME ltime;
  1000.   if (get_arg0_date(&ltime,0))
  1001.     return 0;
  1002.   return (longlong) calc_week(&ltime,
  1003.       week_mode((uint) args[1]->val_int()),
  1004.       &year);
  1005. }
  1008. longlong Item_func_yearweek::val_int()
  1009. {
  1010.   DBUG_ASSERT(fixed == 1);
  1011.   uint year,week;
  1012.   TIME ltime;
  1013.   if (get_arg0_date(&ltime,0))
  1014.     return 0;
  1015.   week= calc_week(&ltime, 
  1016.   (week_mode((uint) args[1]->val_int()) | WEEK_YEAR),
  1017.   &year);
  1018.   return week+year*100;
  1019. }
  1022. /* weekday() has a automatic to_days() on item */
  1024. longlong Item_func_weekday::val_int()
  1025. {
  1026.   DBUG_ASSERT(fixed == 1);
  1027.   ulong tmp_value=(ulong) args[0]->val_int();
  1028.   if ((null_value=(args[0]->null_value || !tmp_value)))
  1029.     return 0; /* purecov: inspected */
  1031.   return (longlong) calc_weekday(tmp_value,odbc_type)+test(odbc_type);
  1032. }
  1035. String* Item_func_dayname::val_str(String* str)
  1036. {
  1037.   DBUG_ASSERT(fixed == 1);
  1038.   uint weekday=(uint) val_int(); // Always Item_func_daynr()
  1039.   const char *name;
  1041.   if (null_value)
  1042.     return (String*) 0;
  1043.   
  1044.   name= day_names[weekday];
  1045.   str->set(name, strlen(name), system_charset_info);
  1046.   return str;
  1047. }
  1050. longlong Item_func_year::val_int()
  1051. {
  1052.   DBUG_ASSERT(fixed == 1);
  1053.   TIME ltime;
  1054.   (void) get_arg0_date(&ltime,1);
  1055.   return (longlong) ltime.year;
  1056. }
  1059. longlong Item_func_unix_timestamp::val_int()
  1060. {
  1061.   TIME ltime;
  1062.   bool not_used;
  1063.   
  1064.   DBUG_ASSERT(fixed == 1);
  1065.   if (arg_count == 0)
  1066.     return (longlong) current_thd->query_start();
  1067.   if (args[0]->type() == FIELD_ITEM)
  1068.   { // Optimize timestamp field
  1069.     Field *field=((Item_field*) args[0])->field;
  1070.     if (field->type() == FIELD_TYPE_TIMESTAMP)
  1071.       return ((Field_timestamp*) field)->get_timestamp(&null_value);
  1072.   }
  1073.   
  1074.   if (get_arg0_date(&ltime, 0))
  1075.   {
  1076.     /*
  1077.       We have to set null_value again because get_arg0_date will also set it
  1078.       to true if we have wrong datetime parameter (and we should return 0 in 
  1079.       this case).
  1080.     */
  1081.     null_value= args[0]->null_value;
  1082.     return 0;
  1083.   }
  1084.   
  1085.   return (longlong) TIME_to_timestamp(current_thd, &ltime, &not_used);
  1086. }
  1089. longlong Item_func_time_to_sec::val_int()
  1090. {
  1091.   DBUG_ASSERT(fixed == 1);
  1092.   TIME ltime;
  1093.   longlong seconds;
  1094.   (void) get_arg0_time(&ltime);
  1095.   seconds=ltime.hour*3600L+ltime.minute*60+ltime.second;
  1096.   return ltime.neg ? -seconds : seconds;
  1097. }
  1100. /*
  1101.   Convert a string to a interval value
  1102.   To make code easy, allow interval objects without separators.
  1103. */
  1105. static bool get_interval_value(Item *args,interval_type int_type,
  1106.        String *str_value, INTERVAL *interval)
  1107. {
  1108.   ulonglong array[5];
  1109.   longlong value;
  1110.   const char *str;
  1111.   uint32 length;
  1112.   CHARSET_INFO *cs=str_value->charset();
  1114.   LINT_INIT(value);
  1115.   LINT_INIT(str);
  1116.   LINT_INIT(length);
  1118.   bzero((char*) interval,sizeof(*interval));
  1119.   if ((int) int_type <= INTERVAL_MICROSECOND)
  1120.   {
  1121.     value= args->val_int();
  1122.     if (args->null_value)
  1123.       return 1;
  1124.     if (value < 0)
  1125.     {
  1126.       interval->neg=1;
  1127.       value= -value;
  1128.     }
  1129.   }
  1130.   else
  1131.   {
  1132.     String *res;
  1133.     if (!(res=args->val_str(str_value)))
  1134.       return (1);
  1136.     /* record negative intervalls in interval->neg */
  1137.     str=res->ptr();
  1138.     const char *end=str+res->length();
  1139.     while (str != end && my_isspace(cs,*str))
  1140.       str++;
  1141.     if (str != end && *str == '-')
  1142.     {
  1143.       interval->neg=1;
  1144.       str++;
  1145.     }
  1146.     length=(uint32) (end-str); // Set up pointers to new str
  1147.   }
  1149.   switch (int_type) {
  1150.   case INTERVAL_YEAR:
  1151.     interval->year= (ulong) value;
  1152.     break;
  1153.   case INTERVAL_MONTH:
  1154.     interval->month= (ulong) value;
  1155.     break;
  1156.   case INTERVAL_DAY:
  1157.     interval->day= (ulong) value;
  1158.     break;
  1159.   case INTERVAL_HOUR:
  1160.     interval->hour= (ulong) value;
  1161.     break;
  1162.   case INTERVAL_MICROSECOND:
  1163.     interval->second_part=value;
  1164.     break;
  1165.   case INTERVAL_MINUTE:
  1166.     interval->minute=value;
  1167.     break;
  1168.   case INTERVAL_SECOND:
  1169.     interval->second=value;
  1170.     break;
  1171.   case INTERVAL_YEAR_MONTH: // Allow YEAR-MONTH YYYYYMM
  1172.     if (get_interval_info(str,length,cs,2,array,0))
  1173.       return (1);
  1174.     interval->year=  (ulong) array[0];
  1175.     interval->month= (ulong) array[1];
  1176.     break;
  1177.   case INTERVAL_DAY_HOUR:
  1178.     if (get_interval_info(str,length,cs,2,array,0))
  1179.       return (1);
  1180.     interval->day=  (ulong) array[0];
  1181.     interval->hour= (ulong) array[1];
  1182.     break;
  1183.   case INTERVAL_DAY_MICROSECOND:
  1184.     if (get_interval_info(str,length,cs,5,array,1))
  1185.       return (1);
  1186.     interval->day=    (ulong) array[0];
  1187.     interval->hour=   (ulong) array[1];
  1188.     interval->minute= array[2];
  1189.     interval->second= array[3];
  1190.     interval->second_part= array[4];
  1191.     break;
  1192.   case INTERVAL_DAY_MINUTE:
  1193.     if (get_interval_info(str,length,cs,3,array,0))
  1194.       return (1);
  1195.     interval->day=    (ulong) array[0];
  1196.     interval->hour=   (ulong) array[1];
  1197.     interval->minute= array[2];
  1198.     break;
  1199.   case INTERVAL_DAY_SECOND:
  1200.     if (get_interval_info(str,length,cs,4,array,0))
  1201.       return (1);
  1202.     interval->day=    (ulong) array[0];
  1203.     interval->hour=   (ulong) array[1];
  1204.     interval->minute= array[2];
  1205.     interval->second= array[3];
  1206.     break;
  1207.   case INTERVAL_HOUR_MICROSECOND:
  1208.     if (get_interval_info(str,length,cs,4,array,1))
  1209.       return (1);
  1210.     interval->hour=   (ulong) array[0];
  1211.     interval->minute= array[1];
  1212.     interval->second= array[2];
  1213.     interval->second_part= array[3];
  1214.     break;
  1215.   case INTERVAL_HOUR_MINUTE:
  1216.     if (get_interval_info(str,length,cs,2,array,0))
  1217.       return (1);
  1218.     interval->hour=   (ulong) array[0];
  1219.     interval->minute= array[1];
  1220.     break;
  1221.   case INTERVAL_HOUR_SECOND:
  1222.     if (get_interval_info(str,length,cs,3,array,0))
  1223.       return (1);
  1224.     interval->hour=   (ulong) array[0];
  1225.     interval->minute= array[1];
  1226.     interval->second= array[2];
  1227.     break;
  1228.   case INTERVAL_MINUTE_MICROSECOND:
  1229.     if (get_interval_info(str,length,cs,3,array,1))
  1230.       return (1);
  1231.     interval->minute= array[0];
  1232.     interval->second= array[1];
  1233.     interval->second_part= array[2];
  1234.     break;
  1235.   case INTERVAL_MINUTE_SECOND:
  1236.     if (get_interval_info(str,length,cs,2,array,0))
  1237.       return (1);
  1238.     interval->minute= array[0];
  1239.     interval->second= array[1];
  1240.     break;
  1241.   case INTERVAL_SECOND_MICROSECOND:
  1242.     if (get_interval_info(str,length,cs,2,array,1))
  1243.       return (1);
  1244.     interval->second= array[0];
  1245.     interval->second_part= array[1];
  1246.     break;
  1247.   }
  1248.   return 0;
  1249. }
  1252. String *Item_date::val_str(String *str)
  1253. {
  1254.   DBUG_ASSERT(fixed == 1);
  1255.   TIME ltime;
  1256.   if (get_date(&ltime, TIME_FUZZY_DATE))
  1257.     return (String *) 0;
  1258.   if (str->alloc(11))
  1259.   {
  1260.     null_value= 1;
  1261.     return (String *) 0;
  1262.   }
  1263.   make_date((DATE_TIME_FORMAT *) 0, &ltime, str);
  1264.   return str;
  1265. }
  1268. int Item_date::save_in_field(Field *field, bool no_conversions)
  1269. {
  1270.   TIME ltime;
  1271.   if (get_date(&ltime, TIME_FUZZY_DATE))
  1272.     return set_field_to_null(field);
  1273.   field->set_notnull();
  1274.   field->store_time(&ltime, MYSQL_TIMESTAMP_DATE);
  1275.   return 0;
  1276. }
  1279. longlong Item_date::val_int()
  1280. {
  1281.   DBUG_ASSERT(fixed == 1);
  1282.   TIME ltime;
  1283.   if (get_date(&ltime, TIME_FUZZY_DATE))
  1284.     return 0;
  1285.   return (longlong) (ltime.year*10000L+ltime.month*100+ltime.day);
  1286. }
  1289. bool Item_func_from_days::get_date(TIME *ltime, uint fuzzy_date)
  1290. {
  1291.   longlong value=args[0]->val_int();
  1292.   if ((null_value=args[0]->null_value))
  1293.     return 1;
  1294.   bzero(ltime, sizeof(TIME));
  1295.   get_date_from_daynr((long) value, &ltime->year, &ltime->month, &ltime->day);
  1296.   ltime->time_type= MYSQL_TIMESTAMP_DATE;
  1297.   return 0;
  1298. }
  1301. void Item_func_curdate::fix_length_and_dec()
  1302. {
  1303.   collation.set(&my_charset_bin);
  1304.   decimals=0; 
  1305.   max_length=MAX_DATE_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
  1307.   store_now_in_TIME(&ltime);
  1308.   
  1309.   /* We don't need to set second_part and neg because they already 0 */
  1310.   ltime.hour= ltime.minute= ltime.second= 0;
  1311.   ltime.time_type= MYSQL_TIMESTAMP_DATE;
  1312.   value= (longlong) TIME_to_ulonglong_date(&ltime);
  1313. }
  1315. String *Item_func_curdate::val_str(String *str)
  1316. {
  1317.   DBUG_ASSERT(fixed == 1);
  1318.   if (str->alloc(11))
  1319.   {
  1320.     null_value= 1;
  1321.     return (String *) 0;
  1322.   }
  1323.   make_date((DATE_TIME_FORMAT *) 0, &ltime, str);
  1324.   return str;
  1325. }
  1327. /*
  1328.     Converts current time in my_time_t to TIME represenatation for local
  1329.     time zone. Defines time zone (local) used for whole CURDATE function.
  1330. */
  1331. void Item_func_curdate_local::store_now_in_TIME(TIME *now_time)
  1332. {
  1333.   THD *thd= current_thd;
  1334.   thd->variables.time_zone->gmt_sec_to_TIME(now_time, 
  1335.                                              (my_time_t)thd->query_start());
  1336.   thd->time_zone_used= 1;
  1337. }
  1340. /*
  1341.     Converts current time in my_time_t to TIME represenatation for UTC
  1342.     time zone. Defines time zone (UTC) used for whole UTC_DATE function.
  1343. */
  1344. void Item_func_curdate_utc::store_now_in_TIME(TIME *now_time)
  1345. {
  1346.   my_tz_UTC->gmt_sec_to_TIME(now_time, 
  1347.                              (my_time_t)(current_thd->query_start()));
  1348.   /* 
  1349.     We are not flagging this query as using time zone, since it uses fixed
  1350.     UTC-SYSTEM time-zone.
  1351.   */
  1352. }
  1355. bool Item_func_curdate::get_date(TIME *res,
  1356.  uint fuzzy_date __attribute__((unused)))
  1357. {
  1358.   *res=ltime;
  1359.   return 0;
  1360. }
  1363. String *Item_func_curtime::val_str(String *str)
  1364. {
  1365.   DBUG_ASSERT(fixed == 1);
  1366.   str_value.set(buff, buff_length, &my_charset_bin);
  1367.   return &str_value;
  1368. }
  1371. void Item_func_curtime::fix_length_and_dec()
  1372. {
  1373.   TIME ltime;
  1375.   decimals=0;
  1376.   collation.set(&my_charset_bin);
  1377.   store_now_in_TIME(&ltime);
  1378.   value= TIME_to_ulonglong_time(&ltime);
  1379.   buff_length= (uint) my_time_to_str(&ltime, buff);
  1380.   max_length= buff_length;
  1381. }
  1384. /*
  1385.     Converts current time in my_time_t to TIME represenatation for local
  1386.     time zone. Defines time zone (local) used for whole CURTIME function.
  1387. */
  1388. void Item_func_curtime_local::store_now_in_TIME(TIME *now_time)
  1389. {
  1390.   THD *thd= current_thd;
  1391.   thd->variables.time_zone->gmt_sec_to_TIME(now_time, 
  1392.                                              (my_time_t)thd->query_start());
  1393.   thd->time_zone_used= 1;
  1394. }
  1397. /*
  1398.     Converts current time in my_time_t to TIME represenatation for UTC
  1399.     time zone. Defines time zone (UTC) used for whole UTC_TIME function.
  1400. */
  1401. void Item_func_curtime_utc::store_now_in_TIME(TIME *now_time)
  1402. {
  1403.   my_tz_UTC->gmt_sec_to_TIME(now_time, 
  1404.                              (my_time_t)(current_thd->query_start()));
  1405.   /* 
  1406.     We are not flagging this query as using time zone, since it uses fixed
  1407.     UTC-SYSTEM time-zone.
  1408.   */
  1409. }
  1412. String *Item_func_now::val_str(String *str)
  1413. {
  1414.   DBUG_ASSERT(fixed == 1);
  1415.   str_value.set(buff,buff_length, &my_charset_bin);
  1416.   return &str_value;
  1417. }
  1420. void Item_func_now::fix_length_and_dec()
  1421. {
  1422.   decimals=0;
  1423.   collation.set(&my_charset_bin);
  1425.   store_now_in_TIME(&ltime);
  1426.   value= (longlong) TIME_to_ulonglong_datetime(&ltime);
  1428.   buff_length= (uint) my_datetime_to_str(&ltime, buff);
  1429.   max_length= buff_length;
  1430. }
  1433. /*
  1434.     Converts current time in my_time_t to TIME represenatation for local
  1435.     time zone. Defines time zone (local) used for whole NOW function.
  1436. */
  1437. void Item_func_now_local::store_now_in_TIME(TIME *now_time)
  1438. {
  1439.   THD *thd= current_thd;
  1440.   thd->variables.time_zone->gmt_sec_to_TIME(now_time, 
  1441.                                              (my_time_t)thd->query_start());
  1442.   thd->time_zone_used= 1;
  1443. }
  1446. /*
  1447.     Converts current time in my_time_t to TIME represenatation for UTC
  1448.     time zone. Defines time zone (UTC) used for whole UTC_TIMESTAMP function.
  1449. */
  1450. void Item_func_now_utc::store_now_in_TIME(TIME *now_time)
  1451. {
  1452.   my_tz_UTC->gmt_sec_to_TIME(now_time, 
  1453.                              (my_time_t)(current_thd->query_start()));
  1454.   /* 
  1455.     We are not flagging this query as using time zone, since it uses fixed
  1456.     UTC-SYSTEM time-zone.
  1457.   */
  1458. }
  1461. bool Item_func_now::get_date(TIME *res,
  1462.      uint fuzzy_date __attribute__((unused)))
  1463. {
  1464.   *res=ltime;
  1465.   return 0;
  1466. }
  1469. int Item_func_now::save_in_field(Field *to, bool no_conversions)
  1470. {
  1471.   to->set_notnull();
  1472.   to->store_time(&ltime, MYSQL_TIMESTAMP_DATETIME);
  1473.   return 0;
  1474. }
  1477. String *Item_func_sec_to_time::val_str(String *str)
  1478. {
  1479.   DBUG_ASSERT(fixed == 1);
  1480.   longlong seconds=(longlong) args[0]->val_int();
  1481.   uint sec;
  1482.   TIME ltime;
  1484.   if ((null_value=args[0]->null_value) || str->alloc(19))
  1485.   {
  1486.     null_value= 1;
  1487.     return (String*) 0;
  1488.   }
  1490.   ltime.neg= 0;
  1491.   if (seconds < 0)
  1492.   {
  1493.     seconds= -seconds;
  1494.     ltime.neg= 1;
  1495.   }
  1497.   sec= (uint) ((ulonglong) seconds % 3600);
  1498.   ltime.day= 0;
  1499.   ltime.hour= (uint) (seconds/3600);
  1500.   ltime.minute= sec/60;
  1501.   ltime.second= sec % 60;
  1503.   make_time((DATE_TIME_FORMAT *) 0, &ltime, str);
  1504.   return str;
  1505. }
  1508. longlong Item_func_sec_to_time::val_int()
  1509. {
  1510.   DBUG_ASSERT(fixed == 1);
  1511.   longlong seconds=args[0]->val_int();
  1512.   longlong sign=1;
  1513.   if ((null_value=args[0]->null_value))
  1514.     return 0;
  1515.   if (seconds < 0)
  1516.   {
  1517.     seconds= -seconds;
  1518.     sign= -1;
  1519.   }
  1520.   return sign*((seconds / 3600)*10000+((seconds/60) % 60)*100+ (seconds % 60));
  1521. }
  1524. void Item_func_date_format::fix_length_and_dec()
  1525. {
  1526.   decimals=0;
  1527.   collation.set(&my_charset_bin);
  1528.   if (args[1]->type() == STRING_ITEM)
  1529.   { // Optimize the normal case
  1530.     fixed_length=1;
  1532.     /*
  1533.       Force case sensitive collation on format string.
  1534.       This needed because format modifiers with different case,
  1535.       for example %m and %M, have different meaning. Thus eq()
  1536.       will distinguish them.
  1537.     */
  1538.     args[1]->collation.set(
  1539.         get_charset_by_csname(args[1]->collation.collation->csname,
  1540.                               MY_CS_BINSORT,MYF(0)), DERIVATION_COERCIBLE);
  1541.     /*
  1542.       The result is a binary string (no reason to use collation->mbmaxlen
  1543.       This is becasue make_date_time() only returns binary strings
  1544.     */
  1545.     max_length= format_length(((Item_string*) args[1])->const_string());
  1546.   }
  1547.   else
  1548.   {
  1549.     fixed_length=0;
  1550.     /* The result is a binary string (no reason to use collation->mbmaxlen */
  1551.     max_length=min(args[1]->max_length,MAX_BLOB_WIDTH) * 10;
  1552.     set_if_smaller(max_length,MAX_BLOB_WIDTH);
  1553.   }
  1554.   maybe_null=1; // If wrong date
  1555. }
  1558. uint Item_func_date_format::format_length(const String *format)
  1559. {
  1560.   uint size=0;
  1561.   const char *ptr=format->ptr();
  1562.   const char *end=ptr+format->length();
  1564.   for (; ptr != end ; ptr++)
  1565.   {
  1566.     if (*ptr != '%' || ptr == end-1)
  1567.       size++;
  1568.     else
  1569.     {
  1570.       switch(*++ptr) {
  1571.       case 'M': /* month, textual */
  1572.       case 'W': /* day (of the week), textual */
  1573. size += 9;
  1574. break;
  1575.       case 'D': /* day (of the month), numeric plus english suffix */
  1576.       case 'Y': /* year, numeric, 4 digits */
  1577.       case 'x': /* Year, used with 'v' */
  1578.       case 'X': /* Year, used with 'v, where week starts with Monday' */
  1579. size += 4;
  1580. break;
  1581.       case 'a': /* locale's abbreviated weekday name (Sun..Sat) */
  1582.       case 'b': /* locale's abbreviated month name (Jan.Dec) */
  1583.       case 'j': /* day of year (001..366) */
  1584. size += 3;
  1585. break;
  1586.       case 'U': /* week (00..52) */
  1587.       case 'u': /* week (00..52), where week starts with Monday */
  1588.       case 'V': /* week 1..53 used with 'x' */
  1589.       case 'v': /* week 1..53 used with 'x', where week starts with Monday */
  1590.       case 'H': /* hour (00..23) */
  1591.       case 'y': /* year, numeric, 2 digits */
  1592.       case 'm': /* month, numeric */
  1593.       case 'd': /* day (of the month), numeric */
  1594.       case 'h': /* hour (01..12) */
  1595.       case 'I': /* --||-- */
  1596.       case 'i': /* minutes, numeric */
  1597.       case 'k': /* hour ( 0..23) */
  1598.       case 'l': /* hour ( 1..12) */
  1599.       case 'p': /* locale's AM or PM */
  1600.       case 'S': /* second (00..61) */
  1601.       case 's': /* seconds, numeric */
  1602.       case 'c': /* month (0..12) */
  1603.       case 'e': /* day (0..31) */
  1604. size += 2;
  1605. break;
  1606.       case 'r': /* time, 12-hour (hh:mm:ss [AP]M) */
  1607. size += 11;
  1608. break;
  1609.       case 'T': /* time, 24-hour (hh:mm:ss) */
  1610. size += 8;
  1611. break;
  1612.       case 'f': /* microseconds */
  1613. size += 6;
  1614. break;
  1615.       case 'w': /* day (of the week), numeric */
  1616.       case '%':
  1617.       default:
  1618. size++;
  1619. break;
  1620.       }
  1621.     }
  1622.   }
  1623.   return size;
  1624. }
  1627. String *Item_func_date_format::val_str(String *str)
  1628. {
  1629.   String *format;
  1630.   TIME l_time;
  1631.   uint size;
  1632.   DBUG_ASSERT(fixed == 1);
  1634.   if (!is_time_format)
  1635.   {
  1636.     if (get_arg0_date(&l_time,1))
  1637.       return 0;
  1638.   }
  1639.   else
  1640.   {
  1641.     String *res;
  1642.     if (!(res=args[0]->val_str(str)) ||
  1643. (str_to_time_with_warn(res->ptr(), res->length(), &l_time)))
  1644.       goto null_date;
  1646.     l_time.year=l_time.month=l_time.day=0;
  1647.     null_value=0;
  1648.   }
  1650.   if (!(format = args[1]->val_str(str)) || !format->length())
  1651.     goto null_date;
  1653.   if (fixed_length)
  1654.     size=max_length;
  1655.   else
  1656.     size=format_length(format);
  1657.   if (format == str)
  1658.     str= &value; // Save result here
  1659.   if (str->alloc(size))
  1660.     goto null_date;
  1662.   DATE_TIME_FORMAT date_time_format;
  1663.   date_time_format.format.str=    (char*) format->ptr();
  1664.   date_time_format.format.length= format->length(); 
  1666.   /* Create the result string */
  1667.   if (!make_date_time(&date_time_format, &l_time,
  1668.                       is_time_format ? MYSQL_TIMESTAMP_TIME :
  1669.                                        MYSQL_TIMESTAMP_DATE,
  1670.                       str))
  1671.     return str;
  1673. null_date:
  1674.   null_value=1;
  1675.   return 0;
  1676. }
  1679. void Item_func_from_unixtime::fix_length_and_dec()
  1680. { 
  1681.   thd= current_thd;
  1682.   collation.set(&my_charset_bin);
  1683.   decimals=0;
  1684.   max_length=MAX_DATETIME_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
  1685.   maybe_null= 1;
  1686.   thd->time_zone_used= 1;
  1687. }
  1690. String *Item_func_from_unixtime::val_str(String *str)
  1691. {
  1692.   TIME time_tmp;
  1694.   DBUG_ASSERT(fixed == 1);
  1696.   if (get_date(&time_tmp, 0))
  1697.     return 0;
  1699.   if (str->alloc(20*MY_CHARSET_BIN_MB_MAXLEN))
  1700.   {
  1701.     null_value= 1;
  1702.     return 0;
  1703.   }
  1705.   make_datetime((DATE_TIME_FORMAT *) 0, &time_tmp, str);
  1706.   return str;
  1707. }
  1710. longlong Item_func_from_unixtime::val_int()
  1711. {
  1712.   TIME time_tmp;
  1714.   DBUG_ASSERT(fixed == 1);
  1716.   if (get_date(&time_tmp, 0))
  1717.     return 0;
  1719.   return (longlong) TIME_to_ulonglong_datetime(&time_tmp);
  1720. }
  1722. bool Item_func_from_unixtime::get_date(TIME *ltime,
  1723.        uint fuzzy_date __attribute__((unused)))
  1724. {
  1725.   ulonglong tmp= (ulonglong)(args[0]->val_int());
  1726.   /*
  1727.     "tmp > TIMESTAMP_MAX_VALUE" check also covers case of negative
  1728.     from_unixtime() argument since tmp is unsigned.
  1729.   */
  1730.   if ((null_value= (args[0]->null_value || tmp > TIMESTAMP_MAX_VALUE)))
  1731.     return 1;
  1733.   thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)tmp);
  1735.   return 0;
  1736. }
  1739. void Item_func_convert_tz::fix_length_and_dec()
  1740. {
  1741.   collation.set(&my_charset_bin);
  1742.   decimals= 0;
  1743.   max_length= MAX_DATETIME_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
  1744.   maybe_null= 1;
  1745. }
  1748. bool
  1749. Item_func_convert_tz::fix_fields(THD *thd_arg, TABLE_LIST *tables_arg, Item **ref)
  1750. {
  1751.   String str;
  1752.   if (Item_date_func::fix_fields(thd_arg, tables_arg, ref))
  1753.     return 1;
  1755.   tz_tables= thd_arg->lex->time_zone_tables_used;
  1757.   return 0;
  1758. }
  1761. String *Item_func_convert_tz::val_str(String *str)
  1762. {
  1763.   TIME time_tmp;
  1765.   if (get_date(&time_tmp, 0))
  1766.     return 0;
  1767.   
  1768.   if (str->alloc(20*MY_CHARSET_BIN_MB_MAXLEN))
  1769.   {
  1770.     null_value= 1;
  1771.     return 0;
  1772.   }
  1773.   
  1774.   make_datetime((DATE_TIME_FORMAT *) 0, &time_tmp, str);
  1775.   return str;
  1776. }
  1779. longlong Item_func_convert_tz::val_int()
  1780. {
  1781.   TIME time_tmp;
  1783.   if (get_date(&time_tmp, 0))
  1784.     return 0;
  1785.   
  1786.   return (longlong)TIME_to_ulonglong_datetime(&time_tmp);
  1787. }
  1790. bool Item_func_convert_tz::get_date(TIME *ltime,
  1791.        uint fuzzy_date __attribute__((unused)))
  1792. {
  1793.   my_time_t my_time_tmp;
  1794.   bool not_used;
  1795.   String str;
  1797.   if (!from_tz_cached)
  1798.   {
  1799.     from_tz= my_tz_find(args[1]->val_str(&str), tz_tables);
  1800.     from_tz_cached= args[1]->const_item();
  1801.   }
  1803.   if (!to_tz_cached)
  1804.   {
  1805.     to_tz= my_tz_find(args[2]->val_str(&str), tz_tables);
  1806.     to_tz_cached= args[2]->const_item();
  1807.   }
  1809.   if (from_tz==0 || to_tz==0 || get_arg0_date(ltime, 0))
  1810.   {
  1811.     null_value= 1;
  1812.     return 1;
  1813.   }
  1815.   /* Check if we in range where we treat datetime values as non-UTC */
  1816.   if (ltime->year < TIMESTAMP_MAX_YEAR && ltime->year > TIMESTAMP_MIN_YEAR ||
  1817.       ltime->year==TIMESTAMP_MAX_YEAR && ltime->month==1 && ltime->day==1 ||
  1818.       ltime->year==TIMESTAMP_MIN_YEAR && ltime->month==12 && ltime->day==31)
  1819.   {
  1820.     my_time_tmp= from_tz->TIME_to_gmt_sec(ltime, &not_used);
  1821.     if (my_time_tmp >= TIMESTAMP_MIN_VALUE && my_time_tmp <= TIMESTAMP_MAX_VALUE)
  1822.       to_tz->gmt_sec_to_TIME(ltime, my_time_tmp);
  1823.   }
  1824.   
  1825.   null_value= 0;
  1826.   return 0;
  1827. }
  1830. void Item_func_convert_tz::cleanup()
  1831. {
  1832.   from_tz_cached= to_tz_cached= 0;
  1833.   Item_date_func::cleanup();
  1834. }
  1837. void Item_date_add_interval::fix_length_and_dec()
  1838. {
  1839.   enum_field_types arg0_field_type;
  1841.   collation.set(&my_charset_bin);
  1842.   maybe_null=1;
  1843.   max_length=MAX_DATETIME_FULL_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
  1844.   value.alloc(max_length);
  1846.   /*
  1847.     The field type for the result of an Item_date function is defined as
  1848.     follows:
  1850.     - If first arg is a MYSQL_TYPE_DATETIME result is MYSQL_TYPE_DATETIME
  1851.     - If first arg is a MYSQL_TYPE_DATE and the interval type uses hours,
  1852.       minutes or seconds then type is MYSQL_TYPE_DATETIME.
  1853.     - Otherwise the result is MYSQL_TYPE_STRING
  1854.       (This is because you can't know if the string contains a DATE, TIME or
  1855.       DATETIME argument)
  1856.   */
  1857.   cached_field_type= MYSQL_TYPE_STRING;
  1858.   arg0_field_type= args[0]->field_type();
  1859.   if (arg0_field_type == MYSQL_TYPE_DATETIME ||
  1860.       arg0_field_type == MYSQL_TYPE_TIMESTAMP)
  1861.     cached_field_type= MYSQL_TYPE_DATETIME;
  1862.   else if (arg0_field_type == MYSQL_TYPE_DATE)
  1863.   {
  1864.     if (int_type <= INTERVAL_DAY || int_type == INTERVAL_YEAR_MONTH)
  1865.       cached_field_type= arg0_field_type;
  1866.     else
  1867.       cached_field_type= MYSQL_TYPE_DATETIME;
  1868.   }
  1869. }
  1872. /* Here arg[1] is a Item_interval object */
  1874. bool Item_date_add_interval::get_date(TIME *ltime, uint fuzzy_date)
  1875. {
  1876.   long period,sign;
  1877.   INTERVAL interval;
  1879.   ltime->neg= 0;
  1880.   if (args[0]->get_date(ltime,0) ||
  1881.       get_interval_value(args[1],int_type,&value,&interval))
  1882.     goto null_date;
  1883.   sign= (interval.neg ? -1 : 1);
  1884.   if (date_sub_interval)
  1885.     sign = -sign;
  1887.   null_value=0;
  1888.   switch (int_type) {
  1889.   case INTERVAL_SECOND:
  1890.   case INTERVAL_SECOND_MICROSECOND:
  1891.   case INTERVAL_MICROSECOND:
  1892.   case INTERVAL_MINUTE:
  1893.   case INTERVAL_HOUR:
  1894.   case INTERVAL_MINUTE_MICROSECOND:
  1895.   case INTERVAL_MINUTE_SECOND:
  1896.   case INTERVAL_HOUR_MICROSECOND:
  1897.   case INTERVAL_HOUR_SECOND:
  1898.   case INTERVAL_HOUR_MINUTE:
  1899.   case INTERVAL_DAY_MICROSECOND:
  1900.   case INTERVAL_DAY_SECOND:
  1901.   case INTERVAL_DAY_MINUTE:
  1902.   case INTERVAL_DAY_HOUR:
  1903.   {
  1904.     longlong sec, days, daynr, microseconds, extra_sec;
  1905.     ltime->time_type= MYSQL_TIMESTAMP_DATETIME; // Return full date
  1906.     microseconds= ltime->second_part + sign*interval.second_part;
  1907.     extra_sec= microseconds/1000000L;
  1908.     microseconds= microseconds%1000000L;
  1910.     sec=((ltime->day-1)*3600*24L+ltime->hour*3600+ltime->minute*60+
  1911.  ltime->second +
  1912.  sign* (longlong) (interval.day*3600*24L +
  1913.                            interval.hour*LL(3600)+interval.minute*LL(60)+
  1914.                            interval.second))+ extra_sec;
  1915.     if (microseconds < 0)
  1916.     {
  1917.       microseconds+= LL(1000000);
  1918.       sec--;
  1919.     }
  1920.     days= sec/(3600*LL(24));
  1921.     sec-= days*3600*LL(24);
  1922.     if (sec < 0)
  1923.     {
  1924.       days--;
  1925.       sec+= 3600*LL(24);
  1926.     }
  1927.     ltime->second_part= (uint) microseconds;
  1928.     ltime->second= (uint) (sec % 60);
  1929.     ltime->minute= (uint) (sec/60 % 60);
  1930.     ltime->hour=   (uint) (sec/3600);
  1931.     daynr= calc_daynr(ltime->year,ltime->month,1) + days;
  1932.     /* Day number from year 0 to 9999-12-31 */
  1933.     if ((ulonglong) daynr >= MAX_DAY_NUMBER)
  1934.       goto null_date;
  1935.     get_date_from_daynr((long) daynr, &ltime->year, &ltime->month,
  1936.                         &ltime->day);
  1937.     break;
  1938.   }
  1939.   case INTERVAL_DAY:
  1940.     period= (calc_daynr(ltime->year,ltime->month,ltime->day) +
  1941.              sign * (long) interval.day);
  1942.     /* Daynumber from year 0 to 9999-12-31 */
  1943.     if ((ulong) period >= MAX_DAY_NUMBER)
  1944.       goto null_date;
  1945.     get_date_from_daynr((long) period,&ltime->year,&ltime->month,&ltime->day);
  1946.     break;
  1947.   case INTERVAL_YEAR:
  1948.     ltime->year+= sign * (long) interval.year;
  1949.     if ((ulong) ltime->year >= 10000L)
  1950.       goto null_date;
  1951.     if (ltime->month == 2 && ltime->day == 29 &&
  1952. calc_days_in_year(ltime->year) != 366)
  1953.       ltime->day=28; // Was leap-year
  1954.     break;
  1955.   case INTERVAL_YEAR_MONTH:
  1956.   case INTERVAL_MONTH:
  1957.     period= (ltime->year*12 + sign * (long) interval.year*12 +
  1958.      ltime->month-1 + sign * (long) interval.month);
  1959.     if ((ulong) period >= 120000L)
  1960.       goto null_date;
  1961.     ltime->year= (uint) (period / 12);
  1962.     ltime->month= (uint) (period % 12L)+1;
  1963.     /* Adjust day if the new month doesn't have enough days */
  1964.     if (ltime->day > days_in_month[ltime->month-1])
  1965.     {
  1966.       ltime->day = days_in_month[ltime->month-1];
  1967.       if (ltime->month == 2 && calc_days_in_year(ltime->year) == 366)
  1968. ltime->day++; // Leap-year
  1969.     }
  1970.     break;
  1971.   default:
  1972.     goto null_date;
  1973.   }
  1974.   return 0; // Ok
  1976.  null_date:
  1977.   return (null_value=1);
  1978. }
  1981. String *Item_date_add_interval::val_str(String *str)
  1982. {
  1983.   DBUG_ASSERT(fixed == 1);
  1984.   TIME ltime;
  1985.   enum date_time_format_types format;
  1987.   if (Item_date_add_interval::get_date(&ltime,0))
  1988.     return 0;
  1990.   if (ltime.time_type == MYSQL_TIMESTAMP_DATE)
  1991.     format= DATE_ONLY;
  1992.   else if (ltime.second_part)
  1993.     format= DATE_TIME_MICROSECOND;
  1994.   else
  1995.     format= DATE_TIME;
  1997.   if (!make_datetime(format, &ltime, str))
  1998.     return str;
  2000.   null_value=1;
  2001.   return 0;
  2002. }
  2005. longlong Item_date_add_interval::val_int()
  2006. {
  2007.   DBUG_ASSERT(fixed == 1);
  2008.   TIME ltime;
  2009.   longlong date;
  2010.   if (Item_date_add_interval::get_date(&ltime,0))
  2011.     return (longlong) 0;
  2012.   date = (ltime.year*100L + ltime.month)*100L + ltime.day;
  2013.   return ltime.time_type == MYSQL_TIMESTAMP_DATE ? date :
  2014.     ((date*100L + ltime.hour)*100L+ ltime.minute)*100L + ltime.second;
  2015. }
  2017. static const char *interval_names[]=
  2018. {
  2019.   "year", "month", "day", "hour", "minute",
  2020.   "second", "microsecond", "year_month",
  2021.   "day_hour", "day_minute", "day_second",
  2022.   "hour_minute", "hour_second", "minute_second",
  2023.   "day_microsecond", "hour_microsecond",
  2024.   "minute_microsecond", "second_microsecond"
  2025. };
  2027. void Item_date_add_interval::print(String *str)
  2028. {
  2029.   str->append('(');
  2030.   args[0]->print(str);
  2031.   str->append(date_sub_interval?" - interval ":" + interval ");
  2032.   args[1]->print(str);
  2033.   str->append(' ');
  2034.   str->append(interval_names[int_type]);
  2035.   str->append(')');
  2036. }
  2038. void Item_extract::print(String *str)
  2039. {
  2040.   str->append("extract(", 8);
  2041.   str->append(interval_names[int_type]);
  2042.   str->append(" from ", 6);
  2043.   args[0]->print(str);
  2044.   str->append(')');
  2045. }
  2047. void Item_extract::fix_length_and_dec()
  2048. {
  2049.   value.alloc(32); // alloc buffer
  2051.   maybe_null=1; // If wrong date
  2052.   switch (int_type) {
  2053.   case INTERVAL_YEAR: max_length=4; date_value=1; break;
  2054.   case INTERVAL_YEAR_MONTH: max_length=6; date_value=1; break;
  2055.   case INTERVAL_MONTH: max_length=2; date_value=1; break;
  2056.   case INTERVAL_DAY: max_length=2; date_value=1; break;
  2057.   case INTERVAL_DAY_HOUR: max_length=9; date_value=0; break;
  2058.   case INTERVAL_DAY_MINUTE: max_length=11; date_value=0; break;
  2059.   case INTERVAL_DAY_SECOND: max_length=13; date_value=0; break;
  2060.   case INTERVAL_HOUR: max_length=2; date_value=0; break;
  2061.   case INTERVAL_HOUR_MINUTE: max_length=4; date_value=0; break;
  2062.   case INTERVAL_HOUR_SECOND: max_length=6; date_value=0; break;
  2063.   case INTERVAL_MINUTE: max_length=2; date_value=0; break;
  2064.   case INTERVAL_MINUTE_SECOND: max_length=4; date_value=0; break;
  2065.   case INTERVAL_SECOND: max_length=2; date_value=0; break;
  2066.   case INTERVAL_MICROSECOND: max_length=2; date_value=0; break;
  2067.   case INTERVAL_DAY_MICROSECOND: max_length=20; date_value=0; break;
  2068.   case INTERVAL_HOUR_MICROSECOND: max_length=13; date_value=0; break;
  2069.   case INTERVAL_MINUTE_MICROSECOND: max_length=11; date_value=0; break;
  2070.   case INTERVAL_SECOND_MICROSECOND: max_length=9; date_value=0; break;
  2071.   }
  2072. }
  2075. longlong Item_extract::val_int()
  2076. {
  2077.   DBUG_ASSERT(fixed == 1);
  2078.   TIME ltime;
  2079.   long neg;
  2080.   if (date_value)
  2081.   {
  2082.     if (get_arg0_date(&ltime,1))
  2083.       return 0;
  2084.     neg=1;
  2085.   }
  2086.   else
  2087.   {
  2088.     String *res= args[0]->val_str(&value);
  2089.     if (!res || str_to_time_with_warn(res->ptr(), res->length(), &ltime))
  2090.     {
  2091.       null_value=1;
  2092.       return 0;
  2093.     }
  2094.     neg= ltime.neg ? -1 : 1;
  2095.     null_value=0;
  2096.   }
  2097.   switch (int_type) {
  2098.   case INTERVAL_YEAR: return ltime.year;
  2099.   case INTERVAL_YEAR_MONTH: return ltime.year*100L+ltime.month;
  2100.   case INTERVAL_MONTH: return ltime.month;
  2101.   case INTERVAL_DAY: return ltime.day;
  2102.   case INTERVAL_DAY_HOUR: return (long) (ltime.day*100L+ltime.hour)*neg;
  2103.   case INTERVAL_DAY_MINUTE: return (long) (ltime.day*10000L+
  2104.        ltime.hour*100L+
  2105.        ltime.minute)*neg;
  2106.   case INTERVAL_DAY_SECOND:  return ((longlong) ltime.day*1000000L+
  2107.  (longlong) (ltime.hour*10000L+
  2108.      ltime.minute*100+
  2109.      ltime.second))*neg;
  2110.   case INTERVAL_HOUR: return (long) ltime.hour*neg;
  2111.   case INTERVAL_HOUR_MINUTE: return (long) (ltime.hour*100+ltime.minute)*neg;
  2112.   case INTERVAL_HOUR_SECOND: return (long) (ltime.hour*10000+ltime.minute*100+
  2113.        ltime.second)*neg;
  2114.   case INTERVAL_MINUTE: return (long) ltime.minute*neg;
  2115.   case INTERVAL_MINUTE_SECOND: return (long) (ltime.minute*100+ltime.second)*neg;
  2116.   case INTERVAL_SECOND: return (long) ltime.second*neg;
  2117.   case INTERVAL_MICROSECOND: return (long) ltime.second_part*neg;
  2118.   case INTERVAL_DAY_MICROSECOND: return (((longlong)ltime.day*1000000L +
  2119.   (longlong)ltime.hour*10000L +
  2120.   ltime.minute*100 +
  2121.   ltime.second)*1000000L +
  2122.  ltime.second_part)*neg;
  2123.   case INTERVAL_HOUR_MICROSECOND: return (((longlong)ltime.hour*10000L +
  2124.    ltime.minute*100 +
  2125.    ltime.second)*1000000L +
  2126.   ltime.second_part)*neg;
  2127.   case INTERVAL_MINUTE_MICROSECOND: return (((longlong)(ltime.minute*100+
  2128. ltime.second))*1000000L+
  2129.     ltime.second_part)*neg;
  2130.   case INTERVAL_SECOND_MICROSECOND: return ((longlong)ltime.second*1000000L+
  2131.     ltime.second_part)*neg;
  2132.   }
  2133.   return 0; // Impossible
  2134. }
  2136. bool Item_extract::eq(const Item *item, bool binary_cmp) const
  2137. {
  2138.   if (this == item)
  2139.     return 1;
  2140.   if (item->type() != FUNC_ITEM ||
  2141.       func_name() != ((Item_func*)item)->func_name())
  2142.     return 0;
  2144.   Item_extract* ie= (Item_extract*)item;
  2145.   if (ie->int_type != int_type)
  2146.     return 0;
  2148.   if (!args[0]->eq(ie->args[0], binary_cmp))
  2149.       return 0;
  2150.   return 1;
  2151. }
  2154. bool Item_char_typecast::eq(const Item *item, bool binary_cmp) const
  2155. {
  2156.   if (this == item)
  2157.     return 1;
  2158.   if (item->type() != FUNC_ITEM ||
  2159.       func_name() != ((Item_func*)item)->func_name())
  2160.     return 0;
  2162.   Item_char_typecast *cast= (Item_char_typecast*)item;
  2163.   if (cast_length != cast->cast_length ||
  2164.       cast_cs     != cast->cast_cs)
  2165.     return 0;
  2167.   if (!args[0]->eq(cast->args[0], binary_cmp))
  2168.       return 0;
  2169.   return 1;
  2170. }
  2172. void Item_typecast::print(String *str)
  2173. {
  2174.   str->append("cast(", 5);
  2175.   args[0]->print(str);
  2176.   str->append(" as ", 4);
  2177.   str->append(cast_type());
  2178.   str->append(')');
  2179. }
  2182. void Item_char_typecast::print(String *str)
  2183. {
  2184.   str->append("cast(", 5);
  2185.   args[0]->print(str);
  2186.   str->append(" as char", 8);
  2187.   if (cast_length >= 0)
  2188.   {
  2189.     str->append('(');
  2190.     char buffer[20];
  2191.     // my_charset_bin is good enough for numbers
  2192.     String st(buffer, sizeof(buffer), &my_charset_bin);
  2193.     st.set((ulonglong)cast_length, &my_charset_bin);
  2194.     str->append(st);
  2195.     str->append(')');
  2196.   }
  2197.   if (cast_cs)
  2198.   {
  2199.     str->append(" charset ", 9);
  2200.     str->append(cast_cs->name);
  2201.   }
  2202.   str->append(')');
  2203. }
  2205. String *Item_char_typecast::val_str(String *str)
  2206. {
  2207.   DBUG_ASSERT(fixed == 1);
  2208.   String *res;
  2209.   uint32 length;
  2211.   if (!charset_conversion)
  2212.   {
  2213.     if (!(res= args[0]->val_str(str)))
  2214.     {
  2215.       null_value= 1;
  2216.       return 0;
  2217.     }
  2218.   }
  2219.   else
  2220.   {
  2221.     // Convert character set if differ
  2222.     uint dummy_errors;
  2223.     if (!(res= args[0]->val_str(&tmp_value)) ||
  2224. str->copy(res->ptr(), res->length(), res->charset(),
  2225.                   cast_cs, &dummy_errors))
  2226.     {
  2227.       null_value= 1;
  2228.       return 0;
  2229.     }
  2230.     res= str;
  2231.   }
  2233.   res->set_charset(cast_cs);
  2235.   /*
  2236.      Cut the tail if cast with length
  2237.      and the result is longer than cast length, e.g.
  2238.      CAST('string' AS CHAR(1))
  2239.   */
  2240.   if (cast_length >= 0 &&
  2241.       (res->length() > (length= (uint32) res->charpos(cast_length))))
  2242.   { // Safe even if const arg
  2243.     if (!res->alloced_length())
  2244.     { // Don't change const str
  2245.       str_value= *res; // Not malloced string
  2246.       res= &str_value;
  2247.     }
  2248.     res->length((uint) length);
  2249.   }
  2250.   null_value= 0;
  2251.   return res;
  2252. }
  2254. void Item_char_typecast::fix_length_and_dec()
  2255. {
  2256.   uint32 char_length;
  2257.   /* 
  2258.      We always force character set conversion if cast_cs
  2259.      is a multi-byte character set. It garantees that the
  2260.      result of CAST is a well-formed string.
  2261.      For single-byte character sets we allow just to copy
  2262.      from the argument. A single-byte character sets string
  2263.      is always well-formed. 
  2264.   */
  2265.   charset_conversion= (cast_cs->mbmaxlen > 1) ||
  2266.                       !my_charset_same(args[0]->collation.collation, cast_cs) &&
  2267.                       args[0]->collation.collation != &my_charset_bin &&
  2268.                       cast_cs != &my_charset_bin;
  2269.   collation.set(cast_cs, DERIVATION_IMPLICIT);
  2270.   char_length= (cast_length >= 0) ? cast_length : 
  2271.        args[0]->max_length/args[0]->collation.collation->mbmaxlen;
  2272.   max_length= char_length * cast_cs->mbmaxlen;
  2273. }
  2276. String *Item_datetime_typecast::val_str(String *str)
  2277. {
  2278.   DBUG_ASSERT(fixed == 1);
  2279.   TIME ltime;
  2280.   if (!get_arg0_date(&ltime,1) &&
  2281.       !make_datetime(ltime.second_part ? DATE_TIME_MICROSECOND : DATE_TIME, 
  2282.      &ltime, str))
  2283.     return str;
  2285.   null_value=1;
  2286.   return 0;
  2287. }
  2290. bool Item_time_typecast::get_time(TIME *ltime)
  2291. {
  2292.   bool res= get_arg0_time(ltime);
  2293.   /*
  2294.     For MYSQL_TIMESTAMP_TIME value we can have non-zero day part,
  2295.     which we should not lose.
  2296.   */
  2297.   if (ltime->time_type == MYSQL_TIMESTAMP_DATETIME)
  2298.     ltime->year= ltime->month= ltime->day= 0;
  2299.   ltime->time_type= MYSQL_TIMESTAMP_TIME;
  2300.   return res;
  2301. }
  2304. String *Item_time_typecast::val_str(String *str)
  2305. {
  2306.   DBUG_ASSERT(fixed == 1);
  2307.   TIME ltime;
  2309.   if (!get_arg0_time(&ltime) &&
  2310.       !make_datetime(ltime.second_part ? TIME_MICROSECOND : TIME_ONLY,
  2311.      &ltime, str))
  2312.     return str;
  2314.   null_value=1;
  2315.   return 0;
  2316. }
  2319. bool Item_date_typecast::get_date(TIME *ltime, uint fuzzy_date)
  2320. {
  2321.   bool res= get_arg0_date(ltime,1);
  2322.   ltime->hour= ltime->minute= ltime->second= ltime->second_part= 0;
  2323.   ltime->time_type= MYSQL_TIMESTAMP_DATE;
  2324.   return res;
  2325. }
  2328. String *Item_date_typecast::val_str(String *str)
  2329. {
  2330.   DBUG_ASSERT(fixed == 1);
  2331.   TIME ltime;
  2333.   if (!get_arg0_date(&ltime,1) && !str->alloc(11))
  2334.   {
  2335.     make_date((DATE_TIME_FORMAT *) 0, &ltime, str);
  2336.     return str;
  2337.   }
  2339.   null_value=1;
  2340.   return 0;
  2341. }
  2344. /*
  2345.   MAKEDATE(a,b) is a date function that creates a date value 
  2346.   from a year and day value.
  2347. */
  2349. String *Item_func_makedate::val_str(String *str)
  2350. {
  2351.   DBUG_ASSERT(fixed == 1);
  2352.   TIME l_time;
  2353.   long daynr=  (long) args[1]->val_int();
  2354.   long yearnr= (long) args[0]->val_int();
  2355.   long days;
  2357.   if (args[0]->null_value || args[1]->null_value ||
  2358.       yearnr < 0 || daynr <= 0)
  2359.     goto err;
  2361.   days= calc_daynr(yearnr,1,1) + daynr - 1;
  2362.   /* Day number from year 0 to 9999-12-31 */
  2363.   if (days >= 0 && days < MAX_DAY_NUMBER)
  2364.   {
  2365.     null_value=0;
  2366.     get_date_from_daynr(days,&l_time.year,&l_time.month,&l_time.day);
  2367.     if (str->alloc(11))
  2368.       goto err;
  2369.     make_date((DATE_TIME_FORMAT *) 0, &l_time, str);
  2370.     return str;
  2371.   }
  2373. err:
  2374.   null_value=1;
  2375.   return 0;
  2376. }
  2379. void Item_func_add_time::fix_length_and_dec()
  2380. {
  2381.   enum_field_types arg0_field_type;
  2382.   decimals=0;
  2383.   max_length=MAX_DATETIME_FULL_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
  2384.   maybe_null= 1;
  2386.   /*
  2387.     The field type for the result of an Item_func_add_time function is defined
  2388.     as follows:
  2390.     - If first arg is a MYSQL_TYPE_DATETIME or MYSQL_TYPE_TIMESTAMP 
  2391.       result is MYSQL_TYPE_DATETIME
  2392.     - If first arg is a MYSQL_TYPE_TIME result is MYSQL_TYPE_TIME
  2393.     - Otherwise the result is MYSQL_TYPE_STRING
  2394.   */
  2396.   cached_field_type= MYSQL_TYPE_STRING;
  2397.   arg0_field_type= args[0]->field_type();
  2398.   if (arg0_field_type == MYSQL_TYPE_DATE ||
  2399.       arg0_field_type == MYSQL_TYPE_DATETIME ||
  2400.       arg0_field_type == MYSQL_TYPE_TIMESTAMP)
  2401.     cached_field_type= MYSQL_TYPE_DATETIME;
  2402.   else if (arg0_field_type == MYSQL_TYPE_TIME)
  2403.     cached_field_type= MYSQL_TYPE_TIME;
  2404. }
  2406. /*
  2407.   ADDTIME(t,a) and SUBTIME(t,a) are time functions that calculate a
  2408.   time/datetime value 
  2410.   t: time_or_datetime_expression
  2411.   a: time_expression
  2412.   
  2413.   Result: Time value or datetime value
  2414. */
  2416. String *Item_func_add_time::val_str(String *str)
  2417. {
  2418.   DBUG_ASSERT(fixed == 1);
  2419.   TIME l_time1, l_time2, l_time3;
  2420.   bool is_time= 0;
  2421.   long days, microseconds;
  2422.   longlong seconds;
  2423.   int l_sign= sign;
  2425.   null_value=0;
  2426.   if (is_date)                        // TIMESTAMP function
  2427.   {
  2428.     if (get_arg0_date(&l_time1,1) || 
  2429.         args[1]->get_time(&l_time2) ||
  2430.         l_time1.time_type == MYSQL_TIMESTAMP_TIME || 
  2431.         l_time2.time_type != MYSQL_TIMESTAMP_TIME)
  2432.       goto null_date;
  2433.   }
  2434.   else                                // ADDTIME function
  2435.   {
  2436.     if (args[0]->get_time(&l_time1) || 
  2437.         args[1]->get_time(&l_time2) ||
  2438.         l_time2.time_type == MYSQL_TIMESTAMP_DATETIME)
  2439.       goto null_date;
  2440.     is_time= (l_time1.time_type == MYSQL_TIMESTAMP_TIME);
  2441.   }
  2442.   if (l_time1.neg != l_time2.neg)
  2443.     l_sign= -l_sign;
  2445.   l_time3.neg= calc_time_diff(&l_time1, &l_time2, -l_sign,
  2446.       &seconds, &microseconds);
  2448.   /*
  2449.     If first argument was negative and diff between arguments
  2450.     is non-zero we need to swap sign to get proper result.
  2451.   */
  2452.   if (l_time1.neg && (seconds || microseconds))
  2453.     l_time3.neg= 1-l_time3.neg;         // Swap sign of result
  2455.   if (!is_time && l_time3.neg)
  2456.     goto null_date;
  2458.   days= (long)(seconds/86400L);
  2460.   calc_time_from_sec(&l_time3, (long)(seconds%86400L), microseconds);
  2461.   if (!is_time)
  2462.   {
  2463.     get_date_from_daynr(days,&l_time3.year,&l_time3.month,&l_time3.day);
  2464.     if (l_time3.day &&
  2465. !make_datetime(l_time1.second_part || l_time2.second_part ?
  2466.        DATE_TIME_MICROSECOND : DATE_TIME,
  2467.        &l_time3, str))
  2468.       return str;
  2469.     goto null_date;
  2470.   }
  2471.   
  2472.   l_time3.hour+= days*24;
  2473.   if (!make_datetime(l_time1.second_part || l_time2.second_part ?
  2474.      TIME_MICROSECOND : TIME_ONLY,
  2475.      &l_time3, str))
  2476.     return str;
  2478. null_date:
  2479.   null_value=1;
  2480.   return 0;
  2481. }
  2484. void Item_func_add_time::print(String *str)
  2485. {
  2486.   if (is_date)
  2487.   {
  2488.     DBUG_ASSERT(sign > 0);
  2489.     str->append("timestamp(", 10);
  2490.   }
  2491.   else
  2492.   {
  2493.     if (sign > 0)
  2494.       str->append("addtime(", 8);
  2495.     else
  2496.       str->append("subtime(", 8);
  2497.   }
  2498.   args[0]->print(str);
  2499.   str->append(',');
  2500.   args[0]->print(str);
  2501.   str->append(')');
  2502. }
  2505. /*
  2506.   TIMEDIFF(t,s) is a time function that calculates the 
  2507.   time value between a start and end time.
  2509.   t and s: time_or_datetime_expression
  2510.   Result: Time value
  2511. */
  2513. String *Item_func_timediff::val_str(String *str)
  2514. {
  2515.   DBUG_ASSERT(fixed == 1);
  2516.   longlong seconds;
  2517.   long microseconds;
  2518.   int l_sign= 1;
  2519.   TIME l_time1 ,l_time2, l_time3;
  2521.   null_value= 0;  
  2522.   if (args[0]->get_time(&l_time1) ||
  2523.       args[1]->get_time(&l_time2) ||
  2524.       l_time1.time_type != l_time2.time_type)
  2525.     goto null_date;
  2527.   if (l_time1.neg != l_time2.neg)
  2528.     l_sign= -l_sign;
  2530.   l_time3.neg= calc_time_diff(&l_time1, &l_time2, l_sign,
  2531.       &seconds, &microseconds);
  2533.   /*
  2534.     For MYSQL_TIMESTAMP_TIME only:
  2535.       If first argument was negative and diff between arguments
  2536.       is non-zero we need to swap sign to get proper result.
  2537.   */
  2538.   if (l_time1.neg && (seconds || microseconds))
  2539.     l_time3.neg= 1-l_time3.neg;         // Swap sign of result
  2541.   calc_time_from_sec(&l_time3, (long) seconds, microseconds);
  2543.   if (!make_datetime(l_time1.second_part || l_time2.second_part ?
  2544.      TIME_MICROSECOND : TIME_ONLY,
  2545.      &l_time3, str))
  2546.     return str;
  2548. null_date:
  2549.   null_value=1;
  2550.   return 0;
  2551. }
  2553. /*
  2554.   MAKETIME(h,m,s) is a time function that calculates a time value 
  2555.   from the total number of hours, minutes, and seconds.
  2556.   Result: Time value
  2557. */
  2559. String *Item_func_maketime::val_str(String *str)
  2560. {
  2561.   DBUG_ASSERT(fixed == 1);
  2562.   TIME ltime;
  2564.   long hour=   (long) args[0]->val_int();
  2565.   long minute= (long) args[1]->val_int();
  2566.   long second= (long) args[2]->val_int();
  2568.   if ((null_value=(args[0]->null_value || 
  2569.    args[1]->null_value ||
  2570.    args[2]->null_value || 
  2571.    minute > 59 || minute < 0 || 
  2572.    second > 59 || second < 0 ||
  2573.    str->alloc(19))))
  2574.     return 0;
  2576.   ltime.neg= 0;
  2577.   if (hour < 0)
  2578.   {
  2579.     ltime.neg= 1;
  2580.     hour= -hour;
  2581.   }
  2582.   ltime.hour=   (ulong) hour;
  2583.   ltime.minute= (ulong) minute;
  2584.   ltime.second= (ulong) second;
  2585.   make_time((DATE_TIME_FORMAT *) 0, &ltime, str);
  2586.   return str;
  2587. }
  2590. /*
  2591.   MICROSECOND(a) is a function ( extraction) that extracts the microseconds
  2592.   from a.
  2594.   a: Datetime or time value
  2595.   Result: int value
  2596. */
  2598. longlong Item_func_microsecond::val_int()
  2599. {
  2600.   DBUG_ASSERT(fixed == 1);
  2601.   TIME ltime;
  2602.   if (!get_arg0_time(&ltime))
  2603.     return ltime.second_part;
  2604.   return 0;
  2605. }
  2608. String *Item_func_get_format::val_str(String *str)
  2609. {
  2610.   DBUG_ASSERT(fixed == 1);
  2611.   const char *format_name;
  2612.   KNOWN_DATE_TIME_FORMAT *format;
  2613.   String *val= args[0]->val_str(str);
  2614.   ulong val_len;
  2616.   if ((null_value= args[0]->null_value))
  2617.     return 0;    
  2619.   val_len= val->length();
  2620.   for (format= &known_date_time_formats[0];
  2621.        (format_name= format->format_name);
  2622.        format++)
  2623.   {
  2624.     uint format_name_len;
  2625.     format_name_len= strlen(format_name);
  2626.     if (val_len == format_name_len &&
  2627. !my_strnncoll(&my_charset_latin1, 
  2628.       (const uchar *) val->ptr(), val_len, 
  2629.       (const uchar *) format_name, val_len))
  2630.     {
  2631.       const char *format_str= get_date_time_format_str(format, type);
  2632.       str->set(format_str, strlen(format_str), &my_charset_bin);
  2633.       return str;
  2634.     }
  2635.   }
  2637.   null_value= 1;
  2638.   return 0;
  2639. }
  2642. void Item_func_get_format::print(String *str)
  2643. {
  2644.   str->append(func_name());
  2645.   str->append('(');
  2647.   switch (type) {
  2648.   case MYSQL_TIMESTAMP_DATE:
  2649.     str->append("DATE, ");
  2650.     break;
  2651.   case MYSQL_TIMESTAMP_DATETIME:
  2652.     str->append("DATETIME, ");
  2653.     break;
  2654.   case MYSQL_TIMESTAMP_TIME:
  2655.     str->append("TIME, ");
  2656.     break;
  2657.   default:
  2658.     DBUG_ASSERT(0);
  2659.   }
  2660.   args[0]->print(str);
  2661.   str->append(')');
  2662. }
  2665. /*
  2666.   Get type of datetime value (DATE/TIME/...) which will be produced
  2667.   according to format string.
  2669.   SYNOPSIS
  2670.     get_date_time_result_type()
  2671.       format - format string
  2672.       length - length of format string
  2674.   NOTE
  2675.     We don't process day format's characters('D', 'd', 'e') because day
  2676.     may be a member of all date/time types.
  2678.     Format specifiers supported by this function should be in sync with
  2679.     specifiers supported by extract_date_time() function.
  2681.   RETURN VALUE
  2682.     One of date_time_format_types values:
  2683.     DATE_TIME_MICROSECOND, DATE_TIME, DATE_ONLY, TIME_MICROSECOND, TIME_ONLY
  2684. */
  2686. static date_time_format_types
  2687. get_date_time_result_type(const char *format, uint length)
  2688. {
  2689.   const char *time_part_frms= "HISThiklrs";
  2690.   const char *date_part_frms= "MVUXYWabcjmvuxyw";
  2691.   bool date_part_used= 0, time_part_used= 0, frac_second_used= 0;
  2692.   
  2693.   const char *val= format;
  2694.   const char *end= format + length;
  2696.   for (; val != end && val != end; val++)
  2697.   {
  2698.     if (*val == '%' && val+1 != end)
  2699.     {
  2700.       val++;
  2701.       if (*val == 'f')
  2702.         frac_second_used= time_part_used= 1;
  2703.       else if (!time_part_used && strchr(time_part_frms, *val))
  2704. time_part_used= 1;
  2705.       else if (!date_part_used && strchr(date_part_frms, *val))
  2706. date_part_used= 1;
  2707.       if (date_part_used && frac_second_used)
  2708.       {
  2709.         /*
  2710.           frac_second_used implies time_part_used, and thus we already
  2711.           have all types of date-time components and can end our search.
  2712.         */
  2713. return DATE_TIME_MICROSECOND;
  2714.       }
  2715.     }
  2716.   }
  2718.   /* We don't have all three types of date-time components */
  2719.   if (frac_second_used)
  2720.     return TIME_MICROSECOND;
  2721.   if (time_part_used)
  2722.   {
  2723.     if (date_part_used)
  2724.       return DATE_TIME;
  2725.     return TIME_ONLY;
  2726.   }
  2727.   return DATE_ONLY;
  2728. }
  2731. Field *Item_func_str_to_date::tmp_table_field(TABLE *t_arg)
  2732. {
  2733.   if (cached_field_type == MYSQL_TYPE_TIME)
  2734.     return (new Field_time(maybe_null, name, t_arg, &my_charset_bin));
  2735.   if (cached_field_type == MYSQL_TYPE_DATE)
  2736.     return (new Field_date(maybe_null, name, t_arg, &my_charset_bin));
  2737.   if (cached_field_type == MYSQL_TYPE_DATETIME)
  2738.     return (new Field_datetime(maybe_null, name, t_arg, &my_charset_bin));
  2739.   return (new Field_string(max_length, maybe_null, name, t_arg, &my_charset_bin));
  2740. }
  2743. void Item_func_str_to_date::fix_length_and_dec()
  2744. {
  2745.   char format_buff[64];
  2746.   String format_str(format_buff, sizeof(format_buff), &my_charset_bin);
  2747.   String *format;
  2748.   maybe_null= 1;
  2749.   decimals=0;
  2750.   cached_field_type= MYSQL_TYPE_STRING;
  2751.   max_length= MAX_DATETIME_FULL_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
  2752.   cached_timestamp_type= MYSQL_TIMESTAMP_NONE;
  2753.   if ((const_item= args[1]->const_item()))
  2754.   {
  2755.     format= args[1]->val_str(&format_str);
  2756.     cached_format_type= get_date_time_result_type(format->ptr(),
  2757.                                                   format->length());
  2758.     switch (cached_format_type) {
  2759.     case DATE_ONLY:
  2760.       cached_timestamp_type= MYSQL_TIMESTAMP_DATE;
  2761.       cached_field_type= MYSQL_TYPE_DATE; 
  2762.       max_length= MAX_DATE_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
  2763.       break;
  2764.     case TIME_ONLY:
  2765.     case TIME_MICROSECOND:
  2766.       cached_timestamp_type= MYSQL_TIMESTAMP_TIME;
  2767.       cached_field_type= MYSQL_TYPE_TIME; 
  2768.       max_length= MAX_TIME_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
  2769.       break;
  2770.     default:
  2771.       cached_timestamp_type= MYSQL_TIMESTAMP_DATETIME;
  2772.       cached_field_type= MYSQL_TYPE_DATETIME; 
  2773.       break;
  2774.     }
  2775.   }
  2776. }
  2778. bool Item_func_str_to_date::get_date(TIME *ltime, uint fuzzy_date)
  2779. {
  2780.   DATE_TIME_FORMAT date_time_format;
  2781.   char val_buff[64], format_buff[64];
  2782.   String val_str(val_buff, sizeof(val_buff), &my_charset_bin), *val;
  2783.   String format_str(format_buff, sizeof(format_buff), &my_charset_bin), *format;
  2785.   val=    args[0]->val_str(&val_str);
  2786.   format= args[1]->val_str(&format_str);
  2787.   if (args[0]->null_value || args[1]->null_value)
  2788.     goto null_date;
  2790.   null_value= 0;
  2791.   bzero((char*) ltime, sizeof(ltime));
  2792.   date_time_format.format.str=    (char*) format->ptr();
  2793.   date_time_format.format.length= format->length();
  2794.   if (extract_date_time(&date_time_format, val->ptr(), val->length(),
  2795. ltime, cached_timestamp_type, 0))
  2796.     goto null_date;
  2797.   if (cached_timestamp_type == MYSQL_TIMESTAMP_TIME && ltime->day)
  2798.   {
  2799.     /*
  2800.       Day part for time type can be nonzero value and so 
  2801.       we should add hours from day part to hour part to
  2802.       keep valid time value.
  2803.     */
  2804.     ltime->hour+= ltime->day*24;
  2805.     ltime->day= 0;
  2806.   }
  2807.   return 0;
  2809. null_date:
  2810.   return (null_value=1);
  2811. }
  2814. String *Item_func_str_to_date::val_str(String *str)
  2815. {
  2816.   DBUG_ASSERT(fixed == 1);
  2817.   TIME ltime;
  2819.   if (Item_func_str_to_date::get_date(&ltime, TIME_FUZZY_DATE))
  2820.     return 0;
  2822.   if (!make_datetime((const_item ? cached_format_type :
  2823.      (ltime.second_part ? DATE_TIME_MICROSECOND : DATE_TIME)),
  2824.      &ltime, str))
  2825.     return str;
  2826.   return 0;
  2827. }
  2830. bool Item_func_last_day::get_date(TIME *ltime, uint fuzzy_date)
  2831. {
  2832.   if (get_arg0_date(ltime, fuzzy_date & ~TIME_FUZZY_DATE))
  2833.     return 1;
  2834.   uint month_idx= ltime->month-1;
  2835.   ltime->day= days_in_month[month_idx];
  2836.   if ( month_idx == 1 && calc_days_in_year(ltime->year) == 366)
  2837.     ltime->day= 29;
  2838.   ltime->time_type= MYSQL_TIMESTAMP_DATE;
  2839.   return 0;
  2840. }