home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / time.cpp < prev    next >
C/C++ Source or Header  |  2000-11-16  |  18KB  |  681 lines
  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 */
  16.  
  17.  
  18. /* Functions to handle date and time */
  19.  
  20. #include "mysql_priv.h"
  21. #include <m_ctype.h>
  22.  
  23. static ulong const days_at_timestart=719528;    /* daynr at 1970.01.01 */
  24. uchar *days_in_month= (uchar*) "\037\034\037\036\037\036\037\037\036\037\036\037";
  25.  
  26.  
  27.     /* Init some variabels neaded when using my_local_time */
  28.     /* Currently only my_time_zone is inited */
  29.  
  30. static long my_time_zone=0;
  31. pthread_mutex_t LOCK_timezone;
  32.  
  33. void init_time(void)
  34. {
  35.   time_t seconds;
  36.   struct tm *l_time,tm_tmp;;
  37.   TIME my_time;
  38.  
  39.   seconds= (time_t) time((time_t*) 0);
  40.   localtime_r(&seconds,&tm_tmp);
  41.   l_time= &tm_tmp;
  42.   my_time_zone=0;
  43.   my_time.year=        (uint) l_time->tm_year+1900;
  44.   my_time.month=    (uint) l_time->tm_mon+1;
  45.   my_time.day=        (uint) l_time->tm_mday;
  46.   my_time.hour=        (uint) l_time->tm_hour;
  47.   my_time.minute=    (uint) l_time->tm_min;
  48.   my_time.second=        (uint) l_time->tm_sec;
  49.   VOID(my_gmt_sec(&my_time));        /* Init my_time_zone */
  50. }
  51.  
  52. /*
  53.   Convert current time to sec. since 1970.01.01 
  54.   This code handles also day light saving time.
  55.   The idea is to cache the time zone (including daylight saving time)
  56.   for the next call to make things faster.
  57.   
  58. */
  59.  
  60. long my_gmt_sec(TIME *t)
  61. {
  62.   uint loop;
  63.   time_t tmp;
  64.   struct tm *l_time,tm_tmp;
  65.   long diff;
  66.  
  67.   if (t->hour >= 24)
  68.   {                    /* Fix for time-loop */
  69.     t->day+=t->hour/24;
  70.     t->hour%=24;
  71.   }
  72.   pthread_mutex_lock(&LOCK_timezone);
  73.   tmp=(time_t) ((calc_daynr((uint) t->year,(uint) t->month,(uint) t->day) -
  74.          (long) days_at_timestart)*86400L + (long) t->hour*3600L +
  75.         (long) (t->minute*60 + t->second)) + (time_t) my_time_zone;
  76.   localtime_r(&tmp,&tm_tmp);
  77.   l_time=&tm_tmp;
  78.   for (loop=0;
  79.        loop < 3 &&
  80.      (t->hour != (uint) l_time->tm_hour ||
  81.       t->minute != (uint) l_time->tm_min);
  82.        loop++)
  83.   {                    /* One check should be enough ? */
  84.     /* Get difference in days */
  85.     int days= t->day - l_time->tm_mday;
  86.     if (days < -1)
  87.       days= 1;                    // Month has wrapped
  88.     else if (days > 1)
  89.       days= -1;
  90.     diff=(3600L*(long) (days*24+((int) t->hour - (int) l_time->tm_hour)) +
  91.       (long) (60*((int) t->minute - (int) l_time->tm_min)));
  92.     my_time_zone+=diff;
  93.     tmp+=(time_t) diff;
  94.     localtime_r(&tmp,&tm_tmp);
  95.     l_time=&tm_tmp;
  96.   }
  97.   /* Fix that if we are in the not existing daylight saving time hour
  98.      we move the start of the next real hour */
  99.   if (loop == 3 && t->hour != (uint) l_time->tm_hour)
  100.   {
  101.     int days= t->day - l_time->tm_mday;
  102.     if (days < -1)
  103.       days=1;                    // Month has wrapped
  104.     else if (days > 1)
  105.       days= -1;
  106.     diff=(3600L*(long) (days*24+((int) t->hour - (int) l_time->tm_hour))+
  107.       (long) (60*((int) t->minute - (int) l_time->tm_min)));
  108.     if (diff == 3600)
  109.       tmp+=3600 - t->minute*60 - t->second;    // Move to next hour
  110.     else if (diff == -3600)
  111.       tmp-=t->minute*60 + t->second;        // Move to next hour
  112.   }
  113.   if ((my_time_zone >=0 ? my_time_zone: -my_time_zone) > 3600L*12)
  114.     my_time_zone=0;            /* Wrong date */
  115.   pthread_mutex_unlock(&LOCK_timezone);
  116.   return (long) tmp;
  117. } /* my_gmt_sec */
  118.  
  119.  
  120.     /* Some functions to calculate dates */
  121.  
  122.     /* Calculate nr of day since year 0 in new date-system (from 1615) */
  123.  
  124. long calc_daynr(uint year,uint month,uint day)
  125. {
  126.   long delsum;
  127.   int temp;
  128.   DBUG_ENTER("calc_daynr");
  129.  
  130.   if (year == 0 && month == 0 && day == 0)
  131.     DBUG_RETURN(0);                /* Skipp errors */
  132.   if (year < 200)
  133.   {
  134.     if ((year=year+1900) < 1900+YY_PART_YEAR)
  135.       year+=100;
  136.   }
  137.   delsum= (long) (365L * year+ 31*(month-1) +day);
  138.   if (month <= 2)
  139.       year--;
  140.   else
  141.     delsum-= (long) (month*4+23)/10;
  142.   temp=(int) ((year/100+1)*3)/4;
  143.   DBUG_PRINT("exit",("year: %d  month: %d  day: %d -> daynr: %ld",
  144.              year+(month <= 2),month,day,delsum+year/4-temp));
  145.   DBUG_RETURN(delsum+(int) year/4-temp);
  146. } /* calc_daynr */
  147.  
  148.  
  149.     /* Calc weekday from daynr */
  150.     /* Returns 0 for monday, 1 for tuesday .... */
  151.  
  152. int calc_weekday(long daynr,bool sunday_first_day_of_week)
  153. {
  154.   DBUG_ENTER("calc_weekday");
  155.   DBUG_RETURN ((int) ((daynr + 5L + (sunday_first_day_of_week ? 1L : 0L)) % 7));
  156. }
  157.  
  158.     /* Calc days in one year. works with 0 <= year <= 99 */
  159.  
  160. uint calc_days_in_year(uint year)
  161. {
  162.   return (year & 3) == 0 && (year%100 || (year%400 == 0 && year)) ?
  163.     366 : 365;
  164. }
  165.  
  166. /* Calculate week.  If 'with_year' is not set, then return a week 0-53, where
  167.    0 means that it's the last week of the previous year.
  168.    If 'with_year' is set then the week will always be in the range 1-53 and
  169.    the year out parameter will contain the year for the week */
  170.  
  171. uint calc_week(TIME *l_time, bool with_year, bool sunday_first_day_of_week,
  172.            uint *year)
  173. {
  174.   uint days;
  175.   ulong daynr=calc_daynr(l_time->year,l_time->month,l_time->day);
  176.   ulong first_daynr=calc_daynr(l_time->year,1,1);
  177.   uint weekday=calc_weekday(first_daynr,sunday_first_day_of_week);
  178.   *year=l_time->year;
  179.   if (l_time->month == 1 && weekday >= 4 && l_time->day <= 7-weekday)
  180.   {
  181.     /* Last week of the previous year */
  182.     if (!with_year)
  183.       return 0;
  184.     with_year=0;                // Don't check the week again
  185.     (*year)--;
  186.     first_daynr-= (days=calc_days_in_year(*year));
  187.     weekday= (weekday + 53*7- days) % 7;
  188.   }
  189.   if (weekday >= 4)
  190.     days= daynr - (first_daynr+ (7-weekday));
  191.   else
  192.     days= daynr - (first_daynr - weekday);
  193.   if (with_year && days >= 52*7)
  194.   {
  195.     /* Check if we are on the first week of the next year (or week 53) */
  196.     weekday= (weekday + calc_days_in_year(*year)) % 7;
  197.     if (weekday < 4)
  198.     {                    // We are at first week on next year
  199.       (*year)++;
  200.       return 1;
  201.     }
  202.   }
  203.   return days/7+1;
  204. }
  205.  
  206.     /* Change a daynr to year, month and day */
  207.     /* Daynr 0 is returned as date 00.00.00 */
  208.  
  209. void get_date_from_daynr(long daynr,uint *ret_year,uint *ret_month,
  210.              uint *ret_day)
  211. {
  212.   uint year,temp,leap_day,day_of_year,days_in_year;
  213.   uchar *month_pos;
  214.   DBUG_ENTER("get_date_from_daynr");
  215.  
  216.   if (daynr <= 365L || daynr >= 3652500)
  217.   {                        /* Fix if wrong daynr */
  218.     *ret_year= *ret_month = *ret_day =0;
  219.   }
  220.   else
  221.   {
  222.     year= (uint) (daynr*100 / 36525L);
  223.     temp=(((year-1)/100+1)*3)/4;
  224.     day_of_year=(uint) (daynr - (long) year * 365L) - (year-1)/4 +temp;
  225.     while (day_of_year > (days_in_year= calc_days_in_year(year)))
  226.     {
  227.       day_of_year-=days_in_year;
  228.       (year)++;
  229.     }
  230.     leap_day=0;
  231.     if (days_in_year == 366)
  232.     {
  233.       if (day_of_year > 31+28)
  234.       {
  235.     day_of_year--;
  236.     if (day_of_year == 31+28)
  237.       leap_day=1;        /* Handle leapyears leapday */
  238.       }
  239.     }
  240.     *ret_month=1;
  241.     for (month_pos= days_in_month ;
  242.      day_of_year > (uint) *month_pos ;
  243.      day_of_year-= *(month_pos++), (*ret_month)++)
  244.       ;
  245.     *ret_year=year;
  246.     *ret_day=day_of_year+leap_day;
  247.   }
  248.   DBUG_VOID_RETURN;
  249. }
  250.  
  251. /*    find date from string and put it in vektor
  252.     Input: pos = "YYMMDD" OR "YYYYMMDD" in any order or
  253.     "xxxxx YYxxxMMxxxDD xxxx" where xxx is anything exept
  254.     a number. Month or day mustn't exeed 2 digits, year may be 4 digits.
  255. */
  256.  
  257.  
  258. #ifdef NOT_NEEDED
  259.  
  260. void find_date(string pos,uint *vek,uint flag)
  261. {
  262.   uint length,value;
  263.   string start;
  264.   DBUG_ENTER("find_date");
  265.   DBUG_PRINT("enter",("pos: '%s'  flag: %d",pos,flag));
  266.  
  267.   bzero((char*) vek,sizeof(int)*4);
  268.   while (*pos && !isdigit(*pos))
  269.     pos++;
  270.   length=(uint) strlen(pos);
  271.   for (uint i=0 ; i< 3; i++)
  272.   {
  273.     start=pos; value=0;
  274.     while (isdigit(pos[0]) &&
  275.        ((pos-start) < 2 || ((pos-start) < 4 && length >= 8 &&
  276.                 !(flag & 3))))
  277.     {
  278.       value=value*10 + (uint) (uchar) (*pos - '0');
  279.       pos++;
  280.     }
  281.     vek[flag & 3]=value; flag>>=2;
  282.     while (*pos && (ispunct(*pos) || isspace(*pos)))
  283.       pos++;
  284.   }
  285.   DBUG_PRINT("exit",("year: %d  month: %d  day: %d",vek[0],vek[1],vek[2]));
  286.   DBUG_VOID_RETURN;
  287. } /* find_date */
  288.  
  289.  
  290.     /* Outputs YYMMDD if input year < 100 or YYYYMMDD else */
  291.  
  292. static long calc_daynr_from_week(uint year,uint week,uint day)
  293. {
  294.   long daynr;
  295.   int weekday;
  296.  
  297.   daynr=calc_daynr(year,1,1);
  298.   if ((weekday= calc_weekday(daynr,0)) >= 3)
  299.     daynr+= (7-weekday);
  300.   else
  301.     daynr-=weekday;
  302.  
  303.   return (daynr+week*7+day-8);
  304. }
  305.  
  306. void convert_week_to_date(string date,uint flag,uint *res_length)
  307. {
  308.   string format;
  309.   uint year,vek[4];
  310.  
  311.   find_date(date,vek,(uint) (1*4+2*16));        /* YY-WW-DD */
  312.   year=vek[0];
  313.  
  314.   get_date_from_daynr(calc_daynr_from_week(vek[0],vek[1],vek[2]),
  315.               &vek[0],&vek[1],&vek[2]);
  316.   *res_length=8;
  317.   format="%04d%02d%02d";
  318.   if (year < 100)
  319.   {
  320.     vek[0]= vek[0]%100;
  321.     *res_length=6;
  322.     format="%02d%02d%02d";
  323.   }
  324.   sprintf(date,format,vek[flag & 3],vek[(flag >> 2) & 3],
  325.       vek[(flag >> 4) & 3]);
  326.   return;
  327. }
  328.  
  329.     /* returns YYWWDD or YYYYWWDD according to input year */
  330.     /* flag only reflects format of input date */
  331.  
  332. void convert_date_to_week(string date,uint flag,uint *res_length)
  333. {
  334.   uint vek[4],weekday,days,year,week,day;
  335.   long daynr,first_daynr;
  336.   char buff[256],*format;
  337.  
  338.   if (! date[0])
  339.   {
  340.     get_date(buff,0,0L);            /* Use current date */
  341.     find_date(buff+2,vek,(uint) (1*4+2*16));    /* YY-MM-DD */
  342.   }
  343.   else
  344.     find_date(date,vek,flag);
  345.  
  346.   year= vek[0];
  347.   daynr=      calc_daynr(year,vek[1],vek[2]);
  348.   first_daynr=calc_daynr(year,1,1);
  349.  
  350.     /* Caculate year and first daynr of year */
  351.   if (vek[1] == 1 && (weekday=calc_weekday(first_daynr,0)) >= 3 &&
  352.       vek[2] <= 7-weekday)
  353.   {
  354.     if (!year--)
  355.       year=99;
  356.     first_daynr=first_daynr-calc_days_in_year(year);
  357.   }
  358.   else if (vek[1] == 12 &&
  359.        (weekday=calc_weekday(first_daynr+calc_days_in_year(year)),0) < 3 &&
  360.        vek[2] > 31-weekday)
  361.   {
  362.     first_daynr=first_daynr+calc_days_in_year(year);
  363.     if (year++ == 99)
  364.       year=0;
  365.   }
  366.  
  367.     /* Calulate daynr of first day of week 1 */
  368.   if ((weekday= calc_weekday(first_daynr,0)) >= 3)
  369.     first_daynr+= (7-weekday);
  370.   else
  371.     first_daynr-=weekday;
  372.  
  373.   days=(int) (daynr-first_daynr);
  374.   week=days/7+1 ; day=calc_weekday(daynr,0)+1;
  375.  
  376.   *res_length=8;
  377.   format="%04d%02d%02d";
  378.   if (year < 100)
  379.   {
  380.     *res_length=6;
  381.     format="%02d%02d%02d";
  382.   }
  383.   sprintf(date,format,year,week,day);
  384.   return;
  385. }
  386.  
  387. #endif
  388.  
  389.     /* Functions to handle periods */
  390.  
  391. ulong convert_period_to_month(ulong period)
  392. {
  393.   ulong a,b;
  394.   if (period == 0)
  395.     return 0L;
  396.   if ((a=period/100) < YY_PART_YEAR)
  397.     a+=2000;
  398.   else if (a < 100)
  399.     a+=1900;
  400.   b=period%100;
  401.   return a*12+b-1;
  402. }
  403.  
  404. ulong convert_month_to_period(ulong month)
  405. {
  406.   ulong year;
  407.   if (month == 0L)
  408.     return 0L;
  409.   if ((year=month/12) < 100)
  410.   {
  411.     year+=(year < YY_PART_YEAR) ? 2000 : 1900;
  412.   }
  413.   return year*100+month%12+1;
  414. }
  415.  
  416.  
  417. /*****************************************************************************
  418. ** convert a timestamp string to a TIME value.
  419. ** At least the following formats are recogniced (based on number of digits)
  420. ** YYMMDD, YYYYMMDD, YYMMDDHHMMSS, YYYYMMDDHHMMSS
  421. ** YY-MM-DD, YYYY-MM-DD, YY-MM-DD HH.MM.SS
  422. ** Returns the type of string
  423. *****************************************************************************/
  424.  
  425. timestamp_type
  426. str_to_TIME(const char *str, uint length, TIME *l_time,bool fuzzy_date)
  427. {
  428.   uint field_length,year_length,digits,i,number_of_fields,date[7];
  429.   bool date_used=0;
  430.   const char *pos;
  431.   const char *end=str+length;
  432.   DBUG_ENTER("str_to_TIME");
  433.   DBUG_PRINT("enter",("str: %.*s",length,str));
  434.  
  435.   for (; !isdigit(*str) && str != end ; str++) ; // Skipp garbage
  436.   if (str == end)
  437.     DBUG_RETURN(TIMESTAMP_NONE);
  438.   /*
  439.   ** calculate first number of digits.
  440.   ** If length= 8 or >= 14 then year is of format YYYY.
  441.      (YYYY-MM-DD,  YYYYMMDD, YYYYYMMDDHHMMSS)
  442.   */
  443.   for (pos=str; pos != end && isdigit(*pos) ; pos++) ;
  444.   digits= (uint) (pos-str);
  445.   year_length= (digits == 4 || digits == 8 || digits >= 14) ? 4 : 2;
  446.   field_length=year_length-1;
  447.   for (i=0 ; i < 6 && str != end && isdigit(*str) ; i++)
  448.   {
  449.     uint tmp_value=(uint) (uchar) (*str++ - '0');
  450.     while (str != end && isdigit(str[0]) && field_length--)
  451.     {
  452.       tmp_value=tmp_value*10 + (uint) (uchar) (*str - '0');
  453.       str++;
  454.     }
  455.     if ((date[i]=tmp_value))
  456.       date_used=1;                // Found something
  457.     if (i == 2 && str != end && *str == 'T')
  458.       str++;    // ISO8601:  CCYYMMDDThhmmss
  459.     else
  460.     {
  461.       while (str != end && (ispunct(*str) || isspace(*str)))
  462.       {
  463.     // Only allow space between days and hours
  464.     if (isspace(*str) && i != 2)
  465.       DBUG_RETURN(TIMESTAMP_NONE);
  466.     str++;
  467.       }
  468.     }
  469.     field_length=1;                // Rest fields can only be 2
  470.   }
  471.   /* Handle second fractions */
  472.   if (i == 6 && (uint) (end-str) >= 2 && *str == '.' && isdigit(str[1]))
  473.   {
  474.     str++;
  475.     uint tmp_value=(uint) (uchar) (*str - '0');
  476.     field_length=3;
  477.     while (str++ != end && isdigit(str[0]) && field_length--)
  478.       tmp_value=tmp_value*10 + (uint) (uchar) (*str - '0');
  479.     date[6]=tmp_value;
  480.   }
  481.   else
  482.     date[6]=0;
  483.  
  484.   if (year_length == 2)
  485.     date[0]+= (date[0] < YY_PART_YEAR ? 2000 : 1900);
  486.   number_of_fields=i;
  487.   while (i < 6)
  488.     date[i++]=0;
  489.   if (number_of_fields < 3 || !date_used || date[1] > 12 ||
  490.       date[2] > 31 || date[3] > 23 || date[4] > 59 || date[5] > 59 ||
  491.       !fuzzy_date && (date[1] == 0 || date[2] == 0))
  492.   {
  493.     current_thd->cuted_fields++;
  494.     DBUG_RETURN(TIMESTAMP_NONE);
  495.   }
  496.   if (str != end && current_thd->count_cuted_fields)
  497.   {
  498.     for ( ; str != end ; str++)
  499.     {
  500.       if (!isspace(*str))
  501.       {
  502.     current_thd->cuted_fields++;
  503.     break;
  504.       }
  505.     }
  506.   }
  507.   l_time->year=  date[0];
  508.   l_time->month= date[1];
  509.   l_time->day=     date[2];
  510.   l_time->hour=  date[3];
  511.   l_time->minute=date[4];
  512.   l_time->second=date[5];
  513.   l_time->second_part=date[6];
  514.   DBUG_RETURN(l_time->time_type=
  515.           (number_of_fields <= 3 ? TIMESTAMP_DATE : TIMESTAMP_FULL));
  516. }
  517.  
  518.  
  519. time_t str_to_timestamp(const char *str,uint length)
  520. {
  521.   TIME l_time;
  522.   if (str_to_TIME(str,length,&l_time,0) == TIMESTAMP_NONE)
  523.     return(0);
  524.   if (l_time.year >= TIMESTAMP_MAX_YEAR || l_time.year < 1900+YY_PART_YEAR)
  525.   {
  526.     current_thd->cuted_fields++;
  527.     return(0);
  528.   }
  529.   return(my_gmt_sec(&l_time));
  530. }
  531.  
  532.  
  533. longlong str_to_datetime(const char *str,uint length,bool fuzzy_date)
  534. {
  535.   TIME l_time;
  536.   if (str_to_TIME(str,length,&l_time,fuzzy_date) == TIMESTAMP_NONE)
  537.     return(0);
  538.   return (longlong) (l_time.year*LL(10000000000) +
  539.              l_time.month*LL(100000000)+
  540.              l_time.day*LL(1000000)+
  541.              l_time.hour*LL(10000)+
  542.              (longlong) (l_time.minute*100+l_time.second));
  543. }
  544.  
  545.  
  546. /*****************************************************************************
  547. ** convert a time string to a (ulong) value.
  548. ** Can use all full timestamp formats and
  549. ** [-] DAYS [H]H:MM:SS, [H]H:MM:SS, [M]M:SS, [H]HMMSS, [M]MSS or [S]S
  550. ** There may be an optional [.second_part] after seconds
  551. *****************************************************************************/
  552.  
  553. bool str_to_time(const char *str,uint length,TIME *l_time)
  554. {
  555.   long date[5],value;
  556.   const char *end=str+length;
  557.   bool found_days,found_hours;
  558.   uint state;
  559.  
  560.   l_time->neg=0;
  561.   for (; !isdigit(*str) && *str != '-' && str != end ; str++)
  562.     length--;
  563.   if (str != end && *str == '-')
  564.   {
  565.     l_time->neg=1;
  566.     str++;
  567.     length--;
  568.   }
  569.   if (str == end)
  570.     return 1;
  571.  
  572.   /* Check first if this is a full TIMESTAMP */
  573.   if (length >= 12)
  574.   {                        // Probably full timestamp
  575.     if (str_to_TIME(str,length,l_time,1) == TIMESTAMP_FULL)
  576.       return 0;                    // Was an ok timestamp
  577.   }
  578.  
  579.   /* Not a timestamp. Try to get this as a DAYS_TO_SECOND string */
  580.   for (value=0; str != end && isdigit(*str) ; str++)
  581.     value=value*10L + (long) (*str - '0');
  582.  
  583.   if (*str == ' ')
  584.   {
  585.     while (++str != end && str[0] == ' ') ;
  586.     str--;
  587.   }
  588.  
  589.   LINT_INIT(state);
  590.   found_days=found_hours=0;
  591.   if ((uint) (end-str) > 1 && (*str == ' ' && isdigit(str[1])))
  592.   {                        // days !
  593.     date[0]=value;
  594.     state=1;                    // Assume next is hours
  595.     found_days=1;
  596.     str++;                    // Skipp space;
  597.   }
  598.   else if ((end-str) > 1 && *str == ':' && isdigit(str[1]))
  599.   {
  600.     date[0]=0;                    // Assume we found hours
  601.     date[1]=value;
  602.     state=2;
  603.     found_hours=1;
  604.     str++;                    // skipp ':'
  605.   }
  606.   else
  607.   {
  608.     /* String given as one number; assume HHMMSS format */
  609.     date[0]= 0;
  610.     date[1]= value/10000;
  611.     date[2]= value/100 % 100;
  612.     date[3]= value % 100;
  613.     state=4;
  614.     goto fractional;
  615.   }
  616.  
  617.   /* Read hours, minutes and seconds */
  618.   for (;;)
  619.   {
  620.     for (value=0; str != end && isdigit(*str) ; str++)
  621.       value=value*10L + (long) (*str - '0');
  622.     date[state++]=value;
  623.     if (state == 4 || (end-str) < 2 || *str != ':' || !isdigit(str[1]))
  624.       break;
  625.     str++;                    // Skipp ':'
  626.   }
  627.  
  628.   if (state != 4)
  629.   {                        // Not HH:MM:SS
  630.     /* Fix the date to assume that seconds was given */
  631.     if (!found_hours && !found_days)
  632.     {
  633.       bmove_upp((char*) (date+4), (char*) (date+state),
  634.         sizeof(long)*(state-1));
  635.       bzero((char*) date, sizeof(long)*(4-state));
  636.     }
  637.     else
  638.       bzero((char*) (date+state), sizeof(long)*(4-state));
  639.   }
  640.  
  641.  fractional:
  642.   /* Get fractional second part */
  643.   if ((end-str) >= 2 && *str == '.' && isdigit(str[1]))
  644.   {
  645.     uint field_length=3;
  646.     str++; value=(uint) (uchar) (*str - '0');
  647.     while (++str != end && isdigit(str[0]) && field_length--)
  648.       value=value*10 + (uint) (uchar) (*str - '0');
  649.     date[4]=value;
  650.   }
  651.   else
  652.     date[4]=0;
  653.  
  654.   /* Some simple checks */
  655.   if (date[2] >= 60 || date[3] >= 60)
  656.   {
  657.     current_thd->cuted_fields++;
  658.     return 1;
  659.   }
  660.   l_time->month=0;
  661.   l_time->day=date[0];
  662.   l_time->hour=date[1];
  663.   l_time->minute=date[2];
  664.   l_time->second=date[3];
  665.   l_time->second_part=date[4];
  666.  
  667.   /* Check if there is garbage at end of the TIME specification */
  668.   if (str != end && current_thd->count_cuted_fields)
  669.   {
  670.     do
  671.     {
  672.       if (!isspace(*str))
  673.       {
  674.     current_thd->cuted_fields++;
  675.     break;
  676.       }
  677.     } while (++str != end);
  678.   }
  679.   return 0;
  680. }
  681.