item_timefunc.cc 86.2 KB
Newer Older
1
/* Copyright (C) 2000-2003 MySQL AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
6

unknown's avatar
unknown committed
7 8 9 10
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
11

unknown's avatar
unknown committed
12 13 14 15 16 17 18
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* This file defines all time functions */

19
#ifdef USE_PRAGMA_IMPLEMENTATION
unknown's avatar
unknown committed
20 21 22 23 24 25 26
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include <m_ctype.h>
#include <time.h>

27
/* TODO: Move month and days to language files */
unknown's avatar
unknown committed
28

29
/* Day number for Dec 31st, 9999 */
unknown's avatar
unknown committed
30 31
#define MAX_DAY_NUMBER 3652424L

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
/*
  OPTIMIZATION TODO:
   - Replace the switch with a function that should be called for each
     date type.
   - Remove sprintf and opencode the conversion, like we do in
     Field_datetime.

  The reason for this functions existence is that as we don't have a
  way to know if a datetime/time value has microseconds in them
  we are now only adding microseconds to the output if the
  value has microseconds.

  We can't use a standard make_date_time() for this as we don't know
  if someone will use %f in the format specifier in which case we would get
  the microseconds twice.
*/

49
static bool make_datetime(date_time_format_types format, MYSQL_TIME *ltime,
50
			  String *str)
unknown's avatar
unknown committed
51
{
52 53
  char *buff;
  CHARSET_INFO *cs= &my_charset_bin;
54
  uint length= MAX_DATE_STRING_REP_LENGTH;
unknown's avatar
unknown committed
55

56 57 58
  if (str->alloc(length))
    return 1;
  buff= (char*) str->ptr();
59

60 61 62 63 64 65 66
  switch (format) {
  case TIME_ONLY:
    length= cs->cset->snprintf(cs, buff, length, "%s%02d:%02d:%02d",
			       ltime->neg ? "-" : "",
			       ltime->hour, ltime->minute, ltime->second);
    break;
  case TIME_MICROSECOND:
67
    length= cs->cset->snprintf(cs, buff, length, "%s%02d:%02d:%02d.%06ld",
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
			       ltime->neg ? "-" : "",
			       ltime->hour, ltime->minute, ltime->second,
			       ltime->second_part);
    break;
  case DATE_ONLY:
    length= cs->cset->snprintf(cs, buff, length, "%04d-%02d-%02d",
			       ltime->year, ltime->month, ltime->day);
    break;
  case DATE_TIME:
    length= cs->cset->snprintf(cs, buff, length,
			       "%04d-%02d-%02d %02d:%02d:%02d",
			       ltime->year, ltime->month, ltime->day,
			       ltime->hour, ltime->minute, ltime->second);
    break;
  case DATE_TIME_MICROSECOND:
    length= cs->cset->snprintf(cs, buff, length,
84
			       "%04d-%02d-%02d %02d:%02d:%02d.%06ld",
85 86 87 88
			       ltime->year, ltime->month, ltime->day,
			       ltime->hour, ltime->minute, ltime->second,
			       ltime->second_part);
    break;
89
  }
90 91 92 93

  str->length(length);
  str->set_charset(cs);
  return 0;
94
}
unknown's avatar
unknown committed
95 96


97
/*
98
  Wrapper over make_datetime() with validation of the input MYSQL_TIME value
99 100 101 102 103 104 105 106 107

  NOTE
    see make_datetime() for more information

  RETURN
    1    if there was an error during converion
    0    otherwise
*/

108
static bool make_datetime_with_warn(date_time_format_types format, MYSQL_TIME *ltime,
109 110 111 112 113 114 115 116 117 118 119
                                    String *str)
{
  int warning= 0;

  if (make_datetime(format, ltime, str))
    return 1;
  if (check_time_range(ltime, &warning))
    return 1;
  if (!warning)
    return 0;

120 121
  make_truncated_value_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                               str->ptr(), str->length(),
122
                               MYSQL_TIMESTAMP_TIME, NullS);
123 124 125 126 127
  return make_datetime(format, ltime, str);
}


/*
128
  Wrapper over make_time() with validation of the input MYSQL_TIME value
129 130 131 132 133 134 135 136 137 138

  NOTE
    see make_time() for more info

  RETURN
    1    if there was an error during conversion
    0    otherwise
*/

static bool make_time_with_warn(const DATE_TIME_FORMAT *format,
139
                                MYSQL_TIME *l_time, String *str)
140 141 142 143 144 145 146
{
  int warning= 0;
  make_time(format, l_time, str);
  if (check_time_range(l_time, &warning))
    return 1;
  if (warning)
  {
147 148
    make_truncated_value_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                                 str->ptr(), str->length(),
149
                                 MYSQL_TIMESTAMP_TIME, NullS);
150 151 152 153 154 155 156 157
    make_time(format, l_time, str);
  }

  return 0;
}


/*
158
  Convert seconds to MYSQL_TIME value with overflow checking
159 160 161 162 163

  SYNOPSIS:
    sec_to_time()
    seconds          number of seconds
    unsigned_flag    1, if 'seconds' is unsigned, 0, otherwise
164
    ltime            output MYSQL_TIME value
165 166

  DESCRIPTION
167
    If the 'seconds' argument is inside MYSQL_TIME data range, convert it to a
168 169 170 171 172 173 174 175 176
    corresponding value.
    Otherwise, truncate the resulting value to the nearest endpoint, and
    produce a warning message.

  RETURN
    1                if the value was truncated during conversion
    0                otherwise
*/
  
177
static bool sec_to_time(longlong seconds, bool unsigned_flag, MYSQL_TIME *ltime)
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
{
  uint sec;

  bzero((char *)ltime, sizeof(*ltime));
  
  if (seconds < 0)
  {
    if (unsigned_flag)
      goto overflow;
    ltime->neg= 1;
    if (seconds < -3020399)
      goto overflow;
    seconds= -seconds;
  }
  else if (seconds > 3020399)
    goto overflow;
  
  sec= (uint) ((ulonglong) seconds % 3600);
  ltime->hour= (uint) (seconds/3600);
  ltime->minute= sec/60;
  ltime->second= sec % 60;

  return 0;

overflow:
  ltime->hour= TIME_MAX_HOUR;
  ltime->minute= TIME_MAX_MINUTE;
  ltime->second= TIME_MAX_SECOND;

  char buf[22];
  int len= (int)(longlong10_to_str(seconds, buf, unsigned_flag ? 10 : -10)
                 - buf);
210 211
  make_truncated_value_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                               buf, len, MYSQL_TIMESTAMP_TIME,
212
                               NullS);
213 214 215 216 217
  
  return 1;
}


unknown's avatar
unknown committed
218 219 220 221 222 223 224
/*
  Date formats corresponding to compound %r and %T conversion specifiers

  Note: We should init at least first element of "positions" array
        (first member) or hpux11 compiler will die horribly.
*/
static DATE_TIME_FORMAT time_ampm_format= {{0}, '\0', 0,
225
                                           {(char *)"%I:%i:%S %p", 11}};
unknown's avatar
unknown committed
226
static DATE_TIME_FORMAT time_24hrs_format= {{0}, '\0', 0,
227 228
                                            {(char *)"%H:%i:%S", 8}};

unknown's avatar
unknown committed
229
/*
230
  Extract datetime value to MYSQL_TIME struct from string value
231
  according to format string. 
232 233 234 235 236 237 238

  SYNOPSIS
    extract_date_time()
    format		date/time format specification
    val			String to decode
    length		Length of string
    l_time		Store result here
239 240 241
    cached_timestamp_type 
                       It uses to get an appropriate warning
                       in the case when the value is truncated.
242 243 244 245 246 247 248 249 250 251 252
    sub_pattern_end    if non-zero then we are parsing string which
                       should correspond compound specifier (like %T or
                       %r) and this parameter is pointer to place where
                       pointer to end of string matching this specifier
                       should be stored.
    NOTE
     Possibility to parse strings matching to patterns equivalent to compound
     specifiers is mainly intended for use from inside of this function in
     order to understand %T and %r conversion specifiers, so number of
     conversion specifiers that can be used in such sub-patterns is limited.
     Also most of checks are skipped in this case.
253

254 255 256
     If one adds new format specifiers to this function he should also
     consider adding them to get_date_time_result_type() function.

257 258 259
    RETURN
      0	ok
      1	error
unknown's avatar
unknown committed
260
*/
261 262

static bool extract_date_time(DATE_TIME_FORMAT *format,
263
			      const char *val, uint length, MYSQL_TIME *l_time,
264
                              timestamp_type cached_timestamp_type,
265 266
                              const char **sub_pattern_end,
                              const char *date_time_type)
unknown's avatar
unknown committed
267
{
unknown's avatar
unknown committed
268
  int weekday= 0, yearday= 0, daypart= 0;
269
  int week_number= -1;
270
  int error= 0;
271
  int  strict_week_number_year= -1;
272
  int frac_part;
273 274 275 276
  bool usa_time= 0;
  bool sunday_first_n_first_week_non_iso;
  bool strict_week_number;
  bool strict_week_number_year_type;
277
  const char *val_begin= val;
278 279
  const char *val_end= val + length;
  const char *ptr= format->format.str;
280
  const char *end= ptr + format->format.length;
281
  CHARSET_INFO *cs= &my_charset_bin;
282
  DBUG_ENTER("extract_date_time");
283

284
  LINT_INIT(strict_week_number);
285 286 287
  /* Remove valgrind varnings when using gcc 3.3 and -O1 */
  PURIFY_OR_LINT_INIT(strict_week_number_year_type);
  PURIFY_OR_LINT_INIT(sunday_first_n_first_week_non_iso);
288 289 290

  if (!sub_pattern_end)
    bzero((char*) l_time, sizeof(*l_time));
291 292

  for (; ptr != end && val != val_end; ptr++)
293
  {
294 295 296 297
    /* Skip pre-space between each argument */
    while (val != val_end && my_isspace(cs, *val))
      val++;

298 299
    if (*ptr == '%' && ptr+1 != end)
    {
300 301 302
      int val_len;
      char *tmp;

303
      error= 0;
304 305

      val_len= (uint) (val_end - val);
306
      switch (*++ptr) {
307
	/* Year */
308
      case 'Y':
309 310
	tmp= (char*) val + min(4, val_len);
	l_time->year= (int) my_strtoll10(val, &tmp, &error);
311 312
        if ((int) (tmp-val) <= 2)
          l_time->year= year_2000_handling(l_time->year);
313
	val= tmp;
314 315
	break;
      case 'y':
316 317 318
	tmp= (char*) val + min(2, val_len);
	l_time->year= (int) my_strtoll10(val, &tmp, &error);
	val= tmp;
319
        l_time->year= year_2000_handling(l_time->year);
320
	break;
321 322

	/* Month */
323
      case 'm':
324 325 326 327 328 329
      case 'c':
	tmp= (char*) val + min(2, val_len);
	l_time->month= (int) my_strtoll10(val, &tmp, &error);
	val= tmp;
	break;
      case 'M':
unknown's avatar
unknown committed
330 331 332 333
	if ((l_time->month= check_word(my_locale_en_US.month_names,
				       val, val_end, &val)) <= 0)
	  goto err;
	break;
334
      case 'b':
unknown's avatar
unknown committed
335
	if ((l_time->month= check_word(my_locale_en_US.ab_month_names,
336 337
				       val, val_end, &val)) <= 0)
	  goto err;
338
	break;
339
	/* Day */
340
      case 'd':
341 342 343 344
      case 'e':
	tmp= (char*) val + min(2, val_len);
	l_time->day= (int) my_strtoll10(val, &tmp, &error);
	val= tmp;
345 346
	break;
      case 'D':
347 348 349
	tmp= (char*) val + min(2, val_len);
	l_time->day= (int) my_strtoll10(val, &tmp, &error);
	/* Skip 'st, 'nd, 'th .. */
350
	val= tmp + min((int) (val_end-tmp), 2);
351 352 353 354 355 356 357 358 359 360 361 362 363
	break;

	/* Hour */
      case 'h':
      case 'I':
      case 'l':
	usa_time= 1;
	/* fall through */
      case 'k':
      case 'H':
	tmp= (char*) val + min(2, val_len);
	l_time->hour= (int) my_strtoll10(val, &tmp, &error);
	val= tmp;
364
	break;
365 366

	/* Minute */
367
      case 'i':
368 369 370
	tmp= (char*) val + min(2, val_len);
	l_time->minute= (int) my_strtoll10(val, &tmp, &error);
	val= tmp;
371
	break;
372 373

	/* Second */
374 375
      case 's':
      case 'S':
376 377 378
	tmp= (char*) val + min(2, val_len);
	l_time->second= (int) my_strtoll10(val, &tmp, &error);
	val= tmp;
379
	break;
380 381 382 383

	/* Second part */
      case 'f':
	tmp= (char*) val_end;
384 385
	if (tmp - val > 6)
	  tmp= (char*) val + 6;
unknown's avatar
unknown committed
386
	l_time->second_part= (int) my_strtoll10(val, &tmp, &error);
387 388 389
	frac_part= 6 - (tmp - val);
	if (frac_part > 0)
	  l_time->second_part*= (ulong) log_10_int[frac_part];
390
	val= tmp;
391
	break;
392 393 394 395 396 397 398 399 400 401 402 403 404

	/* AM / PM */
      case 'p':
	if (val_len < 2 || ! usa_time)
	  goto err;
	if (!my_strnncoll(&my_charset_latin1,
			  (const uchar *) val, 2, 
			  (const uchar *) "PM", 2))
	  daypart= 12;
	else if (my_strnncoll(&my_charset_latin1,
			      (const uchar *) val, 2, 
			      (const uchar *) "AM", 2))
	  goto err;
405
	val+= 2;
406
	break;
407 408

	/* Exotic things */
409
      case 'W':
unknown's avatar
unknown committed
410 411 412
	if ((weekday= check_word(my_locale_en_US.day_names, val, val_end, &val)) <= 0)
	  goto err;
	break;
413
      case 'a':
unknown's avatar
unknown committed
414
	if ((weekday= check_word(my_locale_en_US.ab_day_names, val, val_end, &val)) <= 0)
415
	  goto err;
416 417
	break;
      case 'w':
418
	tmp= (char*) val + 1;
419
	if ((weekday= (int) my_strtoll10(val, &tmp, &error)) < 0 ||
420 421
	    weekday >= 7)
	  goto err;
422 423 424
        /* We should use the same 1 - 7 scale for %w as for %W */
        if (!weekday)
          weekday= 7;
425
	val= tmp;
426 427
	break;
      case 'j':
428 429 430
	tmp= (char*) val + min(val_len, 3);
	yearday= (int) my_strtoll10(val, &tmp, &error);
	val= tmp;
431
	break;
432

433 434
        /* Week numbers */
      case 'V':
435
      case 'U':
436
      case 'v':
437
      case 'u':
438 439
        sunday_first_n_first_week_non_iso= (*ptr=='U' || *ptr== 'V');
        strict_week_number= (*ptr=='V' || *ptr=='v');
440
	tmp= (char*) val + min(val_len, 2);
441 442 443 444
	if ((week_number= (int) my_strtoll10(val, &tmp, &error)) < 0 ||
            strict_week_number && !week_number ||
            week_number > 53)
          goto err;
445
	val= tmp;
446
	break;
447

448 449 450 451 452 453 454 455 456 457 458
        /* Year used with 'strict' %V and %v week numbers */
      case 'X':
      case 'x':
        strict_week_number_year_type= (*ptr=='X');
        tmp= (char*) val + min(4, val_len);
        strict_week_number_year= (int) my_strtoll10(val, &tmp, &error);
        val= tmp;
        break;

        /* Time in AM/PM notation */
      case 'r':
459 460 461 462 463 464 465 466
        /*
          We can't just set error here, as we don't want to generate two
          warnings in case of errors
        */
        if (extract_date_time(&time_ampm_format, val,
                              (uint)(val_end - val), l_time,
                              cached_timestamp_type, &val, "time"))
          DBUG_RETURN(1);
467 468 469 470
        break;

        /* Time in 24-hour notation */
      case 'T':
471 472 473 474
        if (extract_date_time(&time_24hrs_format, val,
                              (uint)(val_end - val), l_time,
                              cached_timestamp_type, &val, "time"))
          DBUG_RETURN(1);
475 476 477
        break;

        /* Conversion specifiers that match classes of characters */
478 479 480 481 482 483 484 485 486 487 488 489
      case '.':
	while (my_ispunct(cs, *val) && val != val_end)
	  val++;
	break;
      case '@':
	while (my_isalpha(cs, *val) && val != val_end)
	  val++;
	break;
      case '#':
	while (my_isdigit(cs, *val) && val != val_end)
	  val++;
	break;
490
      default:
491
	goto err;
492
      }
493 494
      if (error)				// Error from my_strtoll10
	goto err;
495
    }
496
    else if (!my_isspace(cs, *ptr))
497
    {
498 499 500
      if (*val != *ptr)
	goto err;
      val++;
501 502 503 504 505
    }
  }
  if (usa_time)
  {
    if (l_time->hour > 12 || l_time->hour < 1)
506
      goto err;
507 508
    l_time->hour= l_time->hour%12+daypart;
  }
unknown's avatar
unknown committed
509

510 511 512 513 514 515 516 517 518 519
  /*
    If we are recursively called for parsing string matching compound
    specifiers we are already done.
  */
  if (sub_pattern_end)
  {
    *sub_pattern_end= val;
    DBUG_RETURN(0);
  }

520 521
  if (yearday > 0)
  {
522 523
    uint days;
    days= calc_daynr(l_time->year,1,1) +  yearday - 1;
524
    if (days <= 0 || days > MAX_DAY_NUMBER)
525 526
      goto err;
    get_date_from_daynr(days,&l_time->year,&l_time->month,&l_time->day);
527
  }
unknown's avatar
unknown committed
528

529 530
  if (week_number >= 0 && weekday)
  {
531
    int days;
532 533
    uint weekday_b;

534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557
    /*
      %V,%v require %X,%x resprectively,
      %U,%u should be used with %Y and not %X or %x
    */
    if (strict_week_number &&
        (strict_week_number_year < 0 ||
         strict_week_number_year_type != sunday_first_n_first_week_non_iso) ||
        !strict_week_number && strict_week_number_year >= 0)
      goto err;

    /* Number of days since year 0 till 1st Jan of this year */
    days= calc_daynr((strict_week_number ? strict_week_number_year :
                                           l_time->year),
                     1, 1);
    /* Which day of week is 1st Jan of this year */
    weekday_b= calc_weekday(days, sunday_first_n_first_week_non_iso);

    /*
      Below we are going to sum:
      1) number of days since year 0 till 1st day of 1st week of this year
      2) number of days between 1st week and our week
      3) and position of our day in the week
    */
    if (sunday_first_n_first_week_non_iso)
558
    {
559 560 561
      days+= ((weekday_b == 0) ? 0 : 7) - weekday_b +
             (week_number - 1) * 7 +
             weekday % 7;
562 563 564
    }
    else
    {
565 566 567
      days+= ((weekday_b <= 3) ? 0 : 7) - weekday_b +
             (week_number - 1) * 7 +
             (weekday - 1);
568
    }
569

570
    if (days <= 0 || days > MAX_DAY_NUMBER)
571 572
      goto err;
    get_date_from_daynr(days,&l_time->year,&l_time->month,&l_time->day);
unknown's avatar
unknown committed
573 574
  }

575 576
  if (l_time->month > 12 || l_time->day > 31 || l_time->hour > 23 || 
      l_time->minute > 59 || l_time->second > 59)
577
    goto err;
578

579 580 581 582 583 584
  if (val != val_end)
  {
    do
    {
      if (!my_isspace(&my_charset_latin1,*val))
      {
585 586
	make_truncated_value_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                                     val_begin, length,
unknown's avatar
unknown committed
587
				     cached_timestamp_type, NullS);
588 589 590 591
	break;
      }
    } while (++val != val_end);
  }
592 593
  DBUG_RETURN(0);

594
err:
595 596 597 598 599
  {
    char buff[128];
    strmake(buff, val_begin, min(length, sizeof(buff)-1));
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                        ER_WRONG_VALUE_FOR_TYPE, ER(ER_WRONG_VALUE_FOR_TYPE),
600
                        date_time_type, buff, "str_to_date");
601
  }
602 603
  DBUG_RETURN(1);
}
604 605 606


/*
607
  Create a formated date/time value in a string
608 609
*/

610
bool make_date_time(DATE_TIME_FORMAT *format, MYSQL_TIME *l_time,
611
		    timestamp_type type, String *str)
612 613 614 615 616
{
  char intbuff[15];
  uint hours_i;
  uint weekday;
  ulong length;
617
  const char *ptr, *end;
unknown's avatar
unknown committed
618
  THD *thd= current_thd;
619
  MY_LOCALE *locale= thd->variables.lc_time_names;
620 621 622

  str->length(0);

623
  if (l_time->neg)
624
    str->append('-');
625 626
  
  end= (ptr= format->format.str) + format->format.length;
627 628 629 630 631 632 633 634
  for (; ptr != end ; ptr++)
  {
    if (*ptr != '%' || ptr+1 == end)
      str->append(*ptr);
    else
    {
      switch (*++ptr) {
      case 'M':
635 636 637 638 639 640
        if (!l_time->month)
          return 1;
        str->append(locale->month_names->type_names[l_time->month-1],
                    strlen(locale->month_names->type_names[l_time->month-1]),
                    system_charset_info);
        break;
641
      case 'b':
642 643 644 645 646 647
        if (!l_time->month)
          return 1;
        str->append(locale->ab_month_names->type_names[l_time->month-1],
                    strlen(locale->ab_month_names->type_names[l_time->month-1]),
                    system_charset_info);
        break;
648
      case 'W':
649 650 651 652 653 654 655 656
        if (type == MYSQL_TIMESTAMP_TIME)
          return 1;
        weekday= calc_weekday(calc_daynr(l_time->year,l_time->month,
                              l_time->day),0);
        str->append(locale->day_names->type_names[weekday],
                    strlen(locale->day_names->type_names[weekday]),
                    system_charset_info);
        break;
657
      case 'a':
658 659 660 661 662 663 664 665
        if (type == MYSQL_TIMESTAMP_TIME)
          return 1;
        weekday=calc_weekday(calc_daynr(l_time->year,l_time->month,
                             l_time->day),0);
        str->append(locale->ab_day_names->type_names[weekday],
                    strlen(locale->ab_day_names->type_names[weekday]),
                    system_charset_info);
        break;
666
      case 'D':
667
	if (type == MYSQL_TIMESTAMP_TIME)
668
	  return 1;
669 670 671
	length= int10_to_str(l_time->day, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 1, '0');
	if (l_time->day >= 10 &&  l_time->day <= 19)
672
	  str->append(STRING_WITH_LEN("th"));
673 674 675 676
	else
	{
	  switch (l_time->day %10) {
	  case 1:
677
	    str->append(STRING_WITH_LEN("st"));
678 679
	    break;
	  case 2:
680
	    str->append(STRING_WITH_LEN("nd"));
681 682
	    break;
	  case 3:
683
	    str->append(STRING_WITH_LEN("rd"));
684 685
	    break;
	  default:
686
	    str->append(STRING_WITH_LEN("th"));
687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724
	    break;
	  }
	}
	break;
      case 'Y':
	length= int10_to_str(l_time->year, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 4, '0');
	break;
      case 'y':
	length= int10_to_str(l_time->year%100, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 2, '0');
	break;
      case 'm':
	length= int10_to_str(l_time->month, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 2, '0');
	break;
      case 'c':
	length= int10_to_str(l_time->month, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 1, '0');
	break;
      case 'd':
	length= int10_to_str(l_time->day, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 2, '0');
	break;
      case 'e':
	length= int10_to_str(l_time->day, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 1, '0');
	break;
      case 'f':
	length= int10_to_str(l_time->second_part, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 6, '0');
	break;
      case 'H':
	length= int10_to_str(l_time->hour, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 2, '0');
	break;
      case 'h':
      case 'I':
725
	hours_i= (l_time->hour%24 + 11)%12+1;
726 727 728 729 730 731 732 733
	length= int10_to_str(hours_i, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 2, '0');
	break;
      case 'i':					/* minutes */
	length= int10_to_str(l_time->minute, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 2, '0');
	break;
      case 'j':
734
	if (type == MYSQL_TIMESTAMP_TIME)
735 736 737
	  return 1;
	length= int10_to_str(calc_daynr(l_time->year,l_time->month,
					l_time->day) - 
738 739 740 741 742 743 744 745
		     calc_daynr(l_time->year,1,1) + 1, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 3, '0');
	break;
      case 'k':
	length= int10_to_str(l_time->hour, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 1, '0');
	break;
      case 'l':
746
	hours_i= (l_time->hour%24 + 11)%12+1;
747 748 749 750 751 752 753 754 755 756
	length= int10_to_str(hours_i, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 1, '0');
	break;
      case 'p':
	hours_i= l_time->hour%24;
	str->append(hours_i < 12 ? "AM" : "PM",2);
	break;
      case 'r':
	length= my_sprintf(intbuff, 
		   (intbuff, 
unknown's avatar
unknown committed
757 758
		    ((l_time->hour % 24) < 12) ?
                    "%02d:%02d:%02d AM" : "%02d:%02d:%02d PM",
759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
		    (l_time->hour+11)%12+1,
		    l_time->minute,
		    l_time->second));
	str->append(intbuff, length);
	break;
      case 'S':
      case 's':
	length= int10_to_str(l_time->second, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 2, '0');
	break;
      case 'T':
	length= my_sprintf(intbuff, 
		   (intbuff, 
		    "%02d:%02d:%02d", 
		    l_time->hour, 
		    l_time->minute,
		    l_time->second));
	str->append(intbuff, length);
	break;
      case 'U':
      case 'u':
      {
	uint year;
782
	if (type == MYSQL_TIMESTAMP_TIME)
783
	  return 1;
unknown's avatar
unknown committed
784 785 786 787 788
	length= int10_to_str(calc_week(l_time,
				       (*ptr) == 'U' ?
				       WEEK_FIRST_WEEKDAY : WEEK_MONDAY_FIRST,
				       &year),
			     intbuff, 10) - intbuff;
789 790 791 792 793 794 795
	str->append_with_prefill(intbuff, length, 2, '0');
      }
      break;
      case 'v':
      case 'V':
      {
	uint year;
796
	if (type == MYSQL_TIMESTAMP_TIME)
797
	  return 1;
unknown's avatar
unknown committed
798 799 800 801 802 803
	length= int10_to_str(calc_week(l_time,
				       ((*ptr) == 'V' ?
					(WEEK_YEAR | WEEK_FIRST_WEEKDAY) :
					(WEEK_YEAR | WEEK_MONDAY_FIRST)),
				       &year),
			     intbuff, 10) - intbuff;
804 805 806 807 808 809 810
	str->append_with_prefill(intbuff, length, 2, '0');
      }
      break;
      case 'x':
      case 'X':
      {
	uint year;
811
	if (type == MYSQL_TIMESTAMP_TIME)
812
	  return 1;
unknown's avatar
unknown committed
813 814 815 816 817
	(void) calc_week(l_time,
			 ((*ptr) == 'X' ?
			  WEEK_YEAR | WEEK_FIRST_WEEKDAY :
			  WEEK_YEAR | WEEK_MONDAY_FIRST),
			 &year);
818 819 820 821 822
	length= int10_to_str(year, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 4, '0');
      }
      break;
      case 'w':
823
	if (type == MYSQL_TIMESTAMP_TIME)
824 825 826
	  return 1;
	weekday=calc_weekday(calc_daynr(l_time->year,l_time->month,
					l_time->day),1);
827 828 829
	length= int10_to_str(weekday, intbuff, 10) - intbuff;
	str->append_with_prefill(intbuff, length, 1, '0');
	break;
830

831 832 833 834 835 836
      default:
	str->append(*ptr);
	break;
      }
    }
  }
837
  return 0;
unknown's avatar
unknown committed
838 839
}

840

unknown's avatar
unknown committed
841
/*
842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858
  Get a array of positive numbers from a string object.
  Each number is separated by 1 non digit character
  Return error if there is too many numbers.
  If there is too few numbers, assume that the numbers are left out
  from the high end. This allows one to give:
  DAY_TO_SECOND as "D MM:HH:SS", "MM:HH:SS" "HH:SS" or as seconds.

  SYNOPSIS
    str:            string value
    length:         length of str
    cs:             charset of str
    values:         array of results
    count:          count of elements in result array
    transform_msec: if value is true we suppose
                    that the last part of string value is microseconds
                    and we should transform value to six digit value.
                    For example, '1.1' -> '1.100000'
unknown's avatar
unknown committed
859 860
*/

unknown's avatar
unknown committed
861
static bool get_interval_info(const char *str,uint length,CHARSET_INFO *cs,
unknown's avatar
unknown committed
862 863
                              uint count, ulonglong *values,
                              bool transform_msec)
unknown's avatar
unknown committed
864 865 866
{
  const char *end=str+length;
  uint i;
867
  while (str != end && !my_isdigit(cs,*str))
unknown's avatar
unknown committed
868 869 870 871
    str++;

  for (i=0 ; i < count ; i++)
  {
872
    longlong value;
873
    const char *start= str;
874
    for (value=0; str != end && my_isdigit(cs,*str) ; str++)
unknown's avatar
unknown committed
875
      value= value*LL(10) + (longlong) (*str - '0');
876 877 878 879 880 881
    if (transform_msec && i == count - 1) // microseconds always last
    {
      long msec_length= 6 - (str - start);
      if (msec_length > 0)
	value*= (long) log_10_int[msec_length];
    }
unknown's avatar
unknown committed
882
    values[i]= value;
883
    while (str != end && !my_isdigit(cs,*str))
unknown's avatar
unknown committed
884 885 886 887 888
      str++;
    if (str == end && i != count-1)
    {
      i++;
      /* Change values[0...i-1] -> values[0...count-1] */
889
      bmove_upp((uchar*) (values+count), (uchar*) (values+i),
890
		sizeof(*values)*i);
891
      bzero((uchar*) values, sizeof(*values)*(count-i));
unknown's avatar
unknown committed
892 893 894 895 896 897
      break;
    }
  }
  return (str != end);
}

unknown's avatar
unknown committed
898

unknown's avatar
unknown committed
899 900
longlong Item_func_period_add::val_int()
{
901
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
902 903 904 905 906 907 908 909 910 911 912 913 914 915
  ulong period=(ulong) args[0]->val_int();
  int months=(int) args[1]->val_int();

  if ((null_value=args[0]->null_value || args[1]->null_value) ||
      period == 0L)
    return 0; /* purecov: inspected */
  return (longlong)
    convert_month_to_period((uint) ((int) convert_period_to_month(period)+
				    months));
}


longlong Item_func_period_diff::val_int()
{
916
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
917 918 919 920 921 922 923 924 925 926 927 928 929
  ulong period1=(ulong) args[0]->val_int();
  ulong period2=(ulong) args[1]->val_int();

  if ((null_value=args[0]->null_value || args[1]->null_value))
    return 0; /* purecov: inspected */
  return (longlong) ((long) convert_period_to_month(period1)-
		     (long) convert_period_to_month(period2));
}



longlong Item_func_to_days::val_int()
{
930
  DBUG_ASSERT(fixed == 1);
931
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
932
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
unknown's avatar
unknown committed
933 934 935 936
    return 0;
  return (longlong) calc_daynr(ltime.year,ltime.month,ltime.day);
}

937 938 939 940 941 942 943 944 945 946 947 948 949 950 951

/*
  Get information about this Item tree monotonicity

  SYNOPSIS
    Item_func_to_days::get_monotonicity_info()

  DESCRIPTION
  Get information about monotonicity of the function represented by this item
  tree.

  RETURN
    See enum_monotonicity_info.
*/

unknown's avatar
unknown committed
952 953 954 955 956 957 958 959 960 961 962 963 964
enum_monotonicity_info Item_func_to_days::get_monotonicity_info() const
{
  if (args[0]->type() == Item::FIELD_ITEM)
  {
    if (args[0]->field_type() == MYSQL_TYPE_DATE)
      return MONOTONIC_STRICT_INCREASING;
    if (args[0]->field_type() == MYSQL_TYPE_DATETIME)
      return MONOTONIC_INCREASING;
  }
  return NON_MONOTONIC;
}


965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002
longlong Item_func_to_days::val_int_endpoint(bool left_endp, bool *incl_endp)
{
  DBUG_ASSERT(fixed == 1);
  MYSQL_TIME ltime;
  longlong res;
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
  {
    /* got NULL, leave the incl_endp intact */
    return LONGLONG_MIN;
  }
  res=(longlong) calc_daynr(ltime.year,ltime.month,ltime.day);
  
  if (args[0]->field_type() == MYSQL_TYPE_DATE)
  {
    // TO_DAYS() is strictly monotonic for dates, leave incl_endp intact
    return res;
  }
 
  /*
    Handle the special but practically useful case of datetime values that
    point to day bound ("strictly less" comparison stays intact):

      col < '2007-09-15 00:00:00'  -> TO_DAYS(col) <  TO_DAYS('2007-09-15')

    which is different from the general case ("strictly less" changes to
    "less or equal"):

      col < '2007-09-15 12:34:56'  -> TO_DAYS(col) <= TO_DAYS('2007-09-15')
  */
  if (!left_endp && !(ltime.hour || ltime.minute || ltime.second ||
                      ltime.second_part))
    ; /* do nothing */
  else
    *incl_endp= TRUE;
  return res;
}


unknown's avatar
unknown committed
1003 1004
longlong Item_func_dayofyear::val_int()
{
1005
  DBUG_ASSERT(fixed == 1);
1006
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
1007
  if (get_arg0_date(&ltime,TIME_NO_ZERO_DATE))
unknown's avatar
unknown committed
1008 1009 1010 1011 1012 1013 1014
    return 0;
  return (longlong) calc_daynr(ltime.year,ltime.month,ltime.day) -
    calc_daynr(ltime.year,1,1) + 1;
}

longlong Item_func_dayofmonth::val_int()
{
1015
  DBUG_ASSERT(fixed == 1);
1016
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
1017
  (void) get_arg0_date(&ltime, TIME_FUZZY_DATE);
unknown's avatar
unknown committed
1018 1019 1020 1021 1022
  return (longlong) ltime.day;
}

longlong Item_func_month::val_int()
{
1023
  DBUG_ASSERT(fixed == 1);
1024
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
1025
  (void) get_arg0_date(&ltime, TIME_FUZZY_DATE);
unknown's avatar
unknown committed
1026 1027 1028
  return (longlong) ltime.month;
}

1029

unknown's avatar
unknown committed
1030 1031
String* Item_func_monthname::val_str(String* str)
{
1032
  DBUG_ASSERT(fixed == 1);
1033
  const char *month_name;
1034
  uint   month= (uint) val_int();
unknown's avatar
unknown committed
1035
  THD *thd= current_thd;
1036

1037
  if (null_value || !month)
1038 1039
  {
    null_value=1;
unknown's avatar
unknown committed
1040
    return (String*) 0;
1041 1042
  }
  null_value=0;
unknown's avatar
unknown committed
1043
  month_name= thd->variables.lc_time_names->month_names->type_names[month-1];
1044
  str->set(month_name, strlen(month_name), system_charset_info);
1045
  return str;
unknown's avatar
unknown committed
1046 1047
}

1048

unknown's avatar
unknown committed
1049 1050 1051 1052
// Returns the quarter of the year

longlong Item_func_quarter::val_int()
{
1053
  DBUG_ASSERT(fixed == 1);
1054
  MYSQL_TIME ltime;
1055 1056
  if (get_arg0_date(&ltime, TIME_FUZZY_DATE))
    return 0;
unknown's avatar
unknown committed
1057 1058 1059 1060 1061
  return (longlong) ((ltime.month+2)/3);
}

longlong Item_func_hour::val_int()
{
1062
  DBUG_ASSERT(fixed == 1);
1063
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
1064 1065 1066 1067 1068 1069
  (void) get_arg0_time(&ltime);
  return ltime.hour;
}

longlong Item_func_minute::val_int()
{
1070
  DBUG_ASSERT(fixed == 1);
1071
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
1072 1073 1074 1075 1076 1077 1078
  (void) get_arg0_time(&ltime);
  return ltime.minute;
}
// Returns the second in time_exp in the range of 0 - 59

longlong Item_func_second::val_int()
{
1079
  DBUG_ASSERT(fixed == 1);
1080
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
1081 1082 1083 1084 1085
  (void) get_arg0_time(&ltime);
  return ltime.second;
}


1086 1087 1088 1089 1090 1091 1092
uint week_mode(uint mode)
{
  uint week_format= (mode & 7);
  if (!(week_format & WEEK_MONDAY_FIRST))
    week_format^= WEEK_FIRST_WEEKDAY;
  return week_format;
}
1093

1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120
/*
  The bits in week_format(for calc_week() function) has the following meaning:
   WEEK_MONDAY_FIRST (0)  If not set	Sunday is first day of week
      		   	  If set	Monday is first day of week
   WEEK_YEAR (1)	  If not set	Week is in range 0-53

   	Week 0 is returned for the the last week of the previous year (for
	a date at start of january) In this case one can get 53 for the
	first week of next year.  This flag ensures that the week is
	relevant for the given year. Note that this flag is only
	releveant if WEEK_JANUARY is not set.

			  If set	 Week is in range 1-53.

	In this case one may get week 53 for a date in January (when
	the week is that last week of previous year) and week 1 for a
	date in December.

  WEEK_FIRST_WEEKDAY (2)  If not set	Weeks are numbered according
			   		to ISO 8601:1988
			  If set	The week that contains the first
					'first-day-of-week' is week 1.
	
	ISO 8601:1988 means that if the week containing January 1 has
	four or more days in the new year, then it is week 1;
	Otherwise it is the last week of the previous year, and the
	next week is week 1.
1121
*/
unknown's avatar
unknown committed
1122 1123 1124

longlong Item_func_week::val_int()
{
1125
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1126
  uint year;
1127
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
1128
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
unknown's avatar
unknown committed
1129
    return 0;
1130 1131
  return (longlong) calc_week(&ltime,
			      week_mode((uint) args[1]->val_int()),
1132
			      &year);
unknown's avatar
unknown committed
1133 1134 1135 1136 1137
}


longlong Item_func_yearweek::val_int()
{
1138
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1139
  uint year,week;
1140
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
1141
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
unknown's avatar
unknown committed
1142
    return 0;
1143 1144 1145
  week= calc_week(&ltime, 
		  (week_mode((uint) args[1]->val_int()) | WEEK_YEAR),
		  &year);
unknown's avatar
unknown committed
1146 1147 1148 1149 1150 1151
  return week+year*100;
}


longlong Item_func_weekday::val_int()
{
1152
  DBUG_ASSERT(fixed == 1);
1153
  MYSQL_TIME ltime;
1154 1155 1156
  
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
    return 0;
unknown's avatar
unknown committed
1157

1158 1159 1160
  return (longlong) calc_weekday(calc_daynr(ltime.year, ltime.month,
                                            ltime.day),
                                 odbc_type) + test(odbc_type);
unknown's avatar
unknown committed
1161 1162
}

1163

unknown's avatar
unknown committed
1164 1165
String* Item_func_dayname::val_str(String* str)
{
1166
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1167
  uint weekday=(uint) val_int();		// Always Item_func_daynr()
1168
  const char *day_name;
unknown's avatar
unknown committed
1169
  THD *thd= current_thd;
1170

unknown's avatar
unknown committed
1171 1172
  if (null_value)
    return (String*) 0;
1173
  
1174 1175
  day_name= thd->variables.lc_time_names->day_names->type_names[weekday];
  str->set(day_name, strlen(day_name), system_charset_info);
1176
  return str;
unknown's avatar
unknown committed
1177 1178 1179 1180 1181
}


longlong Item_func_year::val_int()
{
1182
  DBUG_ASSERT(fixed == 1);
1183
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
1184
  (void) get_arg0_date(&ltime, TIME_FUZZY_DATE);
unknown's avatar
unknown committed
1185 1186 1187
  return (longlong) ltime.year;
}

1188 1189 1190 1191 1192

/*
  Get information about this Item tree monotonicity

  SYNOPSIS
1193
    Item_func_year::get_monotonicity_info()
1194 1195 1196 1197 1198 1199 1200 1201 1202

  DESCRIPTION
  Get information about monotonicity of the function represented by this item
  tree.

  RETURN
    See enum_monotonicity_info.
*/

unknown's avatar
unknown committed
1203 1204 1205 1206 1207 1208 1209 1210
enum_monotonicity_info Item_func_year::get_monotonicity_info() const
{
  if (args[0]->type() == Item::FIELD_ITEM &&
      (args[0]->field_type() == MYSQL_TYPE_DATE ||
       args[0]->field_type() == MYSQL_TYPE_DATETIME))
    return MONOTONIC_INCREASING;
  return NON_MONOTONIC;
}
unknown's avatar
unknown committed
1211

1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242

longlong Item_func_year::val_int_endpoint(bool left_endp, bool *incl_endp)
{
  DBUG_ASSERT(fixed == 1);
  MYSQL_TIME ltime;
  if (get_arg0_date(&ltime, TIME_FUZZY_DATE))
  {
    /* got NULL, leave the incl_endp intact */
    return LONGLONG_MIN;
  }

  /*
    Handle the special but practically useful case of datetime values that
    point to year bound ("strictly less" comparison stays intact) :

      col < '2007-01-01 00:00:00'  -> YEAR(col) <  2007

    which is different from the general case ("strictly less" changes to
    "less or equal"):

      col < '2007-09-15 23:00:00'  -> YEAR(col) <= 2007
  */
  if (!left_endp && ltime.day == 1 && ltime.month == 1 && 
      !(ltime.hour || ltime.minute || ltime.second || ltime.second_part))
    ; /* do nothing */
  else
    *incl_endp= TRUE;
  return ltime.year;
}


unknown's avatar
unknown committed
1243 1244
longlong Item_func_unix_timestamp::val_int()
{
1245
  MYSQL_TIME ltime;
1246
  my_bool not_used;
1247
  
1248
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1249
  if (arg_count == 0)
1250
    return (longlong) current_thd->query_start();
unknown's avatar
unknown committed
1251 1252 1253
  if (args[0]->type() == FIELD_ITEM)
  {						// Optimize timestamp field
    Field *field=((Item_field*) args[0])->field;
1254
    if (field->type() == MYSQL_TYPE_TIMESTAMP)
1255
      return ((Field_timestamp*) field)->get_timestamp(&null_value);
unknown's avatar
unknown committed
1256
  }
1257 1258
  
  if (get_arg0_date(&ltime, 0))
unknown's avatar
unknown committed
1259
  {
1260 1261 1262 1263 1264 1265 1266
    /*
      We have to set null_value again because get_arg0_date will also set it
      to true if we have wrong datetime parameter (and we should return 0 in 
      this case).
    */
    null_value= args[0]->null_value;
    return 0;
unknown's avatar
unknown committed
1267
  }
1268 1269
  
  return (longlong) TIME_to_timestamp(current_thd, &ltime, &not_used);
unknown's avatar
unknown committed
1270 1271 1272 1273 1274
}


longlong Item_func_time_to_sec::val_int()
{
1275
  DBUG_ASSERT(fixed == 1);
1276
  MYSQL_TIME ltime;
1277
  longlong seconds;
unknown's avatar
unknown committed
1278
  (void) get_arg0_time(&ltime);
1279 1280
  seconds=ltime.hour*3600L+ltime.minute*60+ltime.second;
  return ltime.neg ? -seconds : seconds;
unknown's avatar
unknown committed
1281 1282 1283 1284
}


/*
1285 1286
  Convert a string to a interval value
  To make code easy, allow interval objects without separators.
unknown's avatar
unknown committed
1287 1288
*/

1289
bool get_interval_value(Item *args,interval_type int_type,
1290
			       String *str_value, INTERVAL *interval)
unknown's avatar
unknown committed
1291
{
unknown's avatar
unknown committed
1292
  ulonglong array[5];
1293
  longlong value;
unknown's avatar
unknown committed
1294
  const char *str;
1295
  size_t length;
1296
  CHARSET_INFO *cs=str_value->charset();
unknown's avatar
unknown committed
1297

1298 1299 1300 1301 1302
  LINT_INIT(value);
  LINT_INIT(str);
  LINT_INIT(length);

  bzero((char*) interval,sizeof(*interval));
unknown's avatar
unknown committed
1303
  if ((int) int_type <= INTERVAL_MICROSECOND)
unknown's avatar
unknown committed
1304
  {
1305
    value= args->val_int();
unknown's avatar
unknown committed
1306 1307 1308 1309
    if (args->null_value)
      return 1;
    if (value < 0)
    {
1310
      interval->neg=1;
unknown's avatar
unknown committed
1311 1312 1313 1314 1315 1316 1317 1318 1319
      value= -value;
    }
  }
  else
  {
    String *res;
    if (!(res=args->val_str(str_value)))
      return (1);

1320
    /* record negative intervalls in interval->neg */
unknown's avatar
unknown committed
1321 1322
    str=res->ptr();
    const char *end=str+res->length();
1323
    while (str != end && my_isspace(cs,*str))
unknown's avatar
unknown committed
1324 1325 1326
      str++;
    if (str != end && *str == '-')
    {
1327
      interval->neg=1;
unknown's avatar
unknown committed
1328 1329
      str++;
    }
1330
    length= (size_t) (end-str);		// Set up pointers to new str
unknown's avatar
unknown committed
1331 1332 1333 1334
  }

  switch (int_type) {
  case INTERVAL_YEAR:
unknown's avatar
unknown committed
1335
    interval->year= (ulong) value;
unknown's avatar
unknown committed
1336
    break;
1337
  case INTERVAL_QUARTER:
1338
    interval->month= (ulong)(value*3);
1339
    break;
unknown's avatar
unknown committed
1340
  case INTERVAL_MONTH:
unknown's avatar
unknown committed
1341
    interval->month= (ulong) value;
unknown's avatar
unknown committed
1342
    break;
1343
  case INTERVAL_WEEK:
1344
    interval->day= (ulong)(value*7);
1345
    break;
unknown's avatar
unknown committed
1346
  case INTERVAL_DAY:
unknown's avatar
unknown committed
1347
    interval->day= (ulong) value;
unknown's avatar
unknown committed
1348 1349
    break;
  case INTERVAL_HOUR:
unknown's avatar
unknown committed
1350
    interval->hour= (ulong) value;
unknown's avatar
unknown committed
1351
    break;
unknown's avatar
unknown committed
1352
  case INTERVAL_MICROSECOND:
1353
    interval->second_part=value;
unknown's avatar
unknown committed
1354
    break;
unknown's avatar
unknown committed
1355
  case INTERVAL_MINUTE:
1356
    interval->minute=value;
unknown's avatar
unknown committed
1357 1358
    break;
  case INTERVAL_SECOND:
1359
    interval->second=value;
unknown's avatar
unknown committed
1360 1361
    break;
  case INTERVAL_YEAR_MONTH:			// Allow YEAR-MONTH YYYYYMM
1362
    if (get_interval_info(str,length,cs,2,array,0))
unknown's avatar
unknown committed
1363
      return (1);
unknown's avatar
unknown committed
1364 1365
    interval->year=  (ulong) array[0];
    interval->month= (ulong) array[1];
unknown's avatar
unknown committed
1366 1367
    break;
  case INTERVAL_DAY_HOUR:
1368
    if (get_interval_info(str,length,cs,2,array,0))
unknown's avatar
unknown committed
1369
      return (1);
unknown's avatar
unknown committed
1370 1371
    interval->day=  (ulong) array[0];
    interval->hour= (ulong) array[1];
unknown's avatar
unknown committed
1372
    break;
unknown's avatar
unknown committed
1373
  case INTERVAL_DAY_MICROSECOND:
1374
    if (get_interval_info(str,length,cs,5,array,1))
unknown's avatar
unknown committed
1375
      return (1);
unknown's avatar
unknown committed
1376 1377 1378 1379 1380
    interval->day=    (ulong) array[0];
    interval->hour=   (ulong) array[1];
    interval->minute= array[2];
    interval->second= array[3];
    interval->second_part= array[4];
unknown's avatar
unknown committed
1381
    break;
unknown's avatar
unknown committed
1382
  case INTERVAL_DAY_MINUTE:
1383
    if (get_interval_info(str,length,cs,3,array,0))
unknown's avatar
unknown committed
1384
      return (1);
unknown's avatar
unknown committed
1385 1386 1387
    interval->day=    (ulong) array[0];
    interval->hour=   (ulong) array[1];
    interval->minute= array[2];
unknown's avatar
unknown committed
1388 1389
    break;
  case INTERVAL_DAY_SECOND:
1390
    if (get_interval_info(str,length,cs,4,array,0))
unknown's avatar
unknown committed
1391
      return (1);
unknown's avatar
unknown committed
1392 1393 1394 1395
    interval->day=    (ulong) array[0];
    interval->hour=   (ulong) array[1];
    interval->minute= array[2];
    interval->second= array[3];
unknown's avatar
unknown committed
1396
    break;
unknown's avatar
unknown committed
1397
  case INTERVAL_HOUR_MICROSECOND:
1398
    if (get_interval_info(str,length,cs,4,array,1))
unknown's avatar
unknown committed
1399
      return (1);
unknown's avatar
unknown committed
1400 1401 1402 1403
    interval->hour=   (ulong) array[0];
    interval->minute= array[1];
    interval->second= array[2];
    interval->second_part= array[3];
unknown's avatar
unknown committed
1404
    break;
unknown's avatar
unknown committed
1405
  case INTERVAL_HOUR_MINUTE:
1406
    if (get_interval_info(str,length,cs,2,array,0))
unknown's avatar
unknown committed
1407
      return (1);
unknown's avatar
unknown committed
1408 1409
    interval->hour=   (ulong) array[0];
    interval->minute= array[1];
unknown's avatar
unknown committed
1410 1411
    break;
  case INTERVAL_HOUR_SECOND:
1412
    if (get_interval_info(str,length,cs,3,array,0))
unknown's avatar
unknown committed
1413
      return (1);
unknown's avatar
unknown committed
1414 1415 1416
    interval->hour=   (ulong) array[0];
    interval->minute= array[1];
    interval->second= array[2];
unknown's avatar
unknown committed
1417
    break;
unknown's avatar
unknown committed
1418
  case INTERVAL_MINUTE_MICROSECOND:
1419
    if (get_interval_info(str,length,cs,3,array,1))
unknown's avatar
unknown committed
1420
      return (1);
unknown's avatar
unknown committed
1421 1422 1423
    interval->minute= array[0];
    interval->second= array[1];
    interval->second_part= array[2];
unknown's avatar
unknown committed
1424
    break;
unknown's avatar
unknown committed
1425
  case INTERVAL_MINUTE_SECOND:
1426
    if (get_interval_info(str,length,cs,2,array,0))
unknown's avatar
unknown committed
1427
      return (1);
unknown's avatar
unknown committed
1428 1429
    interval->minute= array[0];
    interval->second= array[1];
unknown's avatar
unknown committed
1430
    break;
unknown's avatar
unknown committed
1431
  case INTERVAL_SECOND_MICROSECOND:
1432
    if (get_interval_info(str,length,cs,2,array,1))
unknown's avatar
unknown committed
1433
      return (1);
unknown's avatar
unknown committed
1434 1435
    interval->second= array[0];
    interval->second_part= array[1];
unknown's avatar
unknown committed
1436
    break;
1437 1438 1439
  case INTERVAL_LAST: /* purecov: begin deadcode */
    DBUG_ASSERT(0); 
    break;            /* purecov: end */
unknown's avatar
unknown committed
1440 1441 1442 1443 1444 1445 1446
  }
  return 0;
}


String *Item_date::val_str(String *str)
{
1447
  DBUG_ASSERT(fixed == 1);
1448
  MYSQL_TIME ltime;
1449 1450
  if (get_date(&ltime, TIME_FUZZY_DATE))
    return (String *) 0;
1451
  if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
1452 1453 1454 1455 1456 1457
  {
    null_value= 1;
    return (String *) 0;
  }
  make_date((DATE_TIME_FORMAT *) 0, &ltime, str);
  return str;
unknown's avatar
unknown committed
1458 1459 1460
}


1461 1462
longlong Item_date::val_int()
{
1463
  DBUG_ASSERT(fixed == 1);
1464
  MYSQL_TIME ltime;
1465 1466 1467 1468 1469 1470
  if (get_date(&ltime, TIME_FUZZY_DATE))
    return 0;
  return (longlong) (ltime.year*10000L+ltime.month*100+ltime.day);
}


1471
bool Item_func_from_days::get_date(MYSQL_TIME *ltime, uint fuzzy_date)
unknown's avatar
unknown committed
1472 1473 1474
{
  longlong value=args[0]->val_int();
  if ((null_value=args[0]->null_value))
1475
    return 1;
1476
  bzero(ltime, sizeof(MYSQL_TIME));
1477
  get_date_from_daynr((long) value, &ltime->year, &ltime->month, &ltime->day);
1478
  ltime->time_type= MYSQL_TIMESTAMP_DATE;
1479
  return 0;
unknown's avatar
unknown committed
1480 1481 1482 1483 1484
}


void Item_func_curdate::fix_length_and_dec()
{
1485
  collation.set(&my_charset_bin);
1486
  decimals=0; 
1487
  max_length=MAX_DATE_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
1488

1489
  store_now_in_TIME(&ltime);
1490
  
1491 1492
  /* We don't need to set second_part and neg because they already 0 */
  ltime.hour= ltime.minute= ltime.second= 0;
1493
  ltime.time_type= MYSQL_TIMESTAMP_DATE;
1494
  value= (longlong) TIME_to_ulonglong_date(&ltime);
unknown's avatar
unknown committed
1495 1496
}

1497 1498
String *Item_func_curdate::val_str(String *str)
{
1499
  DBUG_ASSERT(fixed == 1);
1500
  if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
1501 1502 1503 1504 1505 1506 1507
  {
    null_value= 1;
    return (String *) 0;
  }
  make_date((DATE_TIME_FORMAT *) 0, &ltime, str);
  return str;
}
1508

1509
/*
1510
    Converts current time in my_time_t to MYSQL_TIME represenatation for local
1511 1512
    time zone. Defines time zone (local) used for whole CURDATE function.
*/
1513
void Item_func_curdate_local::store_now_in_TIME(MYSQL_TIME *now_time)
unknown's avatar
unknown committed
1514
{
1515 1516 1517 1518
  THD *thd= current_thd;
  thd->variables.time_zone->gmt_sec_to_TIME(now_time, 
                                             (my_time_t)thd->query_start());
  thd->time_zone_used= 1;
unknown's avatar
unknown committed
1519 1520
}

1521 1522

/*
1523
    Converts current time in my_time_t to MYSQL_TIME represenatation for UTC
1524
    time zone. Defines time zone (UTC) used for whole UTC_DATE function.
1525
*/
1526
void Item_func_curdate_utc::store_now_in_TIME(MYSQL_TIME *now_time)
1527
{
1528 1529 1530 1531 1532 1533
  my_tz_UTC->gmt_sec_to_TIME(now_time, 
                             (my_time_t)(current_thd->query_start()));
  /* 
    We are not flagging this query as using time zone, since it uses fixed
    UTC-SYSTEM time-zone.
  */
1534 1535 1536
}


1537
bool Item_func_curdate::get_date(MYSQL_TIME *res,
1538
				 uint fuzzy_date __attribute__((unused)))
1539
{
1540 1541
  *res=ltime;
  return 0;
1542 1543 1544
}


1545
String *Item_func_curtime::val_str(String *str)
1546 1547
{
  DBUG_ASSERT(fixed == 1);
1548
  str_value.set(buff, buff_length, &my_charset_bin);
1549 1550 1551
  return &str_value;
}

1552

unknown's avatar
unknown committed
1553 1554
void Item_func_curtime::fix_length_and_dec()
{
1555
  MYSQL_TIME ltime;
1556

1557
  decimals= DATETIME_DEC;
1558 1559
  collation.set(&my_charset_bin);
  store_now_in_TIME(&ltime);
1560
  value= TIME_to_ulonglong_time(&ltime);
1561 1562
  buff_length= (uint) my_time_to_str(&ltime, buff);
  max_length= buff_length;
1563 1564 1565 1566
}


/*
1567
    Converts current time in my_time_t to MYSQL_TIME represenatation for local
1568
    time zone. Defines time zone (local) used for whole CURTIME function.
1569
*/
1570
void Item_func_curtime_local::store_now_in_TIME(MYSQL_TIME *now_time)
1571
{
1572 1573 1574 1575
  THD *thd= current_thd;
  thd->variables.time_zone->gmt_sec_to_TIME(now_time, 
                                             (my_time_t)thd->query_start());
  thd->time_zone_used= 1;
1576 1577 1578 1579
}


/*
1580
    Converts current time in my_time_t to MYSQL_TIME represenatation for UTC
1581
    time zone. Defines time zone (UTC) used for whole UTC_TIME function.
1582
*/
1583
void Item_func_curtime_utc::store_now_in_TIME(MYSQL_TIME *now_time)
1584
{
1585 1586 1587 1588 1589 1590
  my_tz_UTC->gmt_sec_to_TIME(now_time, 
                             (my_time_t)(current_thd->query_start()));
  /* 
    We are not flagging this query as using time zone, since it uses fixed
    UTC-SYSTEM time-zone.
  */
1591 1592
}

1593

1594 1595
String *Item_func_now::val_str(String *str)
{
1596
  DBUG_ASSERT(fixed == 1);
1597
  str_value.set(buff,buff_length, &my_charset_bin);
1598
  return &str_value;
unknown's avatar
unknown committed
1599 1600
}

1601

unknown's avatar
unknown committed
1602 1603
void Item_func_now::fix_length_and_dec()
{
1604
  decimals= DATETIME_DEC;
1605 1606
  collation.set(&my_charset_bin);

1607
  store_now_in_TIME(&ltime);
1608
  value= (longlong) TIME_to_ulonglong_datetime(&ltime);
1609

1610 1611
  buff_length= (uint) my_datetime_to_str(&ltime, buff);
  max_length= buff_length;
unknown's avatar
unknown committed
1612 1613
}

1614

1615
/*
1616
    Converts current time in my_time_t to MYSQL_TIME represenatation for local
1617 1618
    time zone. Defines time zone (local) used for whole NOW function.
*/
1619
void Item_func_now_local::store_now_in_TIME(MYSQL_TIME *now_time)
unknown's avatar
unknown committed
1620
{
1621 1622 1623 1624
  THD *thd= current_thd;
  thd->variables.time_zone->gmt_sec_to_TIME(now_time, 
                                             (my_time_t)thd->query_start());
  thd->time_zone_used= 1;
unknown's avatar
unknown committed
1625 1626 1627
}


1628
/*
1629
    Converts current time in my_time_t to MYSQL_TIME represenatation for UTC
1630 1631
    time zone. Defines time zone (UTC) used for whole UTC_TIMESTAMP function.
*/
1632
void Item_func_now_utc::store_now_in_TIME(MYSQL_TIME *now_time)
unknown's avatar
unknown committed
1633
{
1634 1635 1636 1637 1638 1639
  my_tz_UTC->gmt_sec_to_TIME(now_time, 
                             (my_time_t)(current_thd->query_start()));
  /* 
    We are not flagging this query as using time zone, since it uses fixed
    UTC-SYSTEM time-zone.
  */
unknown's avatar
unknown committed
1640 1641 1642
}


1643
bool Item_func_now::get_date(MYSQL_TIME *res,
1644
                             uint fuzzy_date __attribute__((unused)))
1645
{
1646
  *res= ltime;
1647
  return 0;
1648 1649 1650
}


1651
int Item_func_now::save_in_field(Field *to, bool no_conversions)
1652
{
1653
  to->set_notnull();
1654
  to->store_time(&ltime, MYSQL_TIMESTAMP_DATETIME);
1655
  return 0;
1656 1657 1658
}


1659
/*
1660
    Converts current time in my_time_t to MYSQL_TIME represenatation for local
1661 1662
    time zone. Defines time zone (local) used for whole SYSDATE function.
*/
1663
void Item_func_sysdate_local::store_now_in_TIME(MYSQL_TIME *now_time)
1664 1665
{
  THD *thd= current_thd;
1666
  thd->variables.time_zone->gmt_sec_to_TIME(now_time, (my_time_t) my_time(0));
1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692
  thd->time_zone_used= 1;
}


String *Item_func_sysdate_local::val_str(String *str)
{
  DBUG_ASSERT(fixed == 1);
  store_now_in_TIME(&ltime);
  buff_length= (uint) my_datetime_to_str(&ltime, buff);
  str_value.set(buff, buff_length, &my_charset_bin);
  return &str_value;
}


longlong Item_func_sysdate_local::val_int()
{
  DBUG_ASSERT(fixed == 1);
  store_now_in_TIME(&ltime);
  return (longlong) TIME_to_ulonglong_datetime(&ltime);
}


double Item_func_sysdate_local::val_real()
{
  DBUG_ASSERT(fixed == 1);
  store_now_in_TIME(&ltime);
1693
  return ulonglong2double(TIME_to_ulonglong_datetime(&ltime));
1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704
}


void Item_func_sysdate_local::fix_length_and_dec()
{
  decimals= 0;
  collation.set(&my_charset_bin);
  max_length= MAX_DATETIME_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
}


1705
bool Item_func_sysdate_local::get_date(MYSQL_TIME *res,
1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722
                                       uint fuzzy_date __attribute__((unused)))
{
  store_now_in_TIME(&ltime);
  *res= ltime;
  return 0;
}


int Item_func_sysdate_local::save_in_field(Field *to, bool no_conversions)
{
  store_now_in_TIME(&ltime);
  to->set_notnull();
  to->store_time(&ltime, MYSQL_TIMESTAMP_DATETIME);
  return 0;
}


unknown's avatar
unknown committed
1723 1724
String *Item_func_sec_to_time::val_str(String *str)
{
1725
  DBUG_ASSERT(fixed == 1);
1726
  MYSQL_TIME ltime;
1727
  longlong arg_val= args[0]->val_int(); 
1728

1729 1730
  if ((null_value=args[0]->null_value) ||
      str->alloc(MAX_DATE_STRING_REP_LENGTH))
1731 1732 1733 1734
  {
    null_value= 1;
    return (String*) 0;
  }
1735

1736
  sec_to_time(arg_val, args[0]->unsigned_flag, &ltime);
1737
  
1738 1739
  make_time((DATE_TIME_FORMAT *) 0, &ltime, str);
  return str;
unknown's avatar
unknown committed
1740 1741 1742 1743 1744
}


longlong Item_func_sec_to_time::val_int()
{
1745
  DBUG_ASSERT(fixed == 1);
1746
  MYSQL_TIME ltime;
1747
  longlong arg_val= args[0]->val_int(); 
1748
  
unknown's avatar
unknown committed
1749 1750
  if ((null_value=args[0]->null_value))
    return 0;
1751

1752
  sec_to_time(arg_val, args[0]->unsigned_flag, &ltime);
1753 1754 1755

  return (ltime.neg ? -1 : 1) *
    ((ltime.hour)*10000 + ltime.minute*100 + ltime.second);
unknown's avatar
unknown committed
1756 1757 1758 1759 1760
}


void Item_func_date_format::fix_length_and_dec()
{
1761
  THD* thd= current_thd;
1762 1763 1764 1765 1766 1767
  /*
    Must use this_item() in case it's a local SP variable
    (for ->max_length and ->str_value)
  */
  Item *arg1= args[1]->this_item();

unknown's avatar
unknown committed
1768
  decimals=0;
1769 1770 1771 1772 1773
  CHARSET_INFO *cs= thd->variables.collation_connection;
  uint32 repertoire= arg1->collation.repertoire;
  if (!thd->variables.lc_time_names->is_ascii)
    repertoire|= MY_REPERTOIRE_EXTENDED;
  collation.set(cs, arg1->collation.derivation, repertoire);
1774
  if (arg1->type() == STRING_ITEM)
unknown's avatar
unknown committed
1775 1776
  {						// Optimize the normal case
    fixed_length=1;
1777
    max_length= format_length(&arg1->str_value) *
1778
                collation.collation->mbmaxlen;
unknown's avatar
unknown committed
1779 1780 1781 1782
  }
  else
  {
    fixed_length=0;
1783 1784
    max_length=min(arg1->max_length, MAX_BLOB_WIDTH) * 10 *
                   collation.collation->mbmaxlen;
unknown's avatar
unknown committed
1785 1786 1787 1788 1789 1790
    set_if_smaller(max_length,MAX_BLOB_WIDTH);
  }
  maybe_null=1;					// If wrong date
}


unknown's avatar
unknown committed
1791 1792 1793
bool Item_func_date_format::eq(const Item *item, bool binary_cmp) const
{
  Item_func_date_format *item_func;
1794

unknown's avatar
unknown committed
1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
  if (item->type() != FUNC_ITEM)
    return 0;
  if (func_name() != ((Item_func*) item)->func_name())
    return 0;
  if (this == item)
    return 1;
  item_func= (Item_func_date_format*) item;
  if (!args[0]->eq(item_func->args[0], binary_cmp))
    return 0;
  /*
    We must compare format string case sensitive.
    This needed because format modifiers with different case,
    for example %m and %M, have different meaning.
  */
  if (!args[1]->eq(item_func->args[1], 1))
    return 0;
  return 1;
}



unknown's avatar
unknown committed
1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830
uint Item_func_date_format::format_length(const String *format)
{
  uint size=0;
  const char *ptr=format->ptr();
  const char *end=ptr+format->length();

  for (; ptr != end ; ptr++)
  {
    if (*ptr != '%' || ptr == end-1)
      size++;
    else
    {
      switch(*++ptr) {
      case 'M': /* month, textual */
      case 'W': /* day (of the week), textual */
unknown's avatar
unknown committed
1831
	size += 64; /* large for UTF8 locale data */
unknown's avatar
unknown committed
1832 1833 1834 1835 1836 1837 1838 1839 1840
	break;
      case 'D': /* day (of the month), numeric plus english suffix */
      case 'Y': /* year, numeric, 4 digits */
      case 'x': /* Year, used with 'v' */
      case 'X': /* Year, used with 'v, where week starts with Monday' */
	size += 4;
	break;
      case 'a': /* locale's abbreviated weekday name (Sun..Sat) */
      case 'b': /* locale's abbreviated month name (Jan.Dec) */
unknown's avatar
unknown committed
1841 1842
	size += 32; /* large for UTF8 locale data */
	break;
unknown's avatar
unknown committed
1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
      case 'j': /* day of year (001..366) */
	size += 3;
	break;
      case 'U': /* week (00..52) */
      case 'u': /* week (00..52), where week starts with Monday */
      case 'V': /* week 1..53 used with 'x' */
      case 'v': /* week 1..53 used with 'x', where week starts with Monday */
      case 'y': /* year, numeric, 2 digits */
      case 'm': /* month, numeric */
      case 'd': /* day (of the month), numeric */
      case 'h': /* hour (01..12) */
      case 'I': /* --||-- */
      case 'i': /* minutes, numeric */
      case 'l': /* hour ( 1..12) */
      case 'p': /* locale's AM or PM */
      case 'S': /* second (00..61) */
      case 's': /* seconds, numeric */
      case 'c': /* month (0..12) */
      case 'e': /* day (0..31) */
	size += 2;
	break;
1864 1865 1866 1867
      case 'k': /* hour ( 0..23) */
      case 'H': /* hour (00..23; value > 23 OK, padding always 2-digit) */
	size += 7; /* docs allow > 23, range depends on sizeof(unsigned int) */
	break;
unknown's avatar
unknown committed
1868 1869 1870 1871 1872 1873
      case 'r': /* time, 12-hour (hh:mm:ss [AP]M) */
	size += 11;
	break;
      case 'T': /* time, 24-hour (hh:mm:ss) */
	size += 8;
	break;
unknown's avatar
unknown committed
1874 1875 1876
      case 'f': /* microseconds */
	size += 6;
	break;
unknown's avatar
unknown committed
1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891
      case 'w': /* day (of the week), numeric */
      case '%':
      default:
	size++;
	break;
      }
    }
  }
  return size;
}


String *Item_func_date_format::val_str(String *str)
{
  String *format;
1892
  MYSQL_TIME l_time;
1893
  uint size;
1894
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1895

1896
  if (!is_time_format)
unknown's avatar
unknown committed
1897
  {
unknown's avatar
unknown committed
1898
    if (get_arg0_date(&l_time, TIME_FUZZY_DATE))
unknown's avatar
unknown committed
1899 1900 1901 1902 1903
      return 0;
  }
  else
  {
    String *res;
1904
    if (!(res=args[0]->val_str(str)) ||
1905
	(str_to_time_with_warn(res->ptr(), res->length(), &l_time)))
1906 1907
      goto null_date;

unknown's avatar
unknown committed
1908 1909 1910 1911 1912
    l_time.year=l_time.month=l_time.day=0;
    null_value=0;
  }

  if (!(format = args[1]->val_str(str)) || !format->length())
1913
    goto null_date;
unknown's avatar
unknown committed
1914 1915 1916 1917 1918

  if (fixed_length)
    size=max_length;
  else
    size=format_length(format);
1919 1920 1921 1922

  if (size < MAX_DATE_STRING_REP_LENGTH)
    size= MAX_DATE_STRING_REP_LENGTH;

unknown's avatar
unknown committed
1923
  if (format == str)
unknown's avatar
merge  
unknown committed
1924
    str= &value;				// Save result here
unknown's avatar
unknown committed
1925
  if (str->alloc(size))
1926 1927
    goto null_date;

1928 1929 1930
  DATE_TIME_FORMAT date_time_format;
  date_time_format.format.str=    (char*) format->ptr();
  date_time_format.format.length= format->length(); 
unknown's avatar
unknown committed
1931 1932

  /* Create the result string */
1933
  str->set_charset(collation.collation);
1934
  if (!make_date_time(&date_time_format, &l_time,
1935 1936 1937
                      is_time_format ? MYSQL_TIMESTAMP_TIME :
                                       MYSQL_TIMESTAMP_DATE,
                      str))
1938
    return str;
unknown's avatar
unknown committed
1939

1940 1941 1942
null_date:
  null_value=1;
  return 0;
unknown's avatar
unknown committed
1943 1944 1945
}


1946 1947 1948 1949
void Item_func_from_unixtime::fix_length_and_dec()
{ 
  thd= current_thd;
  collation.set(&my_charset_bin);
1950
  decimals= DATETIME_DEC;
1951
  max_length=MAX_DATETIME_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
1952
  maybe_null= 1;
1953 1954 1955 1956
  thd->time_zone_used= 1;
}


unknown's avatar
unknown committed
1957 1958
String *Item_func_from_unixtime::val_str(String *str)
{
1959
  MYSQL_TIME time_tmp;
1960

1961
  DBUG_ASSERT(fixed == 1);
1962 1963

  if (get_date(&time_tmp, 0))
unknown's avatar
unknown committed
1964
    return 0;
1965

1966
  if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
1967 1968 1969 1970 1971
  {
    null_value= 1;
    return 0;
  }

1972
  make_datetime((DATE_TIME_FORMAT *) 0, &time_tmp, str);
1973

1974
  return str;
unknown's avatar
unknown committed
1975 1976 1977 1978 1979
}


longlong Item_func_from_unixtime::val_int()
{
1980
  MYSQL_TIME time_tmp;
1981

1982
  DBUG_ASSERT(fixed == 1);
1983

1984
  if (get_date(&time_tmp, 0))
unknown's avatar
unknown committed
1985
    return 0;
1986

1987
  return (longlong) TIME_to_ulonglong_datetime(&time_tmp);
unknown's avatar
unknown committed
1988 1989
}

1990
bool Item_func_from_unixtime::get_date(MYSQL_TIME *ltime,
1991
				       uint fuzzy_date __attribute__((unused)))
unknown's avatar
unknown committed
1992
{
1993
  ulonglong tmp= (ulonglong)(args[0]->val_int());
1994
  /*
1995 1996
    "tmp > TIMESTAMP_MAX_VALUE" check also covers case of negative
    from_unixtime() argument since tmp is unsigned.
1997
  */
1998
  if ((null_value= (args[0]->null_value || tmp > TIMESTAMP_MAX_VALUE)))
unknown's avatar
unknown committed
1999
    return 1;
2000 2001

  thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)tmp);
2002 2003 2004 2005 2006 2007

  return 0;
}


void Item_func_convert_tz::fix_length_and_dec()
2008
{
2009 2010 2011
  collation.set(&my_charset_bin);
  decimals= 0;
  max_length= MAX_DATETIME_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
2012
  maybe_null= 1;
2013 2014 2015
}


2016 2017
String *Item_func_convert_tz::val_str(String *str)
{
2018
  MYSQL_TIME time_tmp;
2019 2020 2021

  if (get_date(&time_tmp, 0))
    return 0;
2022 2023

  if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
2024 2025 2026 2027
  {
    null_value= 1;
    return 0;
  }
2028

2029
  make_datetime((DATE_TIME_FORMAT *) 0, &time_tmp, str);
2030

2031 2032 2033 2034 2035 2036
  return str;
}


longlong Item_func_convert_tz::val_int()
{
2037
  MYSQL_TIME time_tmp;
2038 2039 2040 2041 2042 2043 2044 2045

  if (get_date(&time_tmp, 0))
    return 0;
  
  return (longlong)TIME_to_ulonglong_datetime(&time_tmp);
}


2046
bool Item_func_convert_tz::get_date(MYSQL_TIME *ltime,
unknown's avatar
unknown committed
2047
                                    uint fuzzy_date __attribute__((unused)))
2048 2049 2050
{
  my_time_t my_time_tmp;
  String str;
2051
  THD *thd= current_thd;
2052 2053 2054

  if (!from_tz_cached)
  {
2055
    from_tz= my_tz_find(thd, args[1]->val_str(&str));
2056 2057 2058 2059 2060
    from_tz_cached= args[1]->const_item();
  }

  if (!to_tz_cached)
  {
2061
    to_tz= my_tz_find(thd, args[2]->val_str(&str));
2062 2063 2064
    to_tz_cached= args[2]->const_item();
  }

unknown's avatar
unknown committed
2065
  if (from_tz==0 || to_tz==0 || get_arg0_date(ltime, TIME_NO_ZERO_DATE))
2066 2067 2068 2069 2070 2071
  {
    null_value= 1;
    return 1;
  }

  {
2072
    my_bool not_used;
2073
    my_time_tmp= from_tz->TIME_to_gmt_sec(ltime, &not_used);
2074 2075
    /* my_time_tmp is guranteed to be in the allowed range */
    if (my_time_tmp)
2076 2077
      to_tz->gmt_sec_to_TIME(ltime, my_time_tmp);
  }
2078

2079
  null_value= 0;
unknown's avatar
unknown committed
2080 2081 2082
  return 0;
}

2083

2084 2085 2086 2087 2088 2089 2090
void Item_func_convert_tz::cleanup()
{
  from_tz_cached= to_tz_cached= 0;
  Item_date_func::cleanup();
}


2091 2092 2093
void Item_date_add_interval::fix_length_and_dec()
{
  enum_field_types arg0_field_type;
2094 2095

  collation.set(&my_charset_bin);
2096
  maybe_null=1;
2097 2098
  max_length=MAX_DATETIME_FULL_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
  value.alloc(max_length);
2099 2100 2101 2102 2103 2104 2105 2106 2107

  /*
    The field type for the result of an Item_date function is defined as
    follows:

    - If first arg is a MYSQL_TYPE_DATETIME result is MYSQL_TYPE_DATETIME
    - If first arg is a MYSQL_TYPE_DATE and the interval type uses hours,
      minutes or seconds then type is MYSQL_TYPE_DATETIME.
    - Otherwise the result is MYSQL_TYPE_STRING
2108
      (This is because you can't know if the string contains a DATE, MYSQL_TIME or
2109 2110 2111 2112 2113 2114 2115 2116 2117
      DATETIME argument)
  */
  cached_field_type= MYSQL_TYPE_STRING;
  arg0_field_type= args[0]->field_type();
  if (arg0_field_type == MYSQL_TYPE_DATETIME ||
      arg0_field_type == MYSQL_TYPE_TIMESTAMP)
    cached_field_type= MYSQL_TYPE_DATETIME;
  else if (arg0_field_type == MYSQL_TYPE_DATE)
  {
unknown's avatar
unknown committed
2118
    if (int_type <= INTERVAL_DAY || int_type == INTERVAL_YEAR_MONTH)
2119 2120 2121 2122 2123 2124 2125 2126
      cached_field_type= arg0_field_type;
    else
      cached_field_type= MYSQL_TYPE_DATETIME;
  }
}


/* Here arg[1] is a Item_interval object */
unknown's avatar
unknown committed
2127

2128
bool Item_date_add_interval::get_date(MYSQL_TIME *ltime, uint fuzzy_date)
unknown's avatar
unknown committed
2129 2130
{
  INTERVAL interval;
2131

unknown's avatar
unknown committed
2132
  if (args[0]->get_date(ltime, TIME_NO_ZERO_DATE) ||
2133 2134
      get_interval_value(args[1], int_type, &value, &interval))
    return (null_value=1);
2135

unknown's avatar
unknown committed
2136
  if (date_sub_interval)
2137
    interval.neg = !interval.neg;
2138

unknown's avatar
unknown committed
2139 2140 2141
  if ((null_value= date_add_interval(ltime, int_type, interval)))
    return 1;
  return 0;
unknown's avatar
unknown committed
2142 2143 2144 2145 2146
}


String *Item_date_add_interval::val_str(String *str)
{
2147
  DBUG_ASSERT(fixed == 1);
2148
  MYSQL_TIME ltime;
2149
  enum date_time_format_types format;
unknown's avatar
unknown committed
2150

unknown's avatar
unknown committed
2151
  if (Item_date_add_interval::get_date(&ltime, TIME_NO_ZERO_DATE))
unknown's avatar
unknown committed
2152
    return 0;
unknown's avatar
unknown committed
2153

2154
  if (ltime.time_type == MYSQL_TIMESTAMP_DATE)
2155 2156 2157 2158 2159 2160 2161
    format= DATE_ONLY;
  else if (ltime.second_part)
    format= DATE_TIME_MICROSECOND;
  else
    format= DATE_TIME;

  if (!make_datetime(format, &ltime, str))
unknown's avatar
unknown committed
2162
    return str;
unknown's avatar
unknown committed
2163 2164 2165 2166 2167

  null_value=1;
  return 0;
}

2168

unknown's avatar
unknown committed
2169 2170
longlong Item_date_add_interval::val_int()
{
2171
  DBUG_ASSERT(fixed == 1);
2172
  MYSQL_TIME ltime;
2173
  longlong date;
unknown's avatar
unknown committed
2174
  if (Item_date_add_interval::get_date(&ltime, TIME_NO_ZERO_DATE))
unknown's avatar
unknown committed
2175
    return (longlong) 0;
2176
  date = (ltime.year*100L + ltime.month)*100L + ltime.day;
2177
  return ltime.time_type == MYSQL_TIMESTAMP_DATE ? date :
2178
    ((date*100L + ltime.hour)*100L+ ltime.minute)*100L + ltime.second;
unknown's avatar
unknown committed
2179 2180
}

2181 2182 2183 2184 2185


bool Item_date_add_interval::eq(const Item *item, bool binary_cmp) const
{
  Item_date_add_interval *other= (Item_date_add_interval*) item;
2186 2187 2188 2189
  if (!Item_func::eq(item, binary_cmp))
    return 0;
  return ((int_type == other->int_type) &&
          (date_sub_interval == other->date_sub_interval));
2190 2191
}

2192 2193 2194 2195
/*
   'interval_names' reflects the order of the enumeration interval_type.
   See item_timefunc.h
 */
2196

2197 2198
static const char *interval_names[]=
{
2199 2200
  "year", "quarter", "month", "week", "day",  
  "hour", "minute", "second", "microsecond",
unknown's avatar
unknown committed
2201 2202 2203 2204 2205
  "year_month", "day_hour", "day_minute", 
  "day_second", "hour_minute", "hour_second",
  "minute_second", "day_microsecond",
  "hour_microsecond", "minute_microsecond",
  "second_microsecond"
2206 2207 2208 2209 2210 2211 2212 2213
};

void Item_date_add_interval::print(String *str)
{
  str->append('(');
  args[0]->print(str);
  str->append(date_sub_interval?" - interval ":" + interval ");
  args[1]->print(str);
2214
  str->append(' ');
2215 2216 2217 2218 2219 2220
  str->append(interval_names[int_type]);
  str->append(')');
}

void Item_extract::print(String *str)
{
2221
  str->append(STRING_WITH_LEN("extract("));
2222
  str->append(interval_names[int_type]);
2223
  str->append(STRING_WITH_LEN(" from "));
2224 2225 2226 2227
  args[0]->print(str);
  str->append(')');
}

unknown's avatar
unknown committed
2228 2229 2230 2231 2232 2233 2234 2235
void Item_extract::fix_length_and_dec()
{
  value.alloc(32);				// alloc buffer

  maybe_null=1;					// If wrong date
  switch (int_type) {
  case INTERVAL_YEAR:		max_length=4; date_value=1; break;
  case INTERVAL_YEAR_MONTH:	max_length=6; date_value=1; break;
2236
  case INTERVAL_QUARTER:        max_length=2; date_value=1; break;
unknown's avatar
unknown committed
2237
  case INTERVAL_MONTH:		max_length=2; date_value=1; break;
2238
  case INTERVAL_WEEK:		max_length=2; date_value=1; break;
unknown's avatar
unknown committed
2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
  case INTERVAL_DAY:		max_length=2; date_value=1; break;
  case INTERVAL_DAY_HOUR:	max_length=9; date_value=0; break;
  case INTERVAL_DAY_MINUTE:	max_length=11; date_value=0; break;
  case INTERVAL_DAY_SECOND:	max_length=13; date_value=0; break;
  case INTERVAL_HOUR:		max_length=2; date_value=0; break;
  case INTERVAL_HOUR_MINUTE:	max_length=4; date_value=0; break;
  case INTERVAL_HOUR_SECOND:	max_length=6; date_value=0; break;
  case INTERVAL_MINUTE:		max_length=2; date_value=0; break;
  case INTERVAL_MINUTE_SECOND:	max_length=4; date_value=0; break;
  case INTERVAL_SECOND:		max_length=2; date_value=0; break;
unknown's avatar
unknown committed
2249 2250 2251 2252 2253
  case INTERVAL_MICROSECOND:	max_length=2; date_value=0; break;
  case INTERVAL_DAY_MICROSECOND: max_length=20; date_value=0; break;
  case INTERVAL_HOUR_MICROSECOND: max_length=13; date_value=0; break;
  case INTERVAL_MINUTE_MICROSECOND: max_length=11; date_value=0; break;
  case INTERVAL_SECOND_MICROSECOND: max_length=9; date_value=0; break;
2254
  case INTERVAL_LAST: DBUG_ASSERT(0); break; /* purecov: deadcode */
unknown's avatar
unknown committed
2255 2256 2257 2258 2259 2260
  }
}


longlong Item_extract::val_int()
{
2261
  DBUG_ASSERT(fixed == 1);
2262
  MYSQL_TIME ltime;
2263 2264
  uint year;
  ulong week_format;
unknown's avatar
unknown committed
2265 2266 2267
  long neg;
  if (date_value)
  {
unknown's avatar
unknown committed
2268
    if (get_arg0_date(&ltime, TIME_FUZZY_DATE))
unknown's avatar
unknown committed
2269 2270 2271 2272 2273 2274
      return 0;
    neg=1;
  }
  else
  {
    String *res= args[0]->val_str(&value);
2275
    if (!res || str_to_time_with_warn(res->ptr(), res->length(), &ltime))
unknown's avatar
unknown committed
2276 2277 2278 2279 2280 2281 2282 2283 2284 2285
    {
      null_value=1;
      return 0;
    }
    neg= ltime.neg ? -1 : 1;
    null_value=0;
  }
  switch (int_type) {
  case INTERVAL_YEAR:		return ltime.year;
  case INTERVAL_YEAR_MONTH:	return ltime.year*100L+ltime.month;
2286
  case INTERVAL_QUARTER:	return (ltime.month+2)/3;
unknown's avatar
unknown committed
2287
  case INTERVAL_MONTH:		return ltime.month;
2288 2289 2290
  case INTERVAL_WEEK:
  {
    week_format= current_thd->variables.default_week_format;
unknown's avatar
unknown committed
2291
    return calc_week(&ltime, week_mode(week_format), &year);
2292
  }
unknown's avatar
unknown committed
2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308
  case INTERVAL_DAY:		return ltime.day;
  case INTERVAL_DAY_HOUR:	return (long) (ltime.day*100L+ltime.hour)*neg;
  case INTERVAL_DAY_MINUTE:	return (long) (ltime.day*10000L+
					       ltime.hour*100L+
					       ltime.minute)*neg;
  case INTERVAL_DAY_SECOND:	 return ((longlong) ltime.day*1000000L+
					 (longlong) (ltime.hour*10000L+
						     ltime.minute*100+
						     ltime.second))*neg;
  case INTERVAL_HOUR:		return (long) ltime.hour*neg;
  case INTERVAL_HOUR_MINUTE:	return (long) (ltime.hour*100+ltime.minute)*neg;
  case INTERVAL_HOUR_SECOND:	return (long) (ltime.hour*10000+ltime.minute*100+
					       ltime.second)*neg;
  case INTERVAL_MINUTE:		return (long) ltime.minute*neg;
  case INTERVAL_MINUTE_SECOND:	return (long) (ltime.minute*100+ltime.second)*neg;
  case INTERVAL_SECOND:		return (long) ltime.second*neg;
unknown's avatar
unknown committed
2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323
  case INTERVAL_MICROSECOND:	return (long) ltime.second_part*neg;
  case INTERVAL_DAY_MICROSECOND: return (((longlong)ltime.day*1000000L +
					  (longlong)ltime.hour*10000L +
					  ltime.minute*100 +
					  ltime.second)*1000000L +
					 ltime.second_part)*neg;
  case INTERVAL_HOUR_MICROSECOND: return (((longlong)ltime.hour*10000L +
					   ltime.minute*100 +
					   ltime.second)*1000000L +
					  ltime.second_part)*neg;
  case INTERVAL_MINUTE_MICROSECOND: return (((longlong)(ltime.minute*100+
							ltime.second))*1000000L+
					    ltime.second_part)*neg;
  case INTERVAL_SECOND_MICROSECOND: return ((longlong)ltime.second*1000000L+
					    ltime.second_part)*neg;
2324
  case INTERVAL_LAST: DBUG_ASSERT(0); break;  /* purecov: deadcode */
unknown's avatar
unknown committed
2325 2326 2327
  }
  return 0;					// Impossible
}
unknown's avatar
unknown committed
2328

unknown's avatar
unknown committed
2329 2330 2331 2332 2333
bool Item_extract::eq(const Item *item, bool binary_cmp) const
{
  if (this == item)
    return 1;
  if (item->type() != FUNC_ITEM ||
2334
      functype() != ((Item_func*)item)->functype())
unknown's avatar
unknown committed
2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
    return 0;

  Item_extract* ie= (Item_extract*)item;
  if (ie->int_type != int_type)
    return 0;

  if (!args[0]->eq(ie->args[0], binary_cmp))
      return 0;
  return 1;
}
unknown's avatar
unknown committed
2345

unknown's avatar
unknown committed
2346

2347 2348 2349 2350 2351
bool Item_char_typecast::eq(const Item *item, bool binary_cmp) const
{
  if (this == item)
    return 1;
  if (item->type() != FUNC_ITEM ||
2352
      functype() != ((Item_func*)item)->functype())
2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363
    return 0;

  Item_char_typecast *cast= (Item_char_typecast*)item;
  if (cast_length != cast->cast_length ||
      cast_cs     != cast->cast_cs)
    return 0;

  if (!args[0]->eq(cast->args[0], binary_cmp))
      return 0;
  return 1;
}
unknown's avatar
unknown committed
2364

unknown's avatar
unknown committed
2365 2366
void Item_typecast::print(String *str)
{
2367
  str->append(STRING_WITH_LEN("cast("));
unknown's avatar
unknown committed
2368
  args[0]->print(str);
2369
  str->append(STRING_WITH_LEN(" as "));
2370 2371 2372 2373
  str->append(cast_type());
  str->append(')');
}

unknown's avatar
unknown committed
2374

2375 2376
void Item_char_typecast::print(String *str)
{
2377
  str->append(STRING_WITH_LEN("cast("));
2378
  args[0]->print(str);
2379
  str->append(STRING_WITH_LEN(" as char"));
2380 2381 2382
  if (cast_length >= 0)
  {
    str->append('(');
2383
    char buffer[20];
unknown's avatar
unknown committed
2384 2385 2386
    // my_charset_bin is good enough for numbers
    String st(buffer, sizeof(buffer), &my_charset_bin);
    st.set((ulonglong)cast_length, &my_charset_bin);
2387
    str->append(st);
2388 2389 2390 2391
    str->append(')');
  }
  if (cast_cs)
  {
2392
    str->append(STRING_WITH_LEN(" charset "));
2393
    str->append(cast_cs->csname);
2394
  }
unknown's avatar
unknown committed
2395 2396
  str->append(')');
}
unknown's avatar
unknown committed
2397

2398 2399
String *Item_char_typecast::val_str(String *str)
{
2400
  DBUG_ASSERT(fixed == 1);
2401
  String *res;
2402 2403
  uint32 length;

2404
  if (!charset_conversion)
2405
  {
2406 2407 2408 2409 2410
    if (!(res= args[0]->val_str(str)))
    {
      null_value= 1;
      return 0;
    }
2411 2412 2413 2414
  }
  else
  {
    // Convert character set if differ
2415
    uint dummy_errors;
2416
    if (!(res= args[0]->val_str(&tmp_value)) ||
2417 2418
        str->copy(res->ptr(), res->length(), from_cs,
        cast_cs, &dummy_errors))
2419 2420 2421 2422 2423 2424
    {
      null_value= 1;
      return 0;
    }
    res= str;
  }
2425 2426

  res->set_charset(cast_cs);
2427

2428
  /*
2429 2430 2431
    Cut the tail if cast with length
    and the result is longer than cast length, e.g.
    CAST('string' AS CHAR(1))
2432
  */
2433 2434 2435 2436 2437
  if (cast_length >= 0)
  {
    if (res->length() > (length= (uint32) res->charpos(cast_length)))
    {                                           // Safe even if const arg
      char char_type[40];
unknown's avatar
unknown committed
2438
      my_snprintf(char_type, sizeof(char_type), "%s(%lu)",
unknown's avatar
unknown committed
2439 2440
                  cast_cs == &my_charset_bin ? "BINARY" : "CHAR",
                  (ulong) length);
2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463

      if (!res->alloced_length())
      {                                         // Don't change const str
        str_value= *res;                        // Not malloced string
        res= &str_value;
      }
      push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                          ER_TRUNCATED_WRONG_VALUE,
                          ER(ER_TRUNCATED_WRONG_VALUE), char_type,
                          res->c_ptr_safe());
      res->length((uint) length);
    }
    else if (cast_cs == &my_charset_bin && res->length() < (uint) cast_length)
    {
      if (res->alloced_length() < (uint) cast_length)
      {
        str->alloc(cast_length);
        str->copy(*res);
        res= str;
      }
      bzero((char*) res->ptr() + res->length(),
            (uint) cast_length - res->length());
      res->length(cast_length);
2464
    }
2465
  }
2466 2467 2468 2469
  null_value= 0;
  return res;
}

2470

2471 2472 2473
void Item_char_typecast::fix_length_and_dec()
{
  uint32 char_length;
unknown's avatar
unknown committed
2474 2475 2476 2477 2478 2479 2480
  /* 
     We always force character set conversion if cast_cs
     is a multi-byte character set. It garantees that the
     result of CAST is a well-formed string.
     For single-byte character sets we allow just to copy
     from the argument. A single-byte character sets string
     is always well-formed. 
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494
     
     There is a special trick to convert form a number to ucs2.
     As numbers have my_charset_bin as their character set,
     it wouldn't do conversion to ucs2 without an additional action.
     To force conversion, we should pretend to be non-binary.
     Let's choose from_cs this way:
     - If the argument in a number and cast_cs is ucs2 (i.e. mbminlen > 1),
       then from_cs is set to latin1, to perform latin1 -> ucs2 conversion.
     - If the argument is a number and cast_cs is ASCII-compatible
       (i.e. mbminlen == 1), then from_cs is set to cast_cs,
       which allows just to take over the args[0]->val_str() result
       and thus avoid unnecessary character set conversion.
     - If the argument is not a number, then from_cs is set to
       the argument's charset.
unknown's avatar
unknown committed
2495
  */
2496
  from_cs= (args[0]->result_type() == INT_RESULT || 
unknown's avatar
unknown committed
2497
            args[0]->result_type() == DECIMAL_RESULT ||
2498 2499 2500
            args[0]->result_type() == REAL_RESULT) ?
           (cast_cs->mbminlen == 1 ? cast_cs : &my_charset_latin1) :
           args[0]->collation.collation;
unknown's avatar
unknown committed
2501
  charset_conversion= (cast_cs->mbmaxlen > 1) ||
2502 2503
                      !my_charset_same(from_cs, cast_cs) &&
                      from_cs != &my_charset_bin &&
unknown's avatar
unknown committed
2504
                      cast_cs != &my_charset_bin;
2505 2506
  collation.set(cast_cs, DERIVATION_IMPLICIT);
  char_length= (cast_length >= 0) ? cast_length : 
2507
	       args[0]->max_length/from_cs->mbmaxlen;
2508 2509 2510
  max_length= char_length * cast_cs->mbmaxlen;
}

2511

unknown's avatar
unknown committed
2512 2513
String *Item_datetime_typecast::val_str(String *str)
{
2514
  DBUG_ASSERT(fixed == 1);
2515
  MYSQL_TIME ltime;
2516

unknown's avatar
unknown committed
2517
  if (!get_arg0_date(&ltime, TIME_FUZZY_DATE) &&
2518 2519
      !make_datetime(ltime.second_part ? DATE_TIME_MICROSECOND : DATE_TIME, 
		     &ltime, str))
unknown's avatar
unknown committed
2520
    return str;
unknown's avatar
unknown committed
2521 2522 2523 2524 2525 2526

  null_value=1;
  return 0;
}


2527 2528 2529
longlong Item_datetime_typecast::val_int()
{
  DBUG_ASSERT(fixed == 1);
2530
  MYSQL_TIME ltime;
2531 2532 2533 2534 2535 2536 2537 2538 2539 2540
  if (get_arg0_date(&ltime,1))
  {
    null_value= 1;
    return 0;
  }

  return TIME_to_ulonglong_datetime(&ltime);
}


2541
bool Item_time_typecast::get_time(MYSQL_TIME *ltime)
unknown's avatar
unknown committed
2542 2543
{
  bool res= get_arg0_time(ltime);
2544 2545 2546 2547 2548 2549
  /*
    For MYSQL_TIMESTAMP_TIME value we can have non-zero day part,
    which we should not lose.
  */
  if (ltime->time_type == MYSQL_TIMESTAMP_DATETIME)
    ltime->year= ltime->month= ltime->day= 0;
2550
  ltime->time_type= MYSQL_TIMESTAMP_TIME;
unknown's avatar
unknown committed
2551 2552 2553 2554
  return res;
}


2555 2556
longlong Item_time_typecast::val_int()
{
2557
  MYSQL_TIME ltime;
2558 2559 2560 2561 2562 2563 2564 2565
  if (get_time(&ltime))
  {
    null_value= 1;
    return 0;
  }
  return ltime.hour * 10000L + ltime.minute * 100 + ltime.second;
}

unknown's avatar
unknown committed
2566 2567
String *Item_time_typecast::val_str(String *str)
{
2568
  DBUG_ASSERT(fixed == 1);
2569
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
2570 2571

  if (!get_arg0_time(&ltime) &&
2572 2573
      !make_datetime(ltime.second_part ? TIME_MICROSECOND : TIME_ONLY,
		     &ltime, str))
unknown's avatar
unknown committed
2574 2575 2576 2577 2578 2579 2580
    return str;

  null_value=1;
  return 0;
}


2581
bool Item_date_typecast::get_date(MYSQL_TIME *ltime, uint fuzzy_date)
unknown's avatar
unknown committed
2582
{
unknown's avatar
unknown committed
2583
  bool res= get_arg0_date(ltime, TIME_FUZZY_DATE);
2584
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= 0;
2585
  ltime->time_type= MYSQL_TIMESTAMP_DATE;
unknown's avatar
unknown committed
2586 2587 2588 2589 2590 2591
  return res;
}


String *Item_date_typecast::val_str(String *str)
{
2592
  DBUG_ASSERT(fixed == 1);
2593
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
2594

2595 2596
  if (!get_arg0_date(&ltime, TIME_FUZZY_DATE) &&
      !str->alloc(MAX_DATE_STRING_REP_LENGTH))
2597
  {
2598
    make_date((DATE_TIME_FORMAT *) 0, &ltime, str);
2599 2600
    return str;
  }
unknown's avatar
unknown committed
2601 2602 2603 2604 2605

  null_value=1;
  return 0;
}

2606 2607 2608
longlong Item_date_typecast::val_int()
{
  DBUG_ASSERT(fixed == 1);
2609
  MYSQL_TIME ltime;
2610
  if ((null_value= args[0]->get_date(&ltime, TIME_FUZZY_DATE)))
2611 2612 2613
    return 0;
  return (longlong) (ltime.year * 10000L + ltime.month * 100 + ltime.day);
}
2614

unknown's avatar
unknown committed
2615 2616 2617
/*
  MAKEDATE(a,b) is a date function that creates a date value 
  from a year and day value.
2618 2619 2620 2621 2622

  NOTES:
    As arguments are integers, we can't know if the year is a 2 digit or 4 digit year.
    In this case we treat all years < 100 as 2 digit years. Ie, this is not safe
    for dates between 0000-01-01 and 0099-12-31
unknown's avatar
unknown committed
2623 2624 2625 2626
*/

String *Item_func_makedate::val_str(String *str)
{
2627
  DBUG_ASSERT(fixed == 1);
2628
  MYSQL_TIME l_time;
unknown's avatar
unknown committed
2629
  long daynr=  (long) args[1]->val_int();
2630
  long year= (long) args[0]->val_int();
unknown's avatar
unknown committed
2631 2632 2633
  long days;

  if (args[0]->null_value || args[1]->null_value ||
2634
      year < 0 || daynr <= 0)
2635
    goto err;
unknown's avatar
unknown committed
2636

2637 2638 2639 2640
  if (year < 100)
    year= year_2000_handling(year);

  days= calc_daynr(year,1,1) + daynr - 1;
unknown's avatar
unknown committed
2641
  /* Day number from year 0 to 9999-12-31 */
2642
  if (days >= 0 && days <= MAX_DAY_NUMBER)
unknown's avatar
unknown committed
2643 2644 2645
  {
    null_value=0;
    get_date_from_daynr(days,&l_time.year,&l_time.month,&l_time.day);
2646
    if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
2647 2648 2649
      goto err;
    make_date((DATE_TIME_FORMAT *) 0, &l_time, str);
    return str;
unknown's avatar
unknown committed
2650 2651
  }

2652
err:
unknown's avatar
unknown committed
2653 2654 2655 2656 2657
  null_value=1;
  return 0;
}


2658 2659 2660 2661 2662 2663 2664 2665 2666 2667
/*
  MAKEDATE(a,b) is a date function that creates a date value 
  from a year and day value.

  NOTES:
    As arguments are integers, we can't know if the year is a 2 digit or 4 digit year.
    In this case we treat all years < 100 as 2 digit years. Ie, this is not safe
    for dates between 0000-01-01 and 0099-12-31
*/

2668 2669 2670
longlong Item_func_makedate::val_int()
{
  DBUG_ASSERT(fixed == 1);
2671
  MYSQL_TIME l_time;
2672
  long daynr=  (long) args[1]->val_int();
2673
  long year= (long) args[0]->val_int();
2674 2675 2676
  long days;

  if (args[0]->null_value || args[1]->null_value ||
2677
      year < 0 || daynr <= 0)
2678 2679
    goto err;

2680 2681 2682 2683
  if (year < 100)
    year= year_2000_handling(year);

  days= calc_daynr(year,1,1) + daynr - 1;
2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697
  /* Day number from year 0 to 9999-12-31 */
  if (days >= 0 && days < MAX_DAY_NUMBER)
  {
    null_value=0;
    get_date_from_daynr(days,&l_time.year,&l_time.month,&l_time.day);
    return (longlong) (l_time.year * 10000L + l_time.month * 100 + l_time.day);
  }

err:
  null_value= 1;
  return 0;
}


unknown's avatar
unknown committed
2698 2699 2700 2701
void Item_func_add_time::fix_length_and_dec()
{
  enum_field_types arg0_field_type;
  decimals=0;
2702
  max_length=MAX_DATETIME_FULL_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
unknown's avatar
unknown committed
2703
  maybe_null= 1;
unknown's avatar
unknown committed
2704 2705

  /*
2706 2707
    The field type for the result of an Item_func_add_time function is defined
    as follows:
unknown's avatar
unknown committed
2708 2709 2710 2711 2712 2713 2714 2715 2716

    - If first arg is a MYSQL_TYPE_DATETIME or MYSQL_TYPE_TIMESTAMP 
      result is MYSQL_TYPE_DATETIME
    - If first arg is a MYSQL_TYPE_TIME result is MYSQL_TYPE_TIME
    - Otherwise the result is MYSQL_TYPE_STRING
  */

  cached_field_type= MYSQL_TYPE_STRING;
  arg0_field_type= args[0]->field_type();
unknown's avatar
unknown committed
2717 2718
  if (arg0_field_type == MYSQL_TYPE_DATE ||
      arg0_field_type == MYSQL_TYPE_DATETIME ||
unknown's avatar
unknown committed
2719 2720 2721 2722 2723 2724 2725
      arg0_field_type == MYSQL_TYPE_TIMESTAMP)
    cached_field_type= MYSQL_TYPE_DATETIME;
  else if (arg0_field_type == MYSQL_TYPE_TIME)
    cached_field_type= MYSQL_TYPE_TIME;
}

/*
2726 2727
  ADDTIME(t,a) and SUBTIME(t,a) are time functions that calculate a
  time/datetime value 
unknown's avatar
unknown committed
2728 2729 2730 2731 2732 2733 2734 2735 2736

  t: time_or_datetime_expression
  a: time_expression
  
  Result: Time value or datetime value
*/

String *Item_func_add_time::val_str(String *str)
{
2737
  DBUG_ASSERT(fixed == 1);
2738
  MYSQL_TIME l_time1, l_time2, l_time3;
unknown's avatar
unknown committed
2739
  bool is_time= 0;
2740 2741
  long days, microseconds;
  longlong seconds;
unknown's avatar
unknown committed
2742 2743 2744
  int l_sign= sign;

  null_value=0;
unknown's avatar
unknown committed
2745 2746
  if (is_date)                        // TIMESTAMP function
  {
unknown's avatar
unknown committed
2747
    if (get_arg0_date(&l_time1, TIME_FUZZY_DATE) || 
unknown's avatar
unknown committed
2748
        args[1]->get_time(&l_time2) ||
2749 2750
        l_time1.time_type == MYSQL_TIMESTAMP_TIME || 
        l_time2.time_type != MYSQL_TIMESTAMP_TIME)
unknown's avatar
unknown committed
2751 2752 2753
      goto null_date;
  }
  else                                // ADDTIME function
unknown's avatar
unknown committed
2754
  {
unknown's avatar
unknown committed
2755 2756
    if (args[0]->get_time(&l_time1) || 
        args[1]->get_time(&l_time2) ||
2757
        l_time2.time_type == MYSQL_TIMESTAMP_DATETIME)
unknown's avatar
unknown committed
2758
      goto null_date;
2759
    is_time= (l_time1.time_type == MYSQL_TIMESTAMP_TIME);
unknown's avatar
unknown committed
2760 2761 2762
  }
  if (l_time1.neg != l_time2.neg)
    l_sign= -l_sign;
2763 2764 2765
  
  bzero((char *)&l_time3, sizeof(l_time3));
  
2766 2767
  l_time3.neg= calc_time_diff(&l_time1, &l_time2, -l_sign,
			      &seconds, &microseconds);
unknown's avatar
unknown committed
2768

2769 2770 2771 2772 2773 2774
  /*
    If first argument was negative and diff between arguments
    is non-zero we need to swap sign to get proper result.
  */
  if (l_time1.neg && (seconds || microseconds))
    l_time3.neg= 1-l_time3.neg;         // Swap sign of result
unknown's avatar
unknown committed
2775

2776 2777 2778 2779
  if (!is_time && l_time3.neg)
    goto null_date;

  days= (long)(seconds/86400L);
unknown's avatar
unknown committed
2780

2781
  calc_time_from_sec(&l_time3, (long)(seconds%86400L), microseconds);
2782

unknown's avatar
unknown committed
2783 2784 2785 2786
  if (!is_time)
  {
    get_date_from_daynr(days,&l_time3.year,&l_time3.month,&l_time3.day);
    if (l_time3.day &&
2787 2788 2789
	!make_datetime(l_time1.second_part || l_time2.second_part ?
		       DATE_TIME_MICROSECOND : DATE_TIME,
		       &l_time3, str))
unknown's avatar
unknown committed
2790 2791 2792
      return str;
    goto null_date;
  }
2793
  
unknown's avatar
unknown committed
2794
  l_time3.hour+= days*24;
2795 2796 2797
  if (!make_datetime_with_warn(l_time1.second_part || l_time2.second_part ?
                               TIME_MICROSECOND : TIME_ONLY,
                               &l_time3, str))
unknown's avatar
unknown committed
2798 2799 2800 2801 2802 2803 2804
    return str;

null_date:
  null_value=1;
  return 0;
}

2805 2806 2807 2808 2809 2810

void Item_func_add_time::print(String *str)
{
  if (is_date)
  {
    DBUG_ASSERT(sign > 0);
2811
    str->append(STRING_WITH_LEN("timestamp("));
2812 2813 2814 2815
  }
  else
  {
    if (sign > 0)
2816
      str->append(STRING_WITH_LEN("addtime("));
2817
    else
2818
      str->append(STRING_WITH_LEN("subtime("));
2819 2820 2821
  }
  args[0]->print(str);
  str->append(',');
2822
  args[1]->print(str);
2823 2824 2825 2826
  str->append(')');
}


unknown's avatar
unknown committed
2827 2828 2829 2830 2831 2832 2833 2834 2835 2836
/*
  TIMEDIFF(t,s) is a time function that calculates the 
  time value between a start and end time.

  t and s: time_or_datetime_expression
  Result: Time value
*/

String *Item_func_timediff::val_str(String *str)
{
2837
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2838 2839 2840
  longlong seconds;
  long microseconds;
  int l_sign= 1;
2841
  MYSQL_TIME l_time1 ,l_time2, l_time3;
unknown's avatar
unknown committed
2842 2843 2844 2845 2846 2847 2848 2849 2850 2851

  null_value= 0;  
  if (args[0]->get_time(&l_time1) ||
      args[1]->get_time(&l_time2) ||
      l_time1.time_type != l_time2.time_type)
    goto null_date;

  if (l_time1.neg != l_time2.neg)
    l_sign= -l_sign;

2852 2853
  bzero((char *)&l_time3, sizeof(l_time3));
  
2854
  l_time3.neg= calc_time_diff(&l_time1, &l_time2, l_sign,
2855
			      &seconds, &microseconds);
unknown's avatar
unknown committed
2856

2857
  /*
unknown's avatar
unknown committed
2858
    For MYSQL_TIMESTAMP_TIME only:
2859
      If first argument was negative and diff between arguments
2860
      is non-zero we need to swap sign to get proper result.
2861
  */
2862
  if (l_time1.neg && (seconds || microseconds))
2863
    l_time3.neg= 1-l_time3.neg;         // Swap sign of result
unknown's avatar
unknown committed
2864

unknown's avatar
unknown committed
2865
  calc_time_from_sec(&l_time3, (long) seconds, microseconds);
2866

2867 2868 2869
  if (!make_datetime_with_warn(l_time1.second_part || l_time2.second_part ?
                               TIME_MICROSECOND : TIME_ONLY,
                               &l_time3, str))
unknown's avatar
unknown committed
2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884
    return str;

null_date:
  null_value=1;
  return 0;
}

/*
  MAKETIME(h,m,s) is a time function that calculates a time value 
  from the total number of hours, minutes, and seconds.
  Result: Time value
*/

String *Item_func_maketime::val_str(String *str)
{
2885
  DBUG_ASSERT(fixed == 1);
2886
  MYSQL_TIME ltime;
2887
  bool overflow= 0;
unknown's avatar
unknown committed
2888

2889 2890 2891
  longlong hour=   args[0]->val_int();
  longlong minute= args[1]->val_int();
  longlong second= args[2]->val_int();
unknown's avatar
unknown committed
2892 2893

  if ((null_value=(args[0]->null_value || 
2894 2895 2896 2897
                   args[1]->null_value ||
                   args[2]->null_value ||
                   minute < 0 || minute > 59 ||
                   second < 0 || second > 59 ||
2898
                   str->alloc(MAX_DATE_STRING_REP_LENGTH))))
2899
    return 0;
unknown's avatar
unknown committed
2900

2901
  bzero((char *)&ltime, sizeof(ltime));
unknown's avatar
unknown committed
2902
  ltime.neg= 0;
2903 2904

  /* Check for integer overflows */
unknown's avatar
unknown committed
2905 2906
  if (hour < 0)
  {
2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929
    if (args[0]->unsigned_flag)
      overflow= 1;
    else
      ltime.neg= 1;
  }
  if (-hour > UINT_MAX || hour > UINT_MAX)
    overflow= 1;

  if (!overflow)
  {
    ltime.hour=   (uint) ((hour < 0 ? -hour : hour));
    ltime.minute= (uint) minute;
    ltime.second= (uint) second;
  }
  else
  {
    ltime.hour= TIME_MAX_HOUR;
    ltime.minute= TIME_MAX_MINUTE;
    ltime.second= TIME_MAX_SECOND;
    char buf[28];
    char *ptr= longlong10_to_str(hour, buf, args[0]->unsigned_flag ? 10 : -10);
    int len = (int)(ptr - buf) +
      my_sprintf(ptr, (ptr, ":%02u:%02u", (uint)minute, (uint)second));
2930 2931
    make_truncated_value_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                                 buf, len, MYSQL_TIMESTAMP_TIME,
2932
                                 NullS);
2933 2934 2935 2936 2937 2938
  }
  
  if (make_time_with_warn((DATE_TIME_FORMAT *) 0, &ltime, str))
  {
    null_value= 1;
    return 0;
unknown's avatar
unknown committed
2939
  }
2940
  return str;
unknown's avatar
unknown committed
2941 2942
}

2943

unknown's avatar
unknown committed
2944
/*
2945 2946
  MICROSECOND(a) is a function ( extraction) that extracts the microseconds
  from a.
unknown's avatar
unknown committed
2947 2948 2949 2950

  a: Datetime or time value
  Result: int value
*/
2951

unknown's avatar
unknown committed
2952 2953
longlong Item_func_microsecond::val_int()
{
2954
  DBUG_ASSERT(fixed == 1);
2955
  MYSQL_TIME ltime;
unknown's avatar
unknown committed
2956 2957 2958 2959
  if (!get_arg0_time(&ltime))
    return ltime.second_part;
  return 0;
}
2960 2961


2962 2963
longlong Item_func_timestamp_diff::val_int()
{
2964
  MYSQL_TIME ltime1, ltime2;
2965 2966 2967 2968 2969 2970
  longlong seconds;
  long microseconds;
  long months= 0;
  int neg= 1;

  null_value= 0;  
unknown's avatar
unknown committed
2971 2972
  if (args[0]->get_date(&ltime1, TIME_NO_ZERO_DATE) ||
      args[1]->get_date(&ltime2, TIME_NO_ZERO_DATE))
2973 2974 2975 2976 2977 2978 2979 2980 2981 2982
    goto null_date;

  if (calc_time_diff(&ltime2,&ltime1, 1,
		     &seconds, &microseconds))
    neg= -1;

  if (int_type == INTERVAL_YEAR ||
      int_type == INTERVAL_QUARTER ||
      int_type == INTERVAL_MONTH)
  {
2983 2984
    uint year_beg, year_end, month_beg, month_end, day_beg, day_end;
    uint years= 0;
2985 2986
    uint second_beg, second_end, microsecond_beg, microsecond_end;

2987 2988 2989 2990 2991 2992
    if (neg == -1)
    {
      year_beg= ltime2.year;
      year_end= ltime1.year;
      month_beg= ltime2.month;
      month_end= ltime1.month;
2993 2994
      day_beg= ltime2.day;
      day_end= ltime1.day;
2995 2996 2997 2998
      second_beg= ltime2.hour * 3600 + ltime2.minute * 60 + ltime2.second;
      second_end= ltime1.hour * 3600 + ltime1.minute * 60 + ltime1.second;
      microsecond_beg= ltime2.second_part;
      microsecond_end= ltime1.second_part;
2999 3000 3001 3002 3003 3004 3005
    }
    else
    {
      year_beg= ltime1.year;
      year_end= ltime2.year;
      month_beg= ltime1.month;
      month_end= ltime2.month;
3006 3007
      day_beg= ltime1.day;
      day_end= ltime2.day;
3008 3009 3010 3011
      second_beg= ltime1.hour * 3600 + ltime1.minute * 60 + ltime1.second;
      second_end= ltime2.hour * 3600 + ltime2.minute * 60 + ltime2.second;
      microsecond_beg= ltime1.second_part;
      microsecond_end= ltime2.second_part;
3012 3013
    }

3014 3015 3016 3017
    /* calc years */
    years= year_end - year_beg;
    if (month_end < month_beg || (month_end == month_beg && day_end < day_beg))
      years-= 1;
3018

3019 3020 3021 3022 3023 3024
    /* calc months */
    months= 12*years;
    if (month_end < month_beg || (month_end == month_beg && day_end < day_beg))
      months+= 12 - (month_beg - month_end);
    else
      months+= (month_end - month_beg);
3025

3026 3027
    if (day_end < day_beg)
      months-= 1;
3028 3029 3030 3031
    else if ((day_end == day_beg) &&
	     ((second_end < second_beg) ||
	      (second_end == second_beg && microsecond_end < microsecond_beg)))
      months-= 1;
3032 3033 3034 3035
  }

  switch (int_type) {
  case INTERVAL_YEAR:
3036
    return months/12*neg;
3037
  case INTERVAL_QUARTER:
3038
    return months/3*neg;
3039
  case INTERVAL_MONTH:
3040
    return months*neg;
3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051
  case INTERVAL_WEEK:          
    return seconds/86400L/7L*neg;
  case INTERVAL_DAY:		
    return seconds/86400L*neg;
  case INTERVAL_HOUR:		
    return seconds/3600L*neg;
  case INTERVAL_MINUTE:		
    return seconds/60L*neg;
  case INTERVAL_SECOND:		
    return seconds*neg;
  case INTERVAL_MICROSECOND:
3052 3053 3054 3055 3056
    /*
      In MySQL difference between any two valid datetime values
      in microseconds fits into longlong.
    */
    return (seconds*1000000L+microseconds)*neg;
3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073
  default:
    break;
  }

null_date:
  null_value=1;
  return 0;
}


void Item_func_timestamp_diff::print(String *str)
{
  str->append(func_name());
  str->append('(');

  switch (int_type) {
  case INTERVAL_YEAR:
3074
    str->append(STRING_WITH_LEN("YEAR"));
3075 3076
    break;
  case INTERVAL_QUARTER:
3077
    str->append(STRING_WITH_LEN("QUARTER"));
3078 3079
    break;
  case INTERVAL_MONTH:
3080
    str->append(STRING_WITH_LEN("MONTH"));
3081 3082
    break;
  case INTERVAL_WEEK:          
3083
    str->append(STRING_WITH_LEN("WEEK"));
3084 3085
    break;
  case INTERVAL_DAY:		
3086
    str->append(STRING_WITH_LEN("DAY"));
3087 3088
    break;
  case INTERVAL_HOUR:
3089
    str->append(STRING_WITH_LEN("HOUR"));
3090 3091
    break;
  case INTERVAL_MINUTE:		
3092
    str->append(STRING_WITH_LEN("MINUTE"));
3093 3094
    break;
  case INTERVAL_SECOND:
3095
    str->append(STRING_WITH_LEN("SECOND"));
3096 3097
    break;		
  case INTERVAL_MICROSECOND:
3098
    str->append(STRING_WITH_LEN("SECOND_FRAC"));
3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110
    break;
  default:
    break;
  }

  for (uint i=0 ; i < 2 ; i++)
  {
    str->append(',');
    args[i]->print(str);
  }
  str->append(')');
}
unknown's avatar
unknown committed
3111 3112


3113 3114
String *Item_func_get_format::val_str(String *str)
{
3115
  DBUG_ASSERT(fixed == 1);
3116 3117 3118 3119
  const char *format_name;
  KNOWN_DATE_TIME_FORMAT *format;
  String *val= args[0]->val_str(str);
  ulong val_len;
3120

3121 3122 3123 3124 3125 3126 3127
  if ((null_value= args[0]->null_value))
    return 0;    

  val_len= val->length();
  for (format= &known_date_time_formats[0];
       (format_name= format->format_name);
       format++)
3128
  {
3129 3130 3131 3132 3133 3134
    uint format_name_len;
    format_name_len= strlen(format_name);
    if (val_len == format_name_len &&
	!my_strnncoll(&my_charset_latin1, 
		      (const uchar *) val->ptr(), val_len, 
		      (const uchar *) format_name, val_len))
3135
    {
3136 3137 3138
      const char *format_str= get_date_time_format_str(format, type);
      str->set(format_str, strlen(format_str), &my_charset_bin);
      return str;
3139 3140 3141
    }
  }

3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152
  null_value= 1;
  return 0;
}


void Item_func_get_format::print(String *str)
{
  str->append(func_name());
  str->append('(');

  switch (type) {
3153
  case MYSQL_TIMESTAMP_DATE:
3154
    str->append(STRING_WITH_LEN("DATE, "));
3155
    break;
3156
  case MYSQL_TIMESTAMP_DATETIME:
3157
    str->append(STRING_WITH_LEN("DATETIME, "));
3158
    break;
3159
  case MYSQL_TIMESTAMP_TIME:
3160
    str->append(STRING_WITH_LEN("TIME, "));
3161 3162 3163 3164 3165 3166 3167 3168 3169
    break;
  default:
    DBUG_ASSERT(0);
  }
  args[0]->print(str);
  str->append(')');
}


3170
/*
3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188
  Get type of datetime value (DATE/TIME/...) which will be produced
  according to format string.

  SYNOPSIS
    get_date_time_result_type()
      format - format string
      length - length of format string

  NOTE
    We don't process day format's characters('D', 'd', 'e') because day
    may be a member of all date/time types.

    Format specifiers supported by this function should be in sync with
    specifiers supported by extract_date_time() function.

  RETURN VALUE
    One of date_time_format_types values:
    DATE_TIME_MICROSECOND, DATE_TIME, DATE_ONLY, TIME_MICROSECOND, TIME_ONLY
3189 3190
*/

3191 3192
static date_time_format_types
get_date_time_result_type(const char *format, uint length)
3193 3194
{
  const char *time_part_frms= "HISThiklrs";
3195
  const char *date_part_frms= "MVUXYWabcjmvuxyw";
3196 3197 3198 3199 3200 3201 3202 3203 3204 3205
  bool date_part_used= 0, time_part_used= 0, frac_second_used= 0;
  
  const char *val= format;
  const char *end= format + length;

  for (; val != end && val != end; val++)
  {
    if (*val == '%' && val+1 != end)
    {
      val++;
3206 3207 3208
      if (*val == 'f')
        frac_second_used= time_part_used= 1;
      else if (!time_part_used && strchr(time_part_frms, *val))
3209 3210 3211
	time_part_used= 1;
      else if (!date_part_used && strchr(date_part_frms, *val))
	date_part_used= 1;
3212 3213 3214 3215 3216 3217
      if (date_part_used && frac_second_used)
      {
        /*
          frac_second_used implies time_part_used, and thus we already
          have all types of date-time components and can end our search.
        */
3218 3219 3220
	return DATE_TIME_MICROSECOND;
    }
  }
unknown's avatar
unknown committed
3221
  }
3222

3223 3224 3225
  /* We don't have all three types of date-time components */
  if (frac_second_used)
    return TIME_MICROSECOND;
3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241
  if (time_part_used)
  {
    if (date_part_used)
      return DATE_TIME;
    return TIME_ONLY;
  }
  return DATE_ONLY;
}


void Item_func_str_to_date::fix_length_and_dec()
{
  char format_buff[64];
  String format_str(format_buff, sizeof(format_buff), &my_charset_bin), *format;
  maybe_null= 1;
  decimals=0;
3242
  cached_field_type= MYSQL_TYPE_DATETIME;
3243
  max_length= MAX_DATETIME_FULL_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
3244
  cached_timestamp_type= MYSQL_TIMESTAMP_NONE;
unknown's avatar
unknown committed
3245 3246
  format= args[1]->val_str(&format_str);
  if (!args[1]->null_value && (const_item= args[1]->const_item()))
3247
  {
3248 3249
    cached_format_type= get_date_time_result_type(format->ptr(),
                                                  format->length());
3250 3251
    switch (cached_format_type) {
    case DATE_ONLY:
3252
      cached_timestamp_type= MYSQL_TIMESTAMP_DATE;
3253 3254 3255 3256 3257
      cached_field_type= MYSQL_TYPE_DATE; 
      max_length= MAX_DATE_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
      break;
    case TIME_ONLY:
    case TIME_MICROSECOND:
3258
      cached_timestamp_type= MYSQL_TIMESTAMP_TIME;
3259 3260 3261 3262
      cached_field_type= MYSQL_TYPE_TIME; 
      max_length= MAX_TIME_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
      break;
    default:
3263
      cached_timestamp_type= MYSQL_TIMESTAMP_DATETIME;
3264 3265 3266 3267 3268 3269
      cached_field_type= MYSQL_TYPE_DATETIME; 
      break;
    }
  }
}

3270
bool Item_func_str_to_date::get_date(MYSQL_TIME *ltime, uint fuzzy_date)
3271 3272 3273
{
  DATE_TIME_FORMAT date_time_format;
  char val_buff[64], format_buff[64];
3274
  String val_string(val_buff, sizeof(val_buff), &my_charset_bin), *val;
3275 3276
  String format_str(format_buff, sizeof(format_buff), &my_charset_bin), *format;

3277
  val=    args[0]->val_str(&val_string);
3278 3279 3280 3281
  format= args[1]->val_str(&format_str);
  if (args[0]->null_value || args[1]->null_value)
    goto null_date;

3282
  null_value= 0;
3283
  bzero((char*) ltime, sizeof(*ltime));
3284 3285 3286
  date_time_format.format.str=    (char*) format->ptr();
  date_time_format.format.length= format->length();
  if (extract_date_time(&date_time_format, val->ptr(), val->length(),
3287 3288 3289
			ltime, cached_timestamp_type, 0, "datetime") ||
      ((fuzzy_date & TIME_NO_ZERO_DATE) &&
       (ltime->year == 0 || ltime->month == 0 || ltime->day == 0)))
3290
    goto null_date;
3291
  if (cached_timestamp_type == MYSQL_TIMESTAMP_TIME && ltime->day)
3292 3293 3294 3295 3296 3297 3298 3299 3300
  {
    /*
      Day part for time type can be nonzero value and so 
      we should add hours from day part to hour part to
      keep valid time value.
    */
    ltime->hour+= ltime->day*24;
    ltime->day= 0;
  }
3301 3302 3303 3304
  return 0;

null_date:
  return (null_value=1);
3305 3306 3307 3308 3309
}


String *Item_func_str_to_date::val_str(String *str)
{
3310
  DBUG_ASSERT(fixed == 1);
3311
  MYSQL_TIME ltime;
3312

3313 3314
  if (Item_func_str_to_date::get_date(&ltime, TIME_FUZZY_DATE))
    return 0;
3315

3316 3317
  if (!make_datetime((const_item ? cached_format_type :
		     (ltime.second_part ? DATE_TIME_MICROSECOND : DATE_TIME)),
3318 3319
		     &ltime, str))
    return str;
3320 3321
  return 0;
}
unknown's avatar
unknown committed
3322 3323


3324
bool Item_func_last_day::get_date(MYSQL_TIME *ltime, uint fuzzy_date)
unknown's avatar
unknown committed
3325
{
3326 3327
  if (get_arg0_date(ltime, fuzzy_date & ~TIME_FUZZY_DATE) ||
      (ltime->month == 0))
unknown's avatar
unknown committed
3328 3329
  {
    null_value= 1;
3330
    return 1;
unknown's avatar
unknown committed
3331 3332
  }
  null_value= 0;
3333 3334 3335 3336
  uint month_idx= ltime->month-1;
  ltime->day= days_in_month[month_idx];
  if ( month_idx == 1 && calc_days_in_year(ltime->year) == 366)
    ltime->day= 29;
3337
  ltime->time_type= MYSQL_TIMESTAMP_DATE;
unknown's avatar
unknown committed
3338 3339
  return 0;
}