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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
item_timefunc.cc
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：27k
源码类别：

MySQL数据库

开发平台：

Visual C++

item_timefunc.cc：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  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.
  7.    
  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.
  12.    
  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 __GNUC__
  21. #pragma implementation // gcc: Class implementation
  22. #endif
  24. #include "mysql_priv.h"
  25. #include <m_ctype.h>
  26. #include <time.h>
  28. /*
  29. ** Todo: Move month and days to language files
  30. */
  32. static String month_names[] = { "January", "February", "March", "April",
  33.        "May", "June", "July", "August",
  34.        "September", "October", "November", "December" };
  35. static String day_names[] = { "Monday", "Tuesday", "Wednesday",
  36.      "Thursday", "Friday", "Saturday" ,"Sunday" };
  38. /*
  39. ** Get a array of positive numbers from a string object.
  40. ** Each number is separated by 1 non digit character
  41. ** Return error if there is too many numbers.
  42. ** If there is too few numbers, assume that the numbers are left out
  43. ** from the high end. This allows one to give:
  44. ** DAY_TO_SECOND as "D MM:HH:SS", "MM:HH:SS" "HH:SS" or as seconds.
  45. */
  47. bool get_interval_info(const char *str,uint length,uint count,
  48.        long *values)
  49. {
  50.   const char *end=str+length;
  51.   uint i;
  52.   while (str != end && !isdigit(*str))
  53.     str++;
  55.   for (i=0 ; i < count ; i++)
  56.   {
  57.     long value;
  58.     for (value=0; str != end && isdigit(*str) ; str++)
  59.       value=value*10L + (long) (*str - '0');
  60.     values[i]= value;
  61.     while (str != end && !isdigit(*str))
  62.       str++;
  63.     if (str == end && i != count-1)
  64.     {
  65.       i++;
  66.       /* Change values[0...i-1] -> values[0...count-1] */
  67.       bmove_upp((char*) (values+count), (char*) (values+i),
  68. sizeof(long)*i);
  69.       bzero((char*) values, sizeof(long)*(count-i));
  70.       break;
  71.     }
  72.   }
  73.   return (str != end);
  74. }
  76. longlong Item_func_period_add::val_int()
  77. {
  78.   ulong period=(ulong) args[0]->val_int();
  79.   int months=(int) args[1]->val_int();
  81.   if ((null_value=args[0]->null_value || args[1]->null_value) ||
  82.       period == 0L)
  83.     return 0; /* purecov: inspected */
  84.   return (longlong)
  85.     convert_month_to_period((uint) ((int) convert_period_to_month(period)+
  86.     months));
  87. }
  90. longlong Item_func_period_diff::val_int()
  91. {
  92.   ulong period1=(ulong) args[0]->val_int();
  93.   ulong period2=(ulong) args[1]->val_int();
  95.   if ((null_value=args[0]->null_value || args[1]->null_value))
  96.     return 0; /* purecov: inspected */
  97.   return (longlong) ((long) convert_period_to_month(period1)-
  98.      (long) convert_period_to_month(period2));
  99. }
  103. longlong Item_func_to_days::val_int()
  104. {
  105.   TIME ltime;
  106.   if (get_arg0_date(&ltime,0))
  107.     return 0;
  108.   return (longlong) calc_daynr(ltime.year,ltime.month,ltime.day);
  109. }
  111. longlong Item_func_dayofyear::val_int()
  112. {
  113.   TIME ltime;
  114.   if (get_arg0_date(&ltime,0))
  115.     return 0;
  116.   return (longlong) calc_daynr(ltime.year,ltime.month,ltime.day) -
  117.     calc_daynr(ltime.year,1,1) + 1;
  118. }
  120. longlong Item_func_dayofmonth::val_int()
  121. {
  122.   TIME ltime;
  123.   (void) get_arg0_date(&ltime,1);
  124.   return (longlong) ltime.day;
  125. }
  127. longlong Item_func_month::val_int()
  128. {
  129.   TIME ltime;
  130.   (void) get_arg0_date(&ltime,1);
  131.   return (longlong) ltime.month;
  132. }
  134. String* Item_func_monthname::val_str(String* str)
  135. {
  136.   uint month=(uint) Item_func_month::val_int();
  137.   if (!month) // This is also true for NULL
  138.   {
  139.     null_value=1;
  140.     return (String*) 0;
  141.   }
  142.   null_value=0;
  143.   return &month_names[month-1];
  144. }
  146. // Returns the quarter of the year
  148. longlong Item_func_quarter::val_int()
  149. {
  150.   TIME ltime;
  151.   (void) get_arg0_date(&ltime,1);
  152.   return (longlong) ((ltime.month+2)/3);
  153. }
  155. longlong Item_func_hour::val_int()
  156. {
  157.   TIME ltime;
  158.   (void) get_arg0_time(&ltime);
  159.   return ltime.hour;
  160. }
  162. longlong Item_func_minute::val_int()
  163. {
  164.   TIME ltime;
  165.   (void) get_arg0_time(&ltime);
  166.   return ltime.minute;
  167. }
  168. // Returns the second in time_exp in the range of 0 - 59
  170. longlong Item_func_second::val_int()
  171. {
  172.   TIME ltime;
  173.   (void) get_arg0_time(&ltime);
  174.   return ltime.second;
  175. }
  178. // Returns the week of year in the range of 0 - 53
  180. longlong Item_func_week::val_int()
  181. {
  182.   uint year;
  183.   TIME ltime;
  184.   if (get_arg0_date(&ltime,0))
  185.     return 0;
  186.   return (longlong) calc_week(&ltime, 0, args[1]->val_int() == 0, &year);
  187. }
  190. longlong Item_func_yearweek::val_int()
  191. {
  192.   uint year,week;
  193.   TIME ltime;
  194.   if (get_arg0_date(&ltime,0))
  195.     return 0;
  196.   week=calc_week(&ltime, 1, args[1]->val_int() == 0, &year);
  197.   return week+year*100;
  198. }
  201. /* weekday() has a automatic to_days() on item */
  203. longlong Item_func_weekday::val_int()
  204. {
  205.   ulong tmp_value=(ulong) args[0]->val_int();
  206.   if ((null_value=(args[0]->null_value || !tmp_value)))
  207.     return 0; /* purecov: inspected */
  209.   return (longlong) calc_weekday(tmp_value,odbc_type)+test(odbc_type);
  210. }
  212. String* Item_func_dayname::val_str(String* str)
  213. {
  214.   uint weekday=(uint) val_int(); // Always Item_func_daynr()
  215.   if (null_value)
  216.     return (String*) 0;
  217.   return &day_names[weekday];
  218. }
  221. longlong Item_func_year::val_int()
  222. {
  223.   TIME ltime;
  224.   (void) get_arg0_date(&ltime,1);
  225.   return (longlong) ltime.year;
  226. }
  229. longlong Item_func_unix_timestamp::val_int()
  230. {
  231.   if (arg_count == 0)
  232.     return (longlong) current_thd->query_start();
  233.   if (args[0]->type() == FIELD_ITEM)
  234.   { // Optimize timestamp field
  235.     Field *field=((Item_field*) args[0])->field;
  236.     if (field->type() == FIELD_TYPE_TIMESTAMP)
  237.       return ((Field_timestamp*) field)->get_timestamp();
  238.   }
  239.   String *str=args[0]->val_str(&value);
  240.   if ((null_value=args[0]->null_value))
  241.   {
  242.     return 0; /* purecov: inspected */
  243.   }
  244.   return (longlong) str_to_timestamp(str->ptr(),str->length());
  245. }
  248. longlong Item_func_time_to_sec::val_int()
  249. {
  250.   TIME ltime;
  251.   (void) get_arg0_time(&ltime);
  252.   return ltime.hour*3600L+ltime.minute*60+ltime.second;
  253. }
  256. /*
  257. ** Convert a string to a interval value
  258. ** To make code easy, allow interval objects without separators.
  259. */
  261. static bool get_interval_value(Item *args,interval_type int_type,
  262.        String *str_value, INTERVAL *t)
  263. {
  264.   long array[4],value;
  265.   const char *str;
  266.   uint32 length;
  267.   LINT_INIT(value);  LINT_INIT(str); LINT_INIT(length);
  269.   bzero((char*) t,sizeof(*t));
  270.   if ((int) int_type <= INTERVAL_SECOND)
  271.   {
  272.     value=(long) args->val_int();
  273.     if (args->null_value)
  274.       return 1;
  275.     if (value < 0)
  276.     {
  277.       t->neg=1;
  278.       value= -value;
  279.     }
  280.   }
  281.   else
  282.   {
  283.     String *res;
  284.     if (!(res=args->val_str(str_value)))
  285.       return (1);
  287.     /* record negative intervalls in t->neg */
  288.     str=res->ptr();
  289.     const char *end=str+res->length();
  290.     while (str != end && isspace(*str))
  291.       str++;
  292.     if (str != end && *str == '-')
  293.     {
  294.       t->neg=1;
  295.       str++;
  296.     }
  297.     length=(uint32) (end-str); // Set up pointers to new str
  298.   }
  300.   switch (int_type) {
  301.   case INTERVAL_YEAR:
  302.     t->year=value;
  303.     break;
  304.   case INTERVAL_MONTH:
  305.     t->month=value;
  306.     break;
  307.   case INTERVAL_DAY:
  308.     t->day=value;
  309.     break;
  310.   case INTERVAL_HOUR:
  311.     t->hour=value;
  312.     break;
  313.   case INTERVAL_MINUTE:
  314.     t->minute=value;
  315.     break;
  316.   case INTERVAL_SECOND:
  317.     t->second=value;
  318.     break;
  319.   case INTERVAL_YEAR_MONTH: // Allow YEAR-MONTH YYYYYMM
  320.     if (get_interval_info(str,length,2,array))
  321.       return (1);
  322.     t->year=array[0];
  323.     t->month=array[1];
  324.     break;
  325.   case INTERVAL_DAY_HOUR:
  326.     if (get_interval_info(str,length,2,array))
  327.       return (1);
  328.     t->day=array[0];
  329.     t->hour=array[1];
  330.     break;
  331.   case INTERVAL_DAY_MINUTE:
  332.     if (get_interval_info(str,length,3,array))
  333.       return (1);
  334.     t->day=array[0];
  335.     t->hour=array[1];
  336.     t->minute=array[2];
  337.     break;
  338.   case INTERVAL_DAY_SECOND:
  339.     if (get_interval_info(str,length,4,array))
  340.       return (1);
  341.     t->day=array[0];
  342.     t->hour=array[1];
  343.     t->minute=array[2];
  344.     t->second=array[3];
  345.     break;
  346.   case INTERVAL_HOUR_MINUTE:
  347.     if (get_interval_info(str,length,2,array))
  348.       return (1);
  349.     t->hour=array[0];
  350.     t->minute=array[1];
  351.     break;
  352.   case INTERVAL_HOUR_SECOND:
  353.     if (get_interval_info(str,length,3,array))
  354.       return (1);
  355.     t->hour=array[0];
  356.     t->minute=array[1];
  357.     t->second=array[2];
  358.     break;
  359.   case INTERVAL_MINUTE_SECOND:
  360.     if (get_interval_info(str,length,2,array))
  361.       return (1);
  362.     t->minute=array[0];
  363.     t->second=array[1];
  364.     break;
  365.   }
  366.   return 0;
  367. }
  370. String *Item_date::val_str(String *str)
  371. {
  372.   ulong value=(ulong) val_int();
  373.   if (null_value)
  374.     return (String*) 0;
  375.   if (!value) // zero daynr
  376.   {
  377.     str->copy("0000-00-00");
  378.     return str;
  379.   }
  380.   if (str->alloc(11))
  381.     return &empty_string; /* purecov: inspected */
  382.   sprintf((char*) str->ptr(),"%04d-%02d-%02d",
  383.   (int) (value/10000L) % 10000,
  384.   (int) (value/100)%100,
  385.   (int) (value%100));
  386.   str->length(10);
  387.   return str;
  388. }
  391. bool Item_date::save_in_field(Field *field)
  392. {
  393.   TIME ltime;
  394.   timestamp_type t_type=TIMESTAMP_FULL;
  395.   if (get_date(&ltime,1))
  396.   {
  397.     if (null_value)
  398.       return set_field_to_null(field);
  399.     t_type=TIMESTAMP_NONE; // Error
  400.   }
  401.   field->set_notnull();
  402.   field->store_time(&ltime,t_type);
  403.   return 0;
  404. }
  407. longlong Item_func_from_days::val_int()
  408. {
  409.   longlong value=args[0]->val_int();
  410.   if ((null_value=args[0]->null_value))
  411.     return 0; /* purecov: inspected */
  413.   uint year,month,day;
  414.   get_date_from_daynr((long) value,&year,&month,&day);
  415.   return (longlong) (year*10000L+month*100+day);
  416. }
  419. void Item_func_curdate::fix_length_and_dec()
  420. {
  421.   struct tm tm_tmp,*start;
  422.   time_t query_start=current_thd->query_start();
  423.   decimals=0; max_length=10;
  424.   localtime_r(&query_start,&tm_tmp);
  425.   start=&tm_tmp;
  426.   value=(longlong) ((ulong) ((uint) start->tm_year+1900)*10000L+
  427.     ((uint) start->tm_mon+1)*100+
  428.     (uint) start->tm_mday);
  429.   /* For getdate */
  430.   ltime.year= start->tm_year+1900;
  431.   ltime.month= start->tm_mon+1;
  432.   ltime.day= start->tm_mday;
  433.   ltime.hour= 0;
  434.   ltime.minute= 0;
  435.   ltime.second= 0;
  436.   ltime.second_part=0;
  437.   ltime.neg=0;
  438.   ltime.time_type=TIMESTAMP_DATE;
  439. }
  441. bool Item_func_curdate::get_date(TIME *res,
  442.  bool fuzzy_date __attribute__((unused)))
  443. {
  444.   *res=ltime;
  445.   return 0;
  446. }
  448. void Item_func_curtime::fix_length_and_dec()
  449. {
  450.   struct tm tm_tmp,*start;
  451.   time_t query_start=current_thd->query_start();
  452.   decimals=0; max_length=8;
  453.   localtime_r(&query_start,&tm_tmp);
  454.   start=&tm_tmp;
  455.   value=(longlong) ((ulong) ((uint) start->tm_hour)*10000L+
  456.     (ulong) (((uint) start->tm_min)*100L+
  457.      (uint) start->tm_sec));
  458.   sprintf(buff,"%02d:%02d:%02d",
  459.   (int) start->tm_hour,
  460.   (int) start->tm_min,
  461.   (int) start->tm_sec);
  462.   buff_length=(uint) strlen(buff);
  463. }
  465. void Item_func_now::fix_length_and_dec()
  466. {
  467.   struct tm tm_tmp,*start;
  468.   time_t query_start=current_thd->query_start();
  469.   decimals=0; max_length=19;
  470.   localtime_r(&query_start,&tm_tmp);
  471.   start=&tm_tmp;
  472.   value=((longlong) ((ulong) ((uint) start->tm_year+1900)*10000L+
  473.      (((uint) start->tm_mon+1)*100+
  474.       (uint) start->tm_mday))*(longlong) 1000000L+
  475.  (longlong) ((ulong) ((uint) start->tm_hour)*10000L+
  476.      (ulong) (((uint) start->tm_min)*100L+
  477.     (uint) start->tm_sec)));
  478.   sprintf(buff,"%04d-%02d-%02d %02d:%02d:%02d",
  479.   ((int) (start->tm_year+1900)) % 10000,
  480.   (int) start->tm_mon+1,
  481.   (int) start->tm_mday,
  482.   (int) start->tm_hour,
  483.   (int) start->tm_min,
  484.   (int) start->tm_sec);
  485.   buff_length=(uint) strlen(buff);
  486.   /* For getdate */
  487.   ltime.year= start->tm_year+1900;
  488.   ltime.month= start->tm_mon+1;
  489.   ltime.day= start->tm_mday;
  490.   ltime.hour= start->tm_hour;
  491.   ltime.minute= start->tm_min;
  492.   ltime.second= start->tm_sec;
  493.   ltime.second_part=0;
  494.   ltime.neg=0;
  495.   ltime.time_type=TIMESTAMP_FULL;
  496. }
  498. bool Item_func_now::get_date(TIME *res,
  499.      bool fuzzy_date __attribute__((unused)))
  500. {
  501.   *res=ltime;
  502.   return 0;
  503. }
  506. bool Item_func_now::save_in_field(Field *to)
  507. {
  508.   to->set_notnull();
  509.   to->store_time(&ltime,TIMESTAMP_FULL);
  510.   return 0;
  511. }
  514. String *Item_func_sec_to_time::val_str(String *str)
  515. {
  516.   char buff[23];
  517.   const char *sign="";
  518.   longlong seconds=(longlong) args[0]->val_int();
  519.   if ((null_value=args[0]->null_value))
  520.     return (String*) 0;
  521.   if (seconds < 0)
  522.   {
  523.     seconds= -seconds;
  524.     sign= "-";
  525.   }
  526.   uint sec= (uint) (seconds % 3600);
  527.   sprintf(buff,"%s%02lu:%02u:%02u",sign,(long) (seconds/3600),
  528.   sec/60, sec % 60);
  529.   str->copy(buff,(uint) strlen(buff));
  530.   return str;
  531. }
  534. longlong Item_func_sec_to_time::val_int()
  535. {
  536.   longlong seconds=args[0]->val_int();
  537.   longlong sign=1;
  538.   if ((null_value=args[0]->null_value))
  539.     return 0;
  540.   if (seconds < 0)
  541.   {
  542.     seconds= -seconds;
  543.     sign= -1;
  544.   }
  545.   return sign*((seconds / 3600)*10000+((seconds/60) % 60)*100+ (seconds % 60));
  546. }
  549. void Item_func_date_format::fix_length_and_dec()
  550. {
  551.   decimals=0;
  552.   if (args[1]->type() == STRING_ITEM)
  553.   { // Optimize the normal case
  554.     fixed_length=1;
  555.     max_length=format_length(((Item_string*) args[1])->const_string());
  556.   }
  557.   else
  558.   {
  559.     fixed_length=0;
  560.     max_length=args[1]->max_length*10;
  561.     set_if_smaller(max_length,MAX_BLOB_WIDTH);
  562.   }
  563.   maybe_null=1; // If wrong date
  564. }
  567. uint Item_func_date_format::format_length(const String *format)
  568. {
  569.   uint size=0;
  570.   const char *ptr=format->ptr();
  571.   const char *end=ptr+format->length();
  573.   for (; ptr != end ; ptr++)
  574.   {
  575.     if (*ptr != '%' || ptr == end-1)
  576.       size++;
  577.     else
  578.     {
  579.       switch(*++ptr) {
  580.       case 'M': /* month, textual */
  581.       case 'W': /* day (of the week), textual */
  582. size += 9;
  583. break;
  584.       case 'D': /* day (of the month), numeric plus english suffix */
  585.       case 'Y': /* year, numeric, 4 digits */
  586.       case 'x': /* Year, used with 'v' */
  587.       case 'X': /* Year, used with 'v, where week starts with Monday' */
  588. size += 4;
  589. break;
  590.       case 'a': /* locale's abbreviated weekday name (Sun..Sat) */
  591.       case 'b': /* locale's abbreviated month name (Jan.Dec) */
  592.       case 'j': /* day of year (001..366) */
  593. size += 3;
  594. break;
  595.       case 'U': /* week (00..52) */
  596.       case 'u': /* week (00..52), where week starts with Monday */
  597.       case 'V': /* week 1..53 used with 'x' */
  598.       case 'v': /* week 1..53 used with 'x', where week starts with Monday */
  599.       case 'H': /* hour (00..23) */
  600.       case 'y': /* year, numeric, 2 digits */
  601.       case 'm': /* month, numeric */
  602.       case 'd': /* day (of the month), numeric */
  603.       case 'h': /* hour (01..12) */
  604.       case 'I': /* --||-- */
  605.       case 'i': /* minutes, numeric */
  606.       case 'k': /* hour ( 0..23) */
  607.       case 'l': /* hour ( 1..12) */
  608.       case 'p': /* locale's AM or PM */
  609.       case 'S': /* second (00..61) */
  610.       case 's': /* seconds, numeric */
  611.       case 'c': /* month (0..12) */
  612.       case 'e': /* day (0..31) */
  613. size += 2;
  614. break;
  615.       case 'r': /* time, 12-hour (hh:mm:ss [AP]M) */
  616. size += 11;
  617. break;
  618.       case 'T': /* time, 24-hour (hh:mm:ss) */
  619. size += 8;
  620. break;
  621.       case 'w': /* day (of the week), numeric */
  622.       case '%':
  623.       default:
  624. size++;
  625. break;
  626.       }
  627.     }
  628.   }
  629.   return size;
  630. }
  633. String *Item_func_date_format::val_str(String *str)
  634. {
  635.   String *format;
  636.   TIME l_time;
  637.   char intbuff[15];
  638.   uint size,weekday;
  640.   if (!date_or_time)
  641.   {
  642.     if (get_arg0_date(&l_time,1))
  643.       return 0;
  644.   }
  645.   else
  646.   {
  647.     String *res;
  648.     if (!(res=args[0]->val_str(str)))
  649.     {
  650.       null_value=1;
  651.       return 0;
  652.     }
  653.     if (str_to_time(res->ptr(),res->length(),&l_time))
  654.     {
  655.       null_value=1;
  656.       return 0;
  657.     }
  658.     l_time.year=l_time.month=l_time.day=0;
  659.     null_value=0;
  660.   }
  662.   if (!(format = args[1]->val_str(str)) || !format->length())
  663.   {
  664.     null_value=1;
  665.     return 0;
  666.   }
  668.   if (fixed_length)
  669.     size=max_length;
  670.   else
  671.     size=format_length(format);
  672.   if (format == str)
  673.     str=&str_value; // Save result here
  674.   if (str->alloc(size))
  675.   {
  676.     null_value=1;
  677.     return 0;
  678.   }
  679.   str->length(0);
  681.   /* Create the result string */
  682.   const char *ptr=format->ptr();
  683.   const char *end=ptr+format->length();
  684.   for ( ; ptr != end ; ptr++)
  685.   {
  686.     if (*ptr != '%' || ptr+1 == end)
  687.       str->append(*ptr);
  688.     else
  689.     {
  690.       switch (*++ptr) {
  691.       case 'M':
  692. if(!l_time.month)
  693. {
  694.   null_value=1;
  695.   return 0;
  696. }
  697. str->append(month_names[l_time.month-1]);
  698. break;
  699.       case 'b':
  700. if(!l_time.month)
  701. {
  702.   null_value=1;
  703.   return 0;
  704. }
  705. str->append(month_names[l_time.month-1].ptr(),3);
  706. break;
  707.       case 'W':
  708. if(date_or_time)
  709. {
  710.   null_value=1;
  711.   return 0;
  712. }
  713. weekday=calc_weekday(calc_daynr(l_time.year,l_time.month,l_time.day),0);
  714. str->append(day_names[weekday]);
  715. break;
  716.       case 'a':
  717. if(date_or_time)
  718. {
  719.   null_value=1;
  720.   return 0;
  721. }
  722. weekday=calc_weekday(calc_daynr(l_time.year,l_time.month,l_time.day),0);
  723. str->append(day_names[weekday].ptr(),3);
  724. break;
  725.       case 'D':
  726. if(date_or_time)
  727. {
  728.   null_value=1;
  729.   return 0;
  730. }
  731. sprintf(intbuff,"%d",l_time.day);
  732. str->append(intbuff);
  733. if (l_time.day >= 10 &&  l_time.day <= 19)
  734.   str->append("th");
  735. else
  736. {
  737.   switch (l_time.day %10)
  738.   {
  739.   case 1:
  740.     str->append("st");
  741.     break;
  742.   case 2:
  743.     str->append("nd");
  744.     break;
  745.   case 3:
  746.     str->append("rd");
  747.     break;
  748.   default:
  749.     str->append("th");
  750.     break;
  751.   }
  752. }
  753. break;
  754.       case 'Y':
  755. sprintf(intbuff,"%04d",l_time.year);
  756. str->append(intbuff);
  757. break;
  758.       case 'y':
  759. sprintf(intbuff,"%02d",l_time.year%100);
  760. str->append(intbuff);
  761. break;
  762.       case 'm':
  763. sprintf(intbuff,"%02d",l_time.month);
  764. str->append(intbuff);
  765. break;
  766.       case 'c':
  767. sprintf(intbuff,"%d",l_time.month);
  768. str->append(intbuff);
  769. break;
  770.       case 'd':
  771. sprintf(intbuff,"%02d",l_time.day);
  772. str->append(intbuff);
  773. break;
  774.       case 'e':
  775. sprintf(intbuff,"%d",l_time.day);
  776. str->append(intbuff);
  777. break;
  778.       case 'H':
  779. sprintf(intbuff,"%02d",l_time.hour);
  780. str->append(intbuff);
  781. break;
  782.       case 'h':
  783.       case 'I':
  784. sprintf(intbuff,"%02d", (l_time.hour+11)%12+1);
  785. str->append(intbuff);
  786. break;
  787.       case 'i': /* minutes */
  788. sprintf(intbuff,"%02d",l_time.minute);
  789. str->append(intbuff);
  790. break;
  791.       case 'j':
  792. if(date_or_time)
  793. {
  794.   null_value=1;
  795.   return 0;
  796. }
  797. sprintf(intbuff,"%03d",
  798. (int) (calc_daynr(l_time.year,l_time.month,l_time.day) -
  799.        calc_daynr(l_time.year,1,1)) + 1);
  800. str->append(intbuff);
  801. break;
  802.       case 'k':
  803. sprintf(intbuff,"%d",l_time.hour);
  804. str->append(intbuff);
  805. break;
  806.       case 'l':
  807. sprintf(intbuff,"%d", (l_time.hour+11)%12+1);
  808. str->append(intbuff);
  809. break;
  810.       case 'p':
  811. str->append(l_time.hour < 12 ? "AM" : "PM");
  812. break;
  813.       case 'r':
  814. sprintf(intbuff,(l_time.hour < 12) ? "%02d:%02d:%02d AM" :
  815. "%02d:%02d:%02d PM",(l_time.hour+11)%12+1,l_time.minute,
  816. l_time.second);
  817. str->append(intbuff);
  818. break;
  819.       case 'S':
  820.       case 's':
  821. sprintf(intbuff,"%02d",l_time.second);
  822. str->append(intbuff);
  823. break;
  824.       case 'T':
  825. sprintf(intbuff,"%02d:%02d:%02d",l_time.hour,l_time.minute,l_time.second);
  826. str->append(intbuff);
  827. break;
  828.       case 'U':
  829.       case 'u':
  830.       {
  831. uint year;
  832. sprintf(intbuff,"%02d",calc_week(&l_time, 0, (*ptr) == 'U', &year));
  833. str->append(intbuff);
  834.       }
  835.       break;
  836.       case 'v':
  837.       case 'V':
  838.       {
  839. uint year;
  840. sprintf(intbuff,"%02d",calc_week(&l_time, 1, (*ptr) == 'V', &year));
  841. str->append(intbuff);
  842.       }
  843.       break;
  844.       case 'x':
  845.       case 'X':
  846.       {
  847. uint year;
  848. (void) calc_week(&l_time, 1, (*ptr) == 'X', &year);
  849. sprintf(intbuff,"%04d",year);
  850. str->append(intbuff);
  851.       }
  852.       break;
  853.       case 'w':
  854. weekday=calc_weekday(calc_daynr(l_time.year,l_time.month,l_time.day),1);
  855. sprintf(intbuff,"%01d",weekday);
  856. str->append(intbuff);
  857. break;
  858.       default:
  859. str->append(*ptr);
  860. break;
  861.       }
  862.     }
  863.   }
  864.   return str;
  865. }
  868. String *Item_func_from_unixtime::val_str(String *str)
  869. {
  870.   struct tm tm_tmp,*start;
  871.   time_t tmp=(time_t) args[0]->val_int();
  872.   if ((null_value=args[0]->null_value))
  873.     return 0;
  874.   localtime_r(&tmp,&tm_tmp);
  875.   start=&tm_tmp;
  876.   if (str->alloc(20))
  877.     return str; /* purecov: inspected */
  878.   sprintf((char*) str->ptr(),"%04d-%02d-%02d %02d:%02d:%02d",
  879.   (int) start->tm_year+1900,
  880.   (int) start->tm_mon+1,
  881.   (int) start->tm_mday,
  882.   (int) start->tm_hour,
  883.   (int) start->tm_min,
  884.   (int) start->tm_sec);
  885.   str->length(19);
  886.   return str;
  887. }
  890. longlong Item_func_from_unixtime::val_int()
  891. {
  892.   time_t tmp=(time_t) (ulong) args[0]->val_int();
  893.   if ((null_value=args[0]->null_value))
  894.     return 0;
  895.   struct tm tm_tmp,*start;
  896.   localtime_r(&tmp,&tm_tmp);
  897.   start= &tm_tmp;
  898.   return ((longlong) ((ulong) ((uint) start->tm_year+1900)*10000L+
  899.       (((uint) start->tm_mon+1)*100+
  900.        (uint) start->tm_mday))*LL(1000000)+
  901.   (longlong) ((ulong) ((uint) start->tm_hour)*10000L+
  902.       (ulong) (((uint) start->tm_min)*100L+
  903.        (uint) start->tm_sec)));
  904. }
  906. bool Item_func_from_unixtime::get_date(TIME *ltime,
  907.        bool fuzzy_date __attribute__((unused)))
  908. {
  909.   time_t tmp=(time_t) (ulong) args[0]->val_int();
  910.   if ((null_value=args[0]->null_value))
  911.     return 1;
  912.   struct tm tm_tmp,*start;
  913.   localtime_r(&tmp,&tm_tmp);
  914.   start= &tm_tmp;
  915.   ltime->year= start->tm_year+1900;
  916.   ltime->month= start->tm_mon+1;
  917.   ltime->day= start->tm_mday;
  918.   ltime->hour= start->tm_hour;
  919.   ltime->minute=start->tm_min;
  920.   ltime->second=start->tm_sec;
  921.   ltime->second_part=0;
  922.   ltime->neg=0;
  923.   return 0;
  924. }
  926.   /* Here arg[1] is a Item_interval object */
  928. bool Item_date_add_interval::get_date(TIME *ltime, bool fuzzy_date)
  929. {
  930.   long period,sign;
  931.   INTERVAL interval;
  933.   if (args[0]->get_date(ltime,0) ||
  934.       get_interval_value(args[1],int_type,&value,&interval))
  935.     goto null_date;
  936.   sign= (interval.neg ? -1 : 1);
  937.   if (date_sub_interval)
  938.     sign = -sign;
  940.   null_value=0;
  941.   switch (int_type) {
  942.   case INTERVAL_SECOND:
  943.   case INTERVAL_MINUTE:
  944.   case INTERVAL_HOUR:
  945.   case INTERVAL_MINUTE_SECOND:
  946.   case INTERVAL_HOUR_SECOND:
  947.   case INTERVAL_HOUR_MINUTE:
  948.   case INTERVAL_DAY_SECOND:
  949.   case INTERVAL_DAY_MINUTE:
  950.   case INTERVAL_DAY_HOUR:
  951.     long sec,days,daynr;
  952.     ltime->time_type=TIMESTAMP_FULL; // Return full date
  954.     sec=((ltime->day-1)*3600*24L+ltime->hour*3600+ltime->minute*60+
  955.  ltime->second +
  956.  sign*(interval.day*3600*24L +
  957.        interval.hour*3600+interval.minute*60+interval.second));
  958.     days=sec/(3600*24L); sec=sec-days*3600*24L;
  959.     if (sec < 0)
  960.     {
  961.       days--;
  962.       sec+=3600*24L;
  963.     }
  964.     ltime->second=sec % 60;
  965.     ltime->minute=sec/60 % 60;
  966.     ltime->hour=sec/3600;
  967.     daynr= calc_daynr(ltime->year,ltime->month,1) + days;
  968.     get_date_from_daynr(daynr,&ltime->year,&ltime->month,&ltime->day);
  969.     if (daynr < 0 || daynr >= 3652424) // Day number from year 0 to 9999-12-31
  970.       goto null_date;
  971.     break;
  972.   case INTERVAL_DAY:
  973.     period= calc_daynr(ltime->year,ltime->month,ltime->day) +
  974.       sign*interval.day;
  975.     if (period < 0 || period >= 3652424) // Daynumber from year 0 to 9999-12-31
  976.       goto null_date;
  977.     get_date_from_daynr((long) period,&ltime->year,&ltime->month,&ltime->day);
  978.     break;
  979.   case INTERVAL_YEAR:
  980.     ltime->year += sign*interval.year;
  981.     if ((int) ltime->year < 0 || ltime->year >= 10000L)
  982.       goto null_date;
  983.     if (ltime->month == 2 && ltime->day == 29 &&
  984. calc_days_in_year(ltime->year) != 366)
  985.       ltime->day=28; // Was leap-year
  986.     break;
  987.   case INTERVAL_YEAR_MONTH:
  988.   case INTERVAL_MONTH:
  989.     period= (ltime->year*12 + sign*interval.year*12 +
  990.      ltime->month-1 + sign*interval.month);
  991.     if (period < 0 || period >= 120000L)
  992.       goto null_date;
  993.     ltime->year= (uint) (period / 12);
  994.     ltime->month= (uint) (period % 12L)+1;
  995.     /* Adjust day if the new month doesn't have enough days */
  996.     if (ltime->day > days_in_month[ltime->month-1])
  997.     {
  998.       ltime->day = days_in_month[ltime->month-1];
  999.       if (ltime->month == 2 && calc_days_in_year(ltime->year) == 366)
  1000. ltime->day++; // Leap-year
  1001.     }
  1002.     break;
  1003.   default:
  1004.     goto null_date;
  1005.   }
  1006.   return 0; // Ok
  1008.  null_date:
  1009.   return (null_value=1);
  1010. }
  1013. String *Item_date_add_interval::val_str(String *str)
  1014. {
  1015.   TIME ltime;
  1017.   if (Item_date_add_interval::get_date(&ltime,0))
  1018.     return 0;
  1019.   if (ltime.time_type == TIMESTAMP_DATE)
  1020.   {
  1021.     if (str->alloc(11))
  1022.       goto null_date;
  1023.     sprintf((char*) str->ptr(),"%04d-%02d-%02d",
  1024.     ltime.year,ltime.month,ltime.day);
  1025.     str->length(10);
  1026.   }
  1027.   else
  1028.   {
  1029.     if (str->alloc(20))
  1030.       goto null_date;
  1031.     sprintf((char*) str->ptr(),"%04d-%02d-%02d %02d:%02d:%02d",
  1032.     ltime.year,ltime.month,ltime.day,
  1033.     ltime.hour,ltime.minute,ltime.second);
  1034.     str->length(19);
  1035.   }
  1036.   return str;
  1038.  null_date:
  1039.   null_value=1;
  1040.   return 0;
  1041. }
  1043. longlong Item_date_add_interval::val_int()
  1044. {
  1045.   TIME ltime;
  1046.   if (Item_date_add_interval::get_date(&ltime,0))
  1047.     return (longlong) 0;
  1048.   return ((longlong) (((ulong) ltime.year)*10000L+
  1049.       (((uint) ltime.month)*100+
  1050.        (uint) ltime.day))*(longlong) 1000000L+
  1051.   (longlong) ((ulong) ((uint) ltime.hour)*10000L+
  1052.       (ulong) (((uint)ltime.minute)*100L+
  1053.        (uint) ltime.second)));
  1054. }
  1056. void Item_extract::fix_length_and_dec()
  1057. {
  1058.   value.alloc(32); // alloc buffer
  1060.   maybe_null=1; // If wrong date
  1061.   switch (int_type) {
  1062.   case INTERVAL_YEAR: max_length=4; date_value=1; break;
  1063.   case INTERVAL_YEAR_MONTH: max_length=6; date_value=1; break;
  1064.   case INTERVAL_MONTH: max_length=2; date_value=1; break;
  1065.   case INTERVAL_DAY: max_length=2; date_value=1; break;
  1066.   case INTERVAL_DAY_HOUR: max_length=9; date_value=0; break;
  1067.   case INTERVAL_DAY_MINUTE: max_length=11; date_value=0; break;
  1068.   case INTERVAL_DAY_SECOND: max_length=13; date_value=0; break;
  1069.   case INTERVAL_HOUR: max_length=2; date_value=0; break;
  1070.   case INTERVAL_HOUR_MINUTE: max_length=4; date_value=0; break;
  1071.   case INTERVAL_HOUR_SECOND: max_length=6; date_value=0; break;
  1072.   case INTERVAL_MINUTE: max_length=2; date_value=0; break;
  1073.   case INTERVAL_MINUTE_SECOND: max_length=4; date_value=0; break;
  1074.   case INTERVAL_SECOND: max_length=2; date_value=0; break;
  1075.   }
  1076. }
  1079. longlong Item_extract::val_int()
  1080. {
  1081.   TIME ltime;
  1082.   long neg;
  1083.   if (date_value)
  1084.   {
  1085.     if (get_arg0_date(&ltime,1))
  1086.       return 0;
  1087.     neg=1;
  1088.   }
  1089.   else
  1090.   {
  1091.     String *res= args[0]->val_str(&value);
  1092.     if (!res || str_to_time(res->ptr(),res->length(),&ltime))
  1093.     {
  1094.       null_value=1;
  1095.       return 0;
  1096.     }
  1097.     neg= ltime.neg ? -1 : 1;
  1098.     null_value=0;
  1099.   }
  1101.   switch (int_type) {
  1102.   case INTERVAL_YEAR: return ltime.year;
  1103.   case INTERVAL_YEAR_MONTH: return ltime.year*100L+ltime.month;
  1104.   case INTERVAL_MONTH: return ltime.month;
  1105.   case INTERVAL_DAY: return ltime.day;
  1106.   case INTERVAL_DAY_HOUR: return (long) (ltime.day*100L+ltime.hour)*neg;
  1107.   case INTERVAL_DAY_MINUTE: return (long) (ltime.day*10000L+
  1108.        ltime.hour*100L+
  1109.        ltime.minute)*neg;
  1110.   case INTERVAL_DAY_SECOND:  return ((longlong) ltime.day*1000000L+
  1111.  (longlong) (ltime.hour*10000L+
  1112.      ltime.minute*100+
  1113.      ltime.second))*neg;
  1114.   case INTERVAL_HOUR: return (long) ltime.hour*neg;
  1115.   case INTERVAL_HOUR_MINUTE: return (long) (ltime.hour*100+ltime.minute)*neg;
  1116.   case INTERVAL_HOUR_SECOND: return (long) (ltime.hour*10000+ltime.minute*100+
  1117.        ltime.second)*neg;
  1118.   case INTERVAL_MINUTE: return (long) ltime.minute*neg;
  1119.   case INTERVAL_MINUTE_SECOND: return (long) (ltime.minute*100+ltime.second)*neg;
  1120.   case INTERVAL_SECOND: return (long) ltime.second*neg;
  1121.   }
  1122.   return 0; // Impossible
  1123. }