← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item_timefunc.cc

Merged in trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item_timefunc.cc
1
 
/* Copyright (C) 2000-2003 MySQL AB
2
 
 
3
 
   This program is free software; you can redistribute it and/or modify
4
 
   it under the terms of the GNU General Public License as published by
5
 
   the Free Software Foundation; version 2 of the License.
6
 
 
7
 
   This program is distributed in the hope that it will be useful,
8
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
   GNU General Public License for more details.
11
 
 
12
 
   You should have received a copy of the GNU General Public License
13
 
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
 
 
16
 
 
17
 
/**
18
 
  @file
19
 
 
20
 
  @brief
21
 
  This file defines all time functions
22
 
 
23
 
  @todo
24
 
    Move month and days to language files
25
 
*/
26
 
#include <drizzled/server_includes.h>
27
 
#include <time.h>
28
 
#include <drizzled/drizzled_error_messages.h>
29
 
 
30
 
/** Day number for Dec 31st, 9999. */
31
 
#define MAX_DAY_NUMBER 3652424L
32
 
 
33
 
/**
34
 
  @todo
35
 
  OPTIMIZATION
36
 
  - Replace the switch with a function that should be called for each
37
 
  date type.
38
 
  - Remove sprintf and opencode the conversion, like we do in
39
 
  Field_datetime.
40
 
 
41
 
  The reason for this functions existence is that as we don't have a
42
 
  way to know if a datetime/time value has microseconds in them
43
 
  we are now only adding microseconds to the output if the
44
 
  value has microseconds.
45
 
 
46
 
  We can't use a standard make_date_time() for this as we don't know
47
 
  if someone will use %f in the format specifier in which case we would get
48
 
  the microseconds twice.
49
 
*/
50
 
 
51
 
static bool make_datetime(date_time_format_types format, DRIZZLE_TIME *ltime,
52
 
                          String *str)
53
 
{
54
 
  char *buff;
55
 
  const CHARSET_INFO * const cs= &my_charset_bin;
56
 
  uint32_t length= MAX_DATE_STRING_REP_LENGTH;
57
 
 
58
 
  if (str->alloc(length))
59
 
    return 1;
60
 
  buff= (char*) str->ptr();
61
 
 
62
 
  switch (format) {
63
 
  case TIME_ONLY:
64
 
    length= cs->cset->snprintf(cs, buff, length, "%s%02d:%02d:%02d",
65
 
                               ltime->neg ? "-" : "",
66
 
                               ltime->hour, ltime->minute, ltime->second);
67
 
    break;
68
 
  case TIME_MICROSECOND:
69
 
    length= cs->cset->snprintf(cs, buff, length, "%s%02d:%02d:%02d.%06ld",
70
 
                               ltime->neg ? "-" : "",
71
 
                               ltime->hour, ltime->minute, ltime->second,
72
 
                               ltime->second_part);
73
 
    break;
74
 
  case DATE_ONLY:
75
 
    length= cs->cset->snprintf(cs, buff, length, "%04d-%02d-%02d",
76
 
                               ltime->year, ltime->month, ltime->day);
77
 
    break;
78
 
  case DATE_TIME:
79
 
    length= cs->cset->snprintf(cs, buff, length,
80
 
                               "%04d-%02d-%02d %02d:%02d:%02d",
81
 
                               ltime->year, ltime->month, ltime->day,
82
 
                               ltime->hour, ltime->minute, ltime->second);
83
 
    break;
84
 
  case DATE_TIME_MICROSECOND:
85
 
    length= cs->cset->snprintf(cs, buff, length,
86
 
                               "%04d-%02d-%02d %02d:%02d:%02d.%06ld",
87
 
                               ltime->year, ltime->month, ltime->day,
88
 
                               ltime->hour, ltime->minute, ltime->second,
89
 
                               ltime->second_part);
90
 
    break;
91
 
  }
92
 
 
93
 
  str->length(length);
94
 
  str->set_charset(cs);
95
 
  return 0;
96
 
}
97
 
 
98
 
 
99
 
/*
100
 
  Wrapper over make_datetime() with validation of the input DRIZZLE_TIME value
101
 
 
102
 
  NOTE
103
 
    see make_datetime() for more information
104
 
 
105
 
  RETURN
106
 
    1    if there was an error during converion
107
 
    0    otherwise
108
 
*/
109
 
 
110
 
static bool make_datetime_with_warn(date_time_format_types format, DRIZZLE_TIME *ltime,
111
 
                                    String *str)
112
 
{
113
 
  int warning= 0;
114
 
 
115
 
  if (make_datetime(format, ltime, str))
116
 
    return 1;
117
 
  if (check_time_range(ltime, &warning))
118
 
    return 1;
119
 
  if (!warning)
120
 
    return 0;
121
 
 
122
 
  make_truncated_value_warning(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
123
 
                               str->ptr(), str->length(),
124
 
                               DRIZZLE_TIMESTAMP_TIME, NULL);
125
 
  return make_datetime(format, ltime, str);
126
 
}
127
 
 
128
 
 
129
 
/*
130
 
  Wrapper over make_time() with validation of the input DRIZZLE_TIME value
131
 
 
132
 
  NOTE
133
 
    see make_time() for more info
134
 
 
135
 
  RETURN
136
 
    1    if there was an error during conversion
137
 
    0    otherwise
138
 
*/
139
 
 
140
 
static bool make_time_with_warn(const DATE_TIME_FORMAT *format,
141
 
                                DRIZZLE_TIME *l_time, String *str)
142
 
{
143
 
  int warning= 0;
144
 
  make_time(format, l_time, str);
145
 
  if (check_time_range(l_time, &warning))
146
 
    return 1;
147
 
  if (warning)
148
 
  {
149
 
    make_truncated_value_warning(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
150
 
                                 str->ptr(), str->length(),
151
 
                                 DRIZZLE_TIMESTAMP_TIME, NULL);
152
 
    make_time(format, l_time, str);
153
 
  }
154
 
 
155
 
  return 0;
156
 
}
157
 
 
158
 
 
159
 
/*
160
 
  Convert seconds to DRIZZLE_TIME value with overflow checking
161
 
 
162
 
  SYNOPSIS:
163
 
    sec_to_time()
164
 
    seconds          number of seconds
165
 
    unsigned_flag    1, if 'seconds' is unsigned, 0, otherwise
166
 
    ltime            output DRIZZLE_TIME value
167
 
 
168
 
  DESCRIPTION
169
 
    If the 'seconds' argument is inside DRIZZLE_TIME data range, convert it to a
170
 
    corresponding value.
171
 
    Otherwise, truncate the resulting value to the nearest endpoint, and
172
 
    produce a warning message.
173
 
 
174
 
  RETURN
175
 
    1                if the value was truncated during conversion
176
 
    0                otherwise
177
 
*/
178
 
  
179
 
static bool sec_to_time(int64_t seconds, bool unsigned_flag, DRIZZLE_TIME *ltime)
180
 
{
181
 
  uint32_t sec;
182
 
 
183
 
  memset(ltime, 0, sizeof(*ltime));
184
 
  
185
 
  if (seconds < 0)
186
 
  {
187
 
    if (unsigned_flag)
188
 
      goto overflow;
189
 
    ltime->neg= 1;
190
 
    if (seconds < -3020399)
191
 
      goto overflow;
192
 
    seconds= -seconds;
193
 
  }
194
 
  else if (seconds > 3020399)
195
 
    goto overflow;
196
 
  
197
 
  sec= (uint) ((uint64_t) seconds % 3600);
198
 
  ltime->hour= (uint) (seconds/3600);
199
 
  ltime->minute= sec/60;
200
 
  ltime->second= sec % 60;
201
 
 
202
 
  return 0;
203
 
 
204
 
overflow:
205
 
  ltime->hour= TIME_MAX_HOUR;
206
 
  ltime->minute= TIME_MAX_MINUTE;
207
 
  ltime->second= TIME_MAX_SECOND;
208
 
 
209
 
  char buf[22];
210
 
  int len= (int)(int64_t10_to_str(seconds, buf, unsigned_flag ? 10 : -10)
211
 
                 - buf);
212
 
  make_truncated_value_warning(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
213
 
                               buf, len, DRIZZLE_TIMESTAMP_TIME,
214
 
                               NULL);
215
 
  
216
 
  return 1;
217
 
}
218
 
 
219
 
 
220
 
/*
221
 
  Date formats corresponding to compound %r and %T conversion specifiers
222
 
 
223
 
  Note: We should init at least first element of "positions" array
224
 
        (first member) or hpux11 compiler will die horribly.
225
 
*/
226
 
static DATE_TIME_FORMAT time_ampm_format= {{0}, '\0', 0,
227
 
                                           {(char *)"%I:%i:%S %p", 11}};
228
 
static DATE_TIME_FORMAT time_24hrs_format= {{0}, '\0', 0,
229
 
                                            {(char *)"%H:%i:%S", 8}};
230
 
 
231
 
/**
232
 
  Extract datetime value to DRIZZLE_TIME struct from string value
233
 
  according to format string.
234
 
 
235
 
  @param format         date/time format specification
236
 
  @param val                    String to decode
237
 
  @param length         Length of string
238
 
  @param l_time         Store result here
239
 
  @param cached_timestamp_type  It uses to get an appropriate warning
240
 
                                in the case when the value is truncated.
241
 
  @param sub_pattern_end    if non-zero then we are parsing string which
242
 
                            should correspond compound specifier (like %T or
243
 
                            %r) and this parameter is pointer to place where
244
 
                            pointer to end of string matching this specifier
245
 
                            should be stored.
246
 
 
247
 
  @note
248
 
    Possibility to parse strings matching to patterns equivalent to compound
249
 
    specifiers is mainly intended for use from inside of this function in
250
 
    order to understand %T and %r conversion specifiers, so number of
251
 
    conversion specifiers that can be used in such sub-patterns is limited.
252
 
    Also most of checks are skipped in this case.
253
 
 
254
 
  @note
255
 
    If one adds new format specifiers to this function he should also
256
 
    consider adding them to get_date_time_result_type() function.
257
 
 
258
 
  @retval
259
 
    0   ok
260
 
  @retval
261
 
    1   error
262
 
*/
263
 
 
264
 
static bool extract_date_time(DATE_TIME_FORMAT *format,
265
 
                              const char *val, uint32_t length, DRIZZLE_TIME *l_time,
266
 
                              enum enum_drizzle_timestamp_type cached_timestamp_type,
267
 
                              const char **sub_pattern_end,
268
 
                              const char *date_time_type)
269
 
{
270
 
  int weekday= 0, yearday= 0, daypart= 0;
271
 
  int week_number= -1;
272
 
  int error= 0;
273
 
  int  strict_week_number_year= -1;
274
 
  int frac_part;
275
 
  bool usa_time= 0;
276
 
  bool sunday_first_n_first_week_non_iso= false;
277
 
  bool strict_week_number= false;
278
 
  bool strict_week_number_year_type= false;
279
 
  const char *val_begin= val;
280
 
  const char *val_end= val + length;
281
 
  const char *ptr= format->format.str;
282
 
  const char *end= ptr + format->format.length;
283
 
  const CHARSET_INFO * const cs= &my_charset_bin;
284
 
 
285
 
  if (!sub_pattern_end)
286
 
    memset(l_time, 0, sizeof(*l_time));
287
 
 
288
 
  for (; ptr != end && val != val_end; ptr++)
289
 
  {
290
 
    /* Skip pre-space between each argument */
291
 
    while (val != val_end && my_isspace(cs, *val))
292
 
      val++;
293
 
 
294
 
    if (*ptr == '%' && ptr+1 != end)
295
 
    {
296
 
      int val_len;
297
 
      char *tmp;
298
 
 
299
 
      error= 0;
300
 
 
301
 
      val_len= (uint) (val_end - val);
302
 
      switch (*++ptr) {
303
 
        /* Year */
304
 
      case 'Y':
305
 
        tmp= (char*) val + cmin(4, val_len);
306
 
        l_time->year= (int) my_strtoll10(val, &tmp, &error);
307
 
        if ((int) (tmp-val) <= 2)
308
 
          l_time->year= year_2000_handling(l_time->year);
309
 
        val= tmp;
310
 
        break;
311
 
      case 'y':
312
 
        tmp= (char*) val + cmin(2, val_len);
313
 
        l_time->year= (int) my_strtoll10(val, &tmp, &error);
314
 
        val= tmp;
315
 
        l_time->year= year_2000_handling(l_time->year);
316
 
        break;
317
 
 
318
 
        /* Month */
319
 
      case 'm':
320
 
      case 'c':
321
 
        tmp= (char*) val + cmin(2, val_len);
322
 
        l_time->month= (int) my_strtoll10(val, &tmp, &error);
323
 
        val= tmp;
324
 
        break;
325
 
      case 'M':
326
 
        if ((l_time->month= check_word(my_locale_en_US.month_names,
327
 
                                       val, val_end, &val)) <= 0)
328
 
          goto err;
329
 
        break;
330
 
      case 'b':
331
 
        if ((l_time->month= check_word(my_locale_en_US.ab_month_names,
332
 
                                       val, val_end, &val)) <= 0)
333
 
          goto err;
334
 
        break;
335
 
        /* Day */
336
 
      case 'd':
337
 
      case 'e':
338
 
        tmp= (char*) val + cmin(2, val_len);
339
 
        l_time->day= (int) my_strtoll10(val, &tmp, &error);
340
 
        val= tmp;
341
 
        break;
342
 
      case 'D':
343
 
        tmp= (char*) val + cmin(2, val_len);
344
 
        l_time->day= (int) my_strtoll10(val, &tmp, &error);
345
 
        /* Skip 'st, 'nd, 'th .. */
346
 
        val= tmp + cmin((int) (val_end-tmp), 2);
347
 
        break;
348
 
 
349
 
        /* Hour */
350
 
      case 'h':
351
 
      case 'I':
352
 
      case 'l':
353
 
        usa_time= 1;
354
 
        /* fall through */
355
 
      case 'k':
356
 
      case 'H':
357
 
        tmp= (char*) val + cmin(2, val_len);
358
 
        l_time->hour= (int) my_strtoll10(val, &tmp, &error);
359
 
        val= tmp;
360
 
        break;
361
 
 
362
 
        /* Minute */
363
 
      case 'i':
364
 
        tmp= (char*) val + cmin(2, val_len);
365
 
        l_time->minute= (int) my_strtoll10(val, &tmp, &error);
366
 
        val= tmp;
367
 
        break;
368
 
 
369
 
        /* Second */
370
 
      case 's':
371
 
      case 'S':
372
 
        tmp= (char*) val + cmin(2, val_len);
373
 
        l_time->second= (int) my_strtoll10(val, &tmp, &error);
374
 
        val= tmp;
375
 
        break;
376
 
 
377
 
        /* Second part */
378
 
      case 'f':
379
 
        tmp= (char*) val_end;
380
 
        if (tmp - val > 6)
381
 
          tmp= (char*) val + 6;
382
 
        l_time->second_part= (int) my_strtoll10(val, &tmp, &error);
383
 
        frac_part= 6 - (tmp - val);
384
 
        if (frac_part > 0)
385
 
          l_time->second_part*= (ulong) log_10_int[frac_part];
386
 
        val= tmp;
387
 
        break;
388
 
 
389
 
        /* AM / PM */
390
 
      case 'p':
391
 
        if (val_len < 2 || ! usa_time)
392
 
          goto err;
393
 
        if (!my_strnncoll(&my_charset_utf8_general_ci,
394
 
                          (const unsigned char *) val, 2, 
395
 
                          (const unsigned char *) "PM", 2))
396
 
          daypart= 12;
397
 
        else if (my_strnncoll(&my_charset_utf8_general_ci,
398
 
                              (const unsigned char *) val, 2, 
399
 
                              (const unsigned char *) "AM", 2))
400
 
          goto err;
401
 
        val+= 2;
402
 
        break;
403
 
 
404
 
        /* Exotic things */
405
 
      case 'W':
406
 
        if ((weekday= check_word(my_locale_en_US.day_names, val, val_end, &val)) <= 0)
407
 
          goto err;
408
 
        break;
409
 
      case 'a':
410
 
        if ((weekday= check_word(my_locale_en_US.ab_day_names, val, val_end, &val)) <= 0)
411
 
          goto err;
412
 
        break;
413
 
      case 'w':
414
 
        tmp= (char*) val + 1;
415
 
        if ((weekday= (int) my_strtoll10(val, &tmp, &error)) < 0 ||
416
 
            weekday >= 7)
417
 
          goto err;
418
 
        /* We should use the same 1 - 7 scale for %w as for %W */
419
 
        if (!weekday)
420
 
          weekday= 7;
421
 
        val= tmp;
422
 
        break;
423
 
      case 'j':
424
 
        tmp= (char*) val + cmin(val_len, 3);
425
 
        yearday= (int) my_strtoll10(val, &tmp, &error);
426
 
        val= tmp;
427
 
        break;
428
 
 
429
 
        /* Week numbers */
430
 
      case 'V':
431
 
      case 'U':
432
 
      case 'v':
433
 
      case 'u':
434
 
        sunday_first_n_first_week_non_iso= (*ptr=='U' || *ptr== 'V');
435
 
        strict_week_number= (*ptr=='V' || *ptr=='v');
436
 
        tmp= (char*) val + cmin(val_len, 2);
437
 
        if ((week_number= (int) my_strtoll10(val, &tmp, &error)) < 0 ||
438
 
            (strict_week_number && !week_number) ||
439
 
            week_number > 53)
440
 
          goto err;
441
 
        val= tmp;
442
 
        break;
443
 
 
444
 
        /* Year used with 'strict' %V and %v week numbers */
445
 
      case 'X':
446
 
      case 'x':
447
 
        strict_week_number_year_type= (*ptr=='X');
448
 
        tmp= (char*) val + cmin(4, val_len);
449
 
        strict_week_number_year= (int) my_strtoll10(val, &tmp, &error);
450
 
        val= tmp;
451
 
        break;
452
 
 
453
 
        /* Time in AM/PM notation */
454
 
      case 'r':
455
 
        /*
456
 
          We can't just set error here, as we don't want to generate two
457
 
          warnings in case of errors
458
 
        */
459
 
        if (extract_date_time(&time_ampm_format, val,
460
 
                              (uint)(val_end - val), l_time,
461
 
                              cached_timestamp_type, &val, "time"))
462
 
          return(1);
463
 
        break;
464
 
 
465
 
        /* Time in 24-hour notation */
466
 
      case 'T':
467
 
        if (extract_date_time(&time_24hrs_format, val,
468
 
                              (uint)(val_end - val), l_time,
469
 
                              cached_timestamp_type, &val, "time"))
470
 
          return(1);
471
 
        break;
472
 
 
473
 
        /* Conversion specifiers that match classes of characters */
474
 
      case '.':
475
 
        while (my_ispunct(cs, *val) && val != val_end)
476
 
          val++;
477
 
        break;
478
 
      case '@':
479
 
        while (my_isalpha(cs, *val) && val != val_end)
480
 
          val++;
481
 
        break;
482
 
      case '#':
483
 
        while (my_isdigit(cs, *val) && val != val_end)
484
 
          val++;
485
 
        break;
486
 
      default:
487
 
        goto err;
488
 
      }
489
 
      if (error)                                // Error from my_strtoll10
490
 
        goto err;
491
 
    }
492
 
    else if (!my_isspace(cs, *ptr))
493
 
    {
494
 
      if (*val != *ptr)
495
 
        goto err;
496
 
      val++;
497
 
    }
498
 
  }
499
 
  if (usa_time)
500
 
  {
501
 
    if (l_time->hour > 12 || l_time->hour < 1)
502
 
      goto err;
503
 
    l_time->hour= l_time->hour%12+daypart;
504
 
  }
505
 
 
506
 
  /*
507
 
    If we are recursively called for parsing string matching compound
508
 
    specifiers we are already done.
509
 
  */
510
 
  if (sub_pattern_end)
511
 
  {
512
 
    *sub_pattern_end= val;
513
 
    return(0);
514
 
  }
515
 
 
516
 
  if (yearday > 0)
517
 
  {
518
 
    uint32_t days;
519
 
    days= calc_daynr(l_time->year,1,1) +  yearday - 1;
520
 
    if (days <= 0 || days > MAX_DAY_NUMBER)
521
 
      goto err;
522
 
    get_date_from_daynr(days,&l_time->year,&l_time->month,&l_time->day);
523
 
  }
524
 
 
525
 
  if (week_number >= 0 && weekday)
526
 
  {
527
 
    int days;
528
 
    uint32_t weekday_b;
529
 
 
530
 
    /*
531
 
      %V,%v require %X,%x resprectively,
532
 
      %U,%u should be used with %Y and not %X or %x
533
 
    */
534
 
    if ((strict_week_number &&
535
 
        (strict_week_number_year < 0 || (strict_week_number_year_type != sunday_first_n_first_week_non_iso))) ||
536
 
        (!strict_week_number && strict_week_number_year >= 0))
537
 
      goto err;
538
 
 
539
 
    /* Number of days since year 0 till 1st Jan of this year */
540
 
    days= calc_daynr((strict_week_number ? strict_week_number_year :
541
 
                                           l_time->year),
542
 
                     1, 1);
543
 
    /* Which day of week is 1st Jan of this year */
544
 
    weekday_b= calc_weekday(days, sunday_first_n_first_week_non_iso);
545
 
 
546
 
    /*
547
 
      Below we are going to sum:
548
 
      1) number of days since year 0 till 1st day of 1st week of this year
549
 
      2) number of days between 1st week and our week
550
 
      3) and position of our day in the week
551
 
    */
552
 
    if (sunday_first_n_first_week_non_iso)
553
 
    {
554
 
      days+= ((weekday_b == 0) ? 0 : 7) - weekday_b +
555
 
             (week_number - 1) * 7 +
556
 
             weekday % 7;
557
 
    }
558
 
    else
559
 
    {
560
 
      days+= ((weekday_b <= 3) ? 0 : 7) - weekday_b +
561
 
             (week_number - 1) * 7 +
562
 
             (weekday - 1);
563
 
    }
564
 
 
565
 
    if (days <= 0 || days > MAX_DAY_NUMBER)
566
 
      goto err;
567
 
    get_date_from_daynr(days,&l_time->year,&l_time->month,&l_time->day);
568
 
  }
569
 
 
570
 
  if (l_time->month > 12 || l_time->day > 31 || l_time->hour > 23 || 
571
 
      l_time->minute > 59 || l_time->second > 59)
572
 
    goto err;
573
 
 
574
 
  if (val != val_end)
575
 
  {
576
 
    do
577
 
    {
578
 
      if (!my_isspace(&my_charset_utf8_general_ci,*val))
579
 
      {
580
 
        make_truncated_value_warning(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
581
 
                                     val_begin, length,
582
 
                                     cached_timestamp_type, NULL);
583
 
        break;
584
 
      }
585
 
    } while (++val != val_end);
586
 
  }
587
 
  return(0);
588
 
 
589
 
err:
590
 
  {
591
 
    char buff[128];
592
 
    strmake(buff, val_begin, cmin(length, (uint)sizeof(buff)-1));
593
 
    push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
594
 
                        ER_WRONG_VALUE_FOR_TYPE, ER(ER_WRONG_VALUE_FOR_TYPE),
595
 
                        date_time_type, buff, "str_to_date");
596
 
  }
597
 
  return(1);
598
 
}
599
 
 
600
 
 
601
 
/**
602
 
  Create a formated date/time value in a string.
603
 
*/
604
 
 
605
 
bool make_date_time(DATE_TIME_FORMAT *format, DRIZZLE_TIME *l_time,
606
 
                    enum enum_drizzle_timestamp_type type, String *str)
607
 
{
608
 
  char intbuff[15];
609
 
  uint32_t hours_i;
610
 
  uint32_t weekday;
611
 
  ulong length;
612
 
  const char *ptr, *end;
613
 
  THD *thd= current_thd;
614
 
  MY_LOCALE *locale= thd->variables.lc_time_names;
615
 
 
616
 
  str->length(0);
617
 
 
618
 
  if (l_time->neg)
619
 
    str->append('-');
620
 
  
621
 
  end= (ptr= format->format.str) + format->format.length;
622
 
  for (; ptr != end ; ptr++)
623
 
  {
624
 
    if (*ptr != '%' || ptr+1 == end)
625
 
      str->append(*ptr);
626
 
    else
627
 
    {
628
 
      switch (*++ptr) {
629
 
      case 'M':
630
 
        if (!l_time->month)
631
 
          return 1;
632
 
        str->append(locale->month_names->type_names[l_time->month-1],
633
 
                    strlen(locale->month_names->type_names[l_time->month-1]),
634
 
                    system_charset_info);
635
 
        break;
636
 
      case 'b':
637
 
        if (!l_time->month)
638
 
          return 1;
639
 
        str->append(locale->ab_month_names->type_names[l_time->month-1],
640
 
                    strlen(locale->ab_month_names->type_names[l_time->month-1]),
641
 
                    system_charset_info);
642
 
        break;
643
 
      case 'W':
644
 
        if (type == DRIZZLE_TIMESTAMP_TIME)
645
 
          return 1;
646
 
        weekday= calc_weekday(calc_daynr(l_time->year,l_time->month,
647
 
                              l_time->day),0);
648
 
        str->append(locale->day_names->type_names[weekday],
649
 
                    strlen(locale->day_names->type_names[weekday]),
650
 
                    system_charset_info);
651
 
        break;
652
 
      case 'a':
653
 
        if (type == DRIZZLE_TIMESTAMP_TIME)
654
 
          return 1;
655
 
        weekday=calc_weekday(calc_daynr(l_time->year,l_time->month,
656
 
                             l_time->day),0);
657
 
        str->append(locale->ab_day_names->type_names[weekday],
658
 
                    strlen(locale->ab_day_names->type_names[weekday]),
659
 
                    system_charset_info);
660
 
        break;
661
 
      case 'D':
662
 
        if (type == DRIZZLE_TIMESTAMP_TIME)
663
 
          return 1;
664
 
        length= int10_to_str(l_time->day, intbuff, 10) - intbuff;
665
 
        str->append_with_prefill(intbuff, length, 1, '0');
666
 
        if (l_time->day >= 10 &&  l_time->day <= 19)
667
 
          str->append(STRING_WITH_LEN("th"));
668
 
        else
669
 
        {
670
 
          switch (l_time->day %10) {
671
 
          case 1:
672
 
            str->append(STRING_WITH_LEN("st"));
673
 
            break;
674
 
          case 2:
675
 
            str->append(STRING_WITH_LEN("nd"));
676
 
            break;
677
 
          case 3:
678
 
            str->append(STRING_WITH_LEN("rd"));
679
 
            break;
680
 
          default:
681
 
            str->append(STRING_WITH_LEN("th"));
682
 
            break;
683
 
          }
684
 
        }
685
 
        break;
686
 
      case 'Y':
687
 
        length= int10_to_str(l_time->year, intbuff, 10) - intbuff;
688
 
        str->append_with_prefill(intbuff, length, 4, '0');
689
 
        break;
690
 
      case 'y':
691
 
        length= int10_to_str(l_time->year%100, intbuff, 10) - intbuff;
692
 
        str->append_with_prefill(intbuff, length, 2, '0');
693
 
        break;
694
 
      case 'm':
695
 
        length= int10_to_str(l_time->month, intbuff, 10) - intbuff;
696
 
        str->append_with_prefill(intbuff, length, 2, '0');
697
 
        break;
698
 
      case 'c':
699
 
        length= int10_to_str(l_time->month, intbuff, 10) - intbuff;
700
 
        str->append_with_prefill(intbuff, length, 1, '0');
701
 
        break;
702
 
      case 'd':
703
 
        length= int10_to_str(l_time->day, intbuff, 10) - intbuff;
704
 
        str->append_with_prefill(intbuff, length, 2, '0');
705
 
        break;
706
 
      case 'e':
707
 
        length= int10_to_str(l_time->day, intbuff, 10) - intbuff;
708
 
        str->append_with_prefill(intbuff, length, 1, '0');
709
 
        break;
710
 
      case 'f':
711
 
        length= int10_to_str(l_time->second_part, intbuff, 10) - intbuff;
712
 
        str->append_with_prefill(intbuff, length, 6, '0');
713
 
        break;
714
 
      case 'H':
715
 
        length= int10_to_str(l_time->hour, intbuff, 10) - intbuff;
716
 
        str->append_with_prefill(intbuff, length, 2, '0');
717
 
        break;
718
 
      case 'h':
719
 
      case 'I':
720
 
        hours_i= (l_time->hour%24 + 11)%12+1;
721
 
        length= int10_to_str(hours_i, intbuff, 10) - intbuff;
722
 
        str->append_with_prefill(intbuff, length, 2, '0');
723
 
        break;
724
 
      case 'i':                                 /* minutes */
725
 
        length= int10_to_str(l_time->minute, intbuff, 10) - intbuff;
726
 
        str->append_with_prefill(intbuff, length, 2, '0');
727
 
        break;
728
 
      case 'j':
729
 
        if (type == DRIZZLE_TIMESTAMP_TIME)
730
 
          return 1;
731
 
        length= int10_to_str(calc_daynr(l_time->year,l_time->month,
732
 
                                        l_time->day) - 
733
 
                     calc_daynr(l_time->year,1,1) + 1, intbuff, 10) - intbuff;
734
 
        str->append_with_prefill(intbuff, length, 3, '0');
735
 
        break;
736
 
      case 'k':
737
 
        length= int10_to_str(l_time->hour, intbuff, 10) - intbuff;
738
 
        str->append_with_prefill(intbuff, length, 1, '0');
739
 
        break;
740
 
      case 'l':
741
 
        hours_i= (l_time->hour%24 + 11)%12+1;
742
 
        length= int10_to_str(hours_i, intbuff, 10) - intbuff;
743
 
        str->append_with_prefill(intbuff, length, 1, '0');
744
 
        break;
745
 
      case 'p':
746
 
        hours_i= l_time->hour%24;
747
 
        str->append(hours_i < 12 ? "AM" : "PM",2);
748
 
        break;
749
 
      case 'r':
750
 
        length= sprintf(intbuff, 
751
 
                    ((l_time->hour % 24) < 12) ?
752
 
                    "%02d:%02d:%02d AM" : "%02d:%02d:%02d PM",
753
 
                    (l_time->hour+11)%12+1,
754
 
                    l_time->minute,
755
 
                    l_time->second);
756
 
        str->append(intbuff, length);
757
 
        break;
758
 
      case 'S':
759
 
      case 's':
760
 
        length= int10_to_str(l_time->second, intbuff, 10) - intbuff;
761
 
        str->append_with_prefill(intbuff, length, 2, '0');
762
 
        break;
763
 
      case 'T':
764
 
        length= sprintf(intbuff, 
765
 
                    "%02d:%02d:%02d", 
766
 
                    l_time->hour, 
767
 
                    l_time->minute,
768
 
                    l_time->second);
769
 
        str->append(intbuff, length);
770
 
        break;
771
 
      case 'U':
772
 
      case 'u':
773
 
      {
774
 
        uint32_t year;
775
 
        if (type == DRIZZLE_TIMESTAMP_TIME)
776
 
          return 1;
777
 
        length= int10_to_str(calc_week(l_time,
778
 
                                       (*ptr) == 'U' ?
779
 
                                       WEEK_FIRST_WEEKDAY : WEEK_MONDAY_FIRST,
780
 
                                       &year),
781
 
                             intbuff, 10) - intbuff;
782
 
        str->append_with_prefill(intbuff, length, 2, '0');
783
 
      }
784
 
      break;
785
 
      case 'v':
786
 
      case 'V':
787
 
      {
788
 
        uint32_t year;
789
 
        if (type == DRIZZLE_TIMESTAMP_TIME)
790
 
          return 1;
791
 
        length= int10_to_str(calc_week(l_time,
792
 
                                       ((*ptr) == 'V' ?
793
 
                                        (WEEK_YEAR | WEEK_FIRST_WEEKDAY) :
794
 
                                        (WEEK_YEAR | WEEK_MONDAY_FIRST)),
795
 
                                       &year),
796
 
                             intbuff, 10) - intbuff;
797
 
        str->append_with_prefill(intbuff, length, 2, '0');
798
 
      }
799
 
      break;
800
 
      case 'x':
801
 
      case 'X':
802
 
      {
803
 
        uint32_t year;
804
 
        if (type == DRIZZLE_TIMESTAMP_TIME)
805
 
          return 1;
806
 
        (void) calc_week(l_time,
807
 
                         ((*ptr) == 'X' ?
808
 
                          WEEK_YEAR | WEEK_FIRST_WEEKDAY :
809
 
                          WEEK_YEAR | WEEK_MONDAY_FIRST),
810
 
                         &year);
811
 
        length= int10_to_str(year, intbuff, 10) - intbuff;
812
 
        str->append_with_prefill(intbuff, length, 4, '0');
813
 
      }
814
 
      break;
815
 
      case 'w':
816
 
        if (type == DRIZZLE_TIMESTAMP_TIME)
817
 
          return 1;
818
 
        weekday=calc_weekday(calc_daynr(l_time->year,l_time->month,
819
 
                                        l_time->day),1);
820
 
        length= int10_to_str(weekday, intbuff, 10) - intbuff;
821
 
        str->append_with_prefill(intbuff, length, 1, '0');
822
 
        break;
823
 
 
824
 
      default:
825
 
        str->append(*ptr);
826
 
        break;
827
 
      }
828
 
    }
829
 
  }
830
 
  return 0;
831
 
}
832
 
 
833
 
 
834
 
/**
835
 
  @details
836
 
  Get a array of positive numbers from a string object.
837
 
  Each number is separated by 1 non digit character
838
 
  Return error if there is too many numbers.
839
 
  If there is too few numbers, assume that the numbers are left out
840
 
  from the high end. This allows one to give:
841
 
  DAY_TO_SECOND as "D MM:HH:SS", "MM:HH:SS" "HH:SS" or as seconds.
842
 
 
843
 
  @param length:         length of str
844
 
  @param cs:             charset of str
845
 
  @param values:         array of results
846
 
  @param count:          count of elements in result array
847
 
  @param transform_msec: if value is true we suppose
848
 
                         that the last part of string value is microseconds
849
 
                         and we should transform value to six digit value.
850
 
                         For example, '1.1' -> '1.100000'
851
 
*/
852
 
 
853
 
static bool get_interval_info(const char *str,uint32_t length, const CHARSET_INFO * const cs,
854
 
                              uint32_t count, uint64_t *values,
855
 
                              bool transform_msec)
856
 
{
857
 
  const char *end=str+length;
858
 
  uint32_t i;
859
 
  while (str != end && !my_isdigit(cs,*str))
860
 
    str++;
861
 
 
862
 
  for (i=0 ; i < count ; i++)
863
 
  {
864
 
    int64_t value;
865
 
    const char *start= str;
866
 
    for (value=0; str != end && my_isdigit(cs,*str) ; str++)
867
 
      value= value * 10L + (int64_t) (*str - '0');
868
 
    if (transform_msec && i == count - 1) // microseconds always last
869
 
    {
870
 
      long msec_length= 6 - (str - start);
871
 
      if (msec_length > 0)
872
 
        value*= (long) log_10_int[msec_length];
873
 
    }
874
 
    values[i]= value;
875
 
    while (str != end && !my_isdigit(cs,*str))
876
 
      str++;
877
 
    if (str == end && i != count-1)
878
 
    {
879
 
      i++;
880
 
      /* Change values[0...i-1] -> values[0...count-1] */
881
 
      bmove_upp((unsigned char*) (values+count), (unsigned char*) (values+i),
882
 
                sizeof(*values)*i);
883
 
      memset(values, 0, sizeof(*values)*(count-i));
884
 
      break;
885
 
    }
886
 
  }
887
 
  return (str != end);
888
 
}
889
 
 
890
 
 
891
 
int64_t Item_func_period_add::val_int()
892
 
{
893
 
  assert(fixed == 1);
894
 
  ulong period=(ulong) args[0]->val_int();
895
 
  int months=(int) args[1]->val_int();
896
 
 
897
 
  if ((null_value=args[0]->null_value || args[1]->null_value) ||
898
 
      period == 0L)
899
 
    return 0; /* purecov: inspected */
900
 
  return (int64_t)
901
 
    convert_month_to_period((uint) ((int) convert_period_to_month(period)+
902
 
                                    months));
903
 
}
904
 
 
905
 
 
906
 
int64_t Item_func_period_diff::val_int()
907
 
{
908
 
  assert(fixed == 1);
909
 
  ulong period1=(ulong) args[0]->val_int();
910
 
  ulong period2=(ulong) args[1]->val_int();
911
 
 
912
 
  if ((null_value=args[0]->null_value || args[1]->null_value))
913
 
    return 0; /* purecov: inspected */
914
 
  return (int64_t) ((long) convert_period_to_month(period1)-
915
 
                     (long) convert_period_to_month(period2));
916
 
}
917
 
 
918
 
 
919
 
 
920
 
int64_t Item_func_to_days::val_int()
921
 
{
922
 
  assert(fixed == 1);
923
 
  DRIZZLE_TIME ltime;
924
 
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
925
 
    return 0;
926
 
  return (int64_t) calc_daynr(ltime.year,ltime.month,ltime.day);
927
 
}
928
 
 
929
 
 
930
 
/*
931
 
  Get information about this Item tree monotonicity
932
 
 
933
 
  SYNOPSIS
934
 
    Item_func_to_days::get_monotonicity_info()
935
 
 
936
 
  DESCRIPTION
937
 
  Get information about monotonicity of the function represented by this item
938
 
  tree.
939
 
 
940
 
  RETURN
941
 
    See enum_monotonicity_info.
942
 
*/
943
 
 
944
 
enum_monotonicity_info Item_func_to_days::get_monotonicity_info() const
945
 
{
946
 
  if (args[0]->type() == Item::FIELD_ITEM)
947
 
  {
948
 
    if (args[0]->field_type() == DRIZZLE_TYPE_NEWDATE)
949
 
      return MONOTONIC_STRICT_INCREASING;
950
 
    if (args[0]->field_type() == DRIZZLE_TYPE_DATETIME)
951
 
      return MONOTONIC_INCREASING;
952
 
  }
953
 
  return NON_MONOTONIC;
954
 
}
955
 
 
956
 
 
957
 
int64_t Item_func_to_days::val_int_endpoint(bool left_endp, bool *incl_endp)
958
 
{
959
 
  assert(fixed == 1);
960
 
  DRIZZLE_TIME ltime;
961
 
  int64_t res;
962
 
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
963
 
  {
964
 
    /* got NULL, leave the incl_endp intact */
965
 
    return INT64_MIN;
966
 
  }
967
 
  res=(int64_t) calc_daynr(ltime.year,ltime.month,ltime.day);
968
 
  
969
 
  if (args[0]->field_type() == DRIZZLE_TYPE_NEWDATE)
970
 
  {
971
 
    // TO_DAYS() is strictly monotonic for dates, leave incl_endp intact
972
 
    return res;
973
 
  }
974
 
 
975
 
  /*
976
 
    Handle the special but practically useful case of datetime values that
977
 
    point to day bound ("strictly less" comparison stays intact):
978
 
 
979
 
      col < '2007-09-15 00:00:00'  -> TO_DAYS(col) <  TO_DAYS('2007-09-15')
980
 
 
981
 
    which is different from the general case ("strictly less" changes to
982
 
    "less or equal"):
983
 
 
984
 
      col < '2007-09-15 12:34:56'  -> TO_DAYS(col) <= TO_DAYS('2007-09-15')
985
 
  */
986
 
  if (!left_endp && !(ltime.hour || ltime.minute || ltime.second ||
987
 
                      ltime.second_part))
988
 
    ; /* do nothing */
989
 
  else
990
 
    *incl_endp= true;
991
 
  return res;
992
 
}
993
 
 
994
 
 
995
 
int64_t Item_func_dayofyear::val_int()
996
 
{
997
 
  assert(fixed == 1);
998
 
  DRIZZLE_TIME ltime;
999
 
  if (get_arg0_date(&ltime,TIME_NO_ZERO_DATE))
1000
 
    return 0;
1001
 
  return (int64_t) calc_daynr(ltime.year,ltime.month,ltime.day) -
1002
 
    calc_daynr(ltime.year,1,1) + 1;
1003
 
}
1004
 
 
1005
 
int64_t Item_func_dayofmonth::val_int()
1006
 
{
1007
 
  assert(fixed == 1);
1008
 
  DRIZZLE_TIME ltime;
1009
 
  (void) get_arg0_date(&ltime, TIME_FUZZY_DATE);
1010
 
  return (int64_t) ltime.day;
1011
 
}
1012
 
 
1013
 
int64_t Item_func_month::val_int()
1014
 
{
1015
 
  assert(fixed == 1);
1016
 
  DRIZZLE_TIME ltime;
1017
 
  (void) get_arg0_date(&ltime, TIME_FUZZY_DATE);
1018
 
  return (int64_t) ltime.month;
1019
 
}
1020
 
 
1021
 
 
1022
 
String* Item_func_monthname::val_str(String* str)
1023
 
{
1024
 
  assert(fixed == 1);
1025
 
  const char *month_name;
1026
 
  uint32_t   month= (uint) val_int();
1027
 
  THD *thd= current_thd;
1028
 
 
1029
 
  if (null_value || !month)
1030
 
  {
1031
 
    null_value=1;
1032
 
    return (String*) 0;
1033
 
  }
1034
 
  null_value=0;
1035
 
  month_name= thd->variables.lc_time_names->month_names->type_names[month-1];
1036
 
  str->set(month_name, strlen(month_name), system_charset_info);
1037
 
  return str;
1038
 
}
1039
 
 
1040
 
 
1041
 
/**
1042
 
  Returns the quarter of the year.
1043
 
*/
1044
 
 
1045
 
int64_t Item_func_quarter::val_int()
1046
 
{
1047
 
  assert(fixed == 1);
1048
 
  DRIZZLE_TIME ltime;
1049
 
  if (get_arg0_date(&ltime, TIME_FUZZY_DATE))
1050
 
    return 0;
1051
 
  return (int64_t) ((ltime.month+2)/3);
1052
 
}
1053
 
 
1054
 
int64_t Item_func_hour::val_int()
1055
 
{
1056
 
  assert(fixed == 1);
1057
 
  DRIZZLE_TIME ltime;
1058
 
  (void) get_arg0_time(&ltime);
1059
 
  return ltime.hour;
1060
 
}
1061
 
 
1062
 
int64_t Item_func_minute::val_int()
1063
 
{
1064
 
  assert(fixed == 1);
1065
 
  DRIZZLE_TIME ltime;
1066
 
  (void) get_arg0_time(&ltime);
1067
 
  return ltime.minute;
1068
 
}
1069
 
 
1070
 
/**
1071
 
  Returns the second in time_exp in the range of 0 - 59.
1072
 
*/
1073
 
int64_t Item_func_second::val_int()
1074
 
{
1075
 
  assert(fixed == 1);
1076
 
  DRIZZLE_TIME ltime;
1077
 
  (void) get_arg0_time(&ltime);
1078
 
  return ltime.second;
1079
 
}
1080
 
 
1081
 
 
1082
 
uint32_t week_mode(uint32_t mode)
1083
 
{
1084
 
  uint32_t week_format= (mode & 7);
1085
 
  if (!(week_format & WEEK_MONDAY_FIRST))
1086
 
    week_format^= WEEK_FIRST_WEEKDAY;
1087
 
  return week_format;
1088
 
}
1089
 
 
1090
 
/**
1091
 
 @verbatim
1092
 
  The bits in week_format(for calc_week() function) has the following meaning:
1093
 
   WEEK_MONDAY_FIRST (0)  If not set    Sunday is first day of week
1094
 
                          If set        Monday is first day of week
1095
 
   WEEK_YEAR (1)          If not set    Week is in range 0-53
1096
 
 
1097
 
        Week 0 is returned for the the last week of the previous year (for
1098
 
        a date at start of january) In this case one can get 53 for the
1099
 
        first week of next year.  This flag ensures that the week is
1100
 
        relevant for the given year. Note that this flag is only
1101
 
        releveant if WEEK_JANUARY is not set.
1102
 
 
1103
 
                          If set         Week is in range 1-53.
1104
 
 
1105
 
        In this case one may get week 53 for a date in January (when
1106
 
        the week is that last week of previous year) and week 1 for a
1107
 
        date in December.
1108
 
 
1109
 
  WEEK_FIRST_WEEKDAY (2)  If not set    Weeks are numbered according
1110
 
                                        to ISO 8601:1988
1111
 
                          If set        The week that contains the first
1112
 
                                        'first-day-of-week' is week 1.
1113
 
        
1114
 
        ISO 8601:1988 means that if the week containing January 1 has
1115
 
        four or more days in the new year, then it is week 1;
1116
 
        Otherwise it is the last week of the previous year, and the
1117
 
        next week is week 1.
1118
 
 @endverbatim
1119
 
*/
1120
 
 
1121
 
int64_t Item_func_week::val_int()
1122
 
{
1123
 
  assert(fixed == 1);
1124
 
  uint32_t year;
1125
 
  DRIZZLE_TIME ltime;
1126
 
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
1127
 
    return 0;
1128
 
  return (int64_t) calc_week(&ltime,
1129
 
                              week_mode((uint) args[1]->val_int()),
1130
 
                              &year);
1131
 
}
1132
 
 
1133
 
 
1134
 
int64_t Item_func_yearweek::val_int()
1135
 
{
1136
 
  assert(fixed == 1);
1137
 
  uint32_t year,week;
1138
 
  DRIZZLE_TIME ltime;
1139
 
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
1140
 
    return 0;
1141
 
  week= calc_week(&ltime, 
1142
 
                  (week_mode((uint) args[1]->val_int()) | WEEK_YEAR),
1143
 
                  &year);
1144
 
  return week+year*100;
1145
 
}
1146
 
 
1147
 
 
1148
 
int64_t Item_func_weekday::val_int()
1149
 
{
1150
 
  assert(fixed == 1);
1151
 
  DRIZZLE_TIME ltime;
1152
 
  
1153
 
  if (get_arg0_date(&ltime, TIME_NO_ZERO_DATE))
1154
 
    return 0;
1155
 
 
1156
 
  return (int64_t) calc_weekday(calc_daynr(ltime.year, ltime.month,
1157
 
                                            ltime.day),
1158
 
                                 odbc_type) + test(odbc_type);
1159
 
}
1160
 
 
1161
 
 
1162
 
String* Item_func_dayname::val_str(String* str)
1163
 
{
1164
 
  assert(fixed == 1);
1165
 
  uint32_t weekday=(uint) val_int();            // Always Item_func_daynr()
1166
 
  const char *day_name;
1167
 
  THD *thd= current_thd;
1168
 
 
1169
 
  if (null_value)
1170
 
    return (String*) 0;
1171
 
  
1172
 
  day_name= thd->variables.lc_time_names->day_names->type_names[weekday];
1173
 
  str->set(day_name, strlen(day_name), system_charset_info);
1174
 
  return str;
1175
 
}
1176
 
 
1177
 
 
1178
 
int64_t Item_func_year::val_int()
1179
 
{
1180
 
  assert(fixed == 1);
1181
 
  DRIZZLE_TIME ltime;
1182
 
  (void) get_arg0_date(&ltime, TIME_FUZZY_DATE);
1183
 
  return (int64_t) ltime.year;
1184
 
}
1185
 
 
1186
 
 
1187
 
/*
1188
 
  Get information about this Item tree monotonicity
1189
 
 
1190
 
  SYNOPSIS
1191
 
    Item_func_year::get_monotonicity_info()
1192
 
 
1193
 
  DESCRIPTION
1194
 
  Get information about monotonicity of the function represented by this item
1195
 
  tree.
1196
 
 
1197
 
  RETURN
1198
 
    See enum_monotonicity_info.
1199
 
*/
1200
 
 
1201
 
enum_monotonicity_info Item_func_year::get_monotonicity_info() const
1202
 
{
1203
 
  if (args[0]->type() == Item::FIELD_ITEM &&
1204
 
      (args[0]->field_type() == DRIZZLE_TYPE_NEWDATE ||
1205
 
       args[0]->field_type() == DRIZZLE_TYPE_DATETIME))
1206
 
    return MONOTONIC_INCREASING;
1207
 
  return NON_MONOTONIC;
1208
 
}
1209
 
 
1210
 
 
1211
 
int64_t Item_func_year::val_int_endpoint(bool left_endp, bool *incl_endp)
1212
 
{
1213
 
  assert(fixed == 1);
1214
 
  DRIZZLE_TIME ltime;
1215
 
  if (get_arg0_date(&ltime, TIME_FUZZY_DATE))
1216
 
  {
1217
 
    /* got NULL, leave the incl_endp intact */
1218
 
    return INT64_MIN;
1219
 
  }
1220
 
 
1221
 
  /*
1222
 
    Handle the special but practically useful case of datetime values that
1223
 
    point to year bound ("strictly less" comparison stays intact) :
1224
 
 
1225
 
      col < '2007-01-01 00:00:00'  -> YEAR(col) <  2007
1226
 
 
1227
 
    which is different from the general case ("strictly less" changes to
1228
 
    "less or equal"):
1229
 
 
1230
 
      col < '2007-09-15 23:00:00'  -> YEAR(col) <= 2007
1231
 
  */
1232
 
  if (!left_endp && ltime.day == 1 && ltime.month == 1 && 
1233
 
      !(ltime.hour || ltime.minute || ltime.second || ltime.second_part))
1234
 
    ; /* do nothing */
1235
 
  else
1236
 
    *incl_endp= true;
1237
 
  return ltime.year;
1238
 
}
1239
 
 
1240
 
 
1241
 
int64_t Item_func_unix_timestamp::val_int()
1242
 
{
1243
 
  DRIZZLE_TIME ltime;
1244
 
  bool not_used;
1245
 
  
1246
 
  assert(fixed == 1);
1247
 
  if (arg_count == 0)
1248
 
    return (int64_t) current_thd->query_start();
1249
 
  if (args[0]->type() == FIELD_ITEM)
1250
 
  {                                             // Optimize timestamp field
1251
 
    Field *field=((Item_field*) args[0])->field;
1252
 
    if (field->type() == DRIZZLE_TYPE_TIMESTAMP)
1253
 
      return ((Field_timestamp*) field)->get_timestamp(&null_value);
1254
 
  }
1255
 
  
1256
 
  if (get_arg0_date(&ltime, 0))
1257
 
  {
1258
 
    /*
1259
 
      We have to set null_value again because get_arg0_date will also set it
1260
 
      to true if we have wrong datetime parameter (and we should return 0 in 
1261
 
      this case).
1262
 
    */
1263
 
    null_value= args[0]->null_value;
1264
 
    return 0;
1265
 
  }
1266
 
  
1267
 
  return (int64_t) TIME_to_timestamp(current_thd, &ltime, &not_used);
1268
 
}
1269
 
 
1270
 
 
1271
 
int64_t Item_func_time_to_sec::val_int()
1272
 
{
1273
 
  assert(fixed == 1);
1274
 
  DRIZZLE_TIME ltime;
1275
 
  int64_t seconds;
1276
 
  (void) get_arg0_time(&ltime);
1277
 
  seconds=ltime.hour*3600L+ltime.minute*60+ltime.second;
1278
 
  return ltime.neg ? -seconds : seconds;
1279
 
}
1280
 
 
1281
 
 
1282
 
/**
1283
 
  Convert a string to a interval value.
1284
 
 
1285
 
  To make code easy, allow interval objects without separators.
1286
 
*/
1287
 
 
1288
 
bool get_interval_value(Item *args,interval_type int_type,
1289
 
                               String *str_value, INTERVAL *interval)
1290
 
{
1291
 
  uint64_t array[5];
1292
 
  int64_t value= 0;
1293
 
  const char *str= NULL;
1294
 
  size_t length= 0;
1295
 
  const CHARSET_INFO * const cs= str_value->charset();
1296
 
 
1297
 
  memset(interval, 0, sizeof(*interval));
1298
 
  if ((int) int_type <= INTERVAL_MICROSECOND)
1299
 
  {
1300
 
    value= args->val_int();
1301
 
    if (args->null_value)
1302
 
      return 1;
1303
 
    if (value < 0)
1304
 
    {
1305
 
      interval->neg=1;
1306
 
      value= -value;
1307
 
    }
1308
 
  }
1309
 
  else
1310
 
  {
1311
 
    String *res;
1312
 
    if (!(res=args->val_str(str_value)))
1313
 
      return (1);
1314
 
 
1315
 
    /* record negative intervalls in interval->neg */
1316
 
    str=res->ptr();
1317
 
    const char *end=str+res->length();
1318
 
    while (str != end && my_isspace(cs,*str))
1319
 
      str++;
1320
 
    if (str != end && *str == '-')
1321
 
    {
1322
 
      interval->neg=1;
1323
 
      str++;
1324
 
    }
1325
 
    length= (size_t) (end-str);         // Set up pointers to new str
1326
 
  }
1327
 
 
1328
 
  switch (int_type) {
1329
 
  case INTERVAL_YEAR:
1330
 
    interval->year= (ulong) value;
1331
 
    break;
1332
 
  case INTERVAL_QUARTER:
1333
 
    interval->month= (ulong)(value*3);
1334
 
    break;
1335
 
  case INTERVAL_MONTH:
1336
 
    interval->month= (ulong) value;
1337
 
    break;
1338
 
  case INTERVAL_WEEK:
1339
 
    interval->day= (ulong)(value*7);
1340
 
    break;
1341
 
  case INTERVAL_DAY:
1342
 
    interval->day= (ulong) value;
1343
 
    break;
1344
 
  case INTERVAL_HOUR:
1345
 
    interval->hour= (ulong) value;
1346
 
    break;
1347
 
  case INTERVAL_MICROSECOND:
1348
 
    interval->second_part=value;
1349
 
    break;
1350
 
  case INTERVAL_MINUTE:
1351
 
    interval->minute=value;
1352
 
    break;
1353
 
  case INTERVAL_SECOND:
1354
 
    interval->second=value;
1355
 
    break;
1356
 
  case INTERVAL_YEAR_MONTH:                     // Allow YEAR-MONTH YYYYYMM
1357
 
    if (get_interval_info(str,length,cs,2,array,0))
1358
 
      return (1);
1359
 
    interval->year=  (ulong) array[0];
1360
 
    interval->month= (ulong) array[1];
1361
 
    break;
1362
 
  case INTERVAL_DAY_HOUR:
1363
 
    if (get_interval_info(str,length,cs,2,array,0))
1364
 
      return (1);
1365
 
    interval->day=  (ulong) array[0];
1366
 
    interval->hour= (ulong) array[1];
1367
 
    break;
1368
 
  case INTERVAL_DAY_MICROSECOND:
1369
 
    if (get_interval_info(str,length,cs,5,array,1))
1370
 
      return (1);
1371
 
    interval->day=    (ulong) array[0];
1372
 
    interval->hour=   (ulong) array[1];
1373
 
    interval->minute= array[2];
1374
 
    interval->second= array[3];
1375
 
    interval->second_part= array[4];
1376
 
    break;
1377
 
  case INTERVAL_DAY_MINUTE:
1378
 
    if (get_interval_info(str,length,cs,3,array,0))
1379
 
      return (1);
1380
 
    interval->day=    (ulong) array[0];
1381
 
    interval->hour=   (ulong) array[1];
1382
 
    interval->minute= array[2];
1383
 
    break;
1384
 
  case INTERVAL_DAY_SECOND:
1385
 
    if (get_interval_info(str,length,cs,4,array,0))
1386
 
      return (1);
1387
 
    interval->day=    (ulong) array[0];
1388
 
    interval->hour=   (ulong) array[1];
1389
 
    interval->minute= array[2];
1390
 
    interval->second= array[3];
1391
 
    break;
1392
 
  case INTERVAL_HOUR_MICROSECOND:
1393
 
    if (get_interval_info(str,length,cs,4,array,1))
1394
 
      return (1);
1395
 
    interval->hour=   (ulong) array[0];
1396
 
    interval->minute= array[1];
1397
 
    interval->second= array[2];
1398
 
    interval->second_part= array[3];
1399
 
    break;
1400
 
  case INTERVAL_HOUR_MINUTE:
1401
 
    if (get_interval_info(str,length,cs,2,array,0))
1402
 
      return (1);
1403
 
    interval->hour=   (ulong) array[0];
1404
 
    interval->minute= array[1];
1405
 
    break;
1406
 
  case INTERVAL_HOUR_SECOND:
1407
 
    if (get_interval_info(str,length,cs,3,array,0))
1408
 
      return (1);
1409
 
    interval->hour=   (ulong) array[0];
1410
 
    interval->minute= array[1];
1411
 
    interval->second= array[2];
1412
 
    break;
1413
 
  case INTERVAL_MINUTE_MICROSECOND:
1414
 
    if (get_interval_info(str,length,cs,3,array,1))
1415
 
      return (1);
1416
 
    interval->minute= array[0];
1417
 
    interval->second= array[1];
1418
 
    interval->second_part= array[2];
1419
 
    break;
1420
 
  case INTERVAL_MINUTE_SECOND:
1421
 
    if (get_interval_info(str,length,cs,2,array,0))
1422
 
      return (1);
1423
 
    interval->minute= array[0];
1424
 
    interval->second= array[1];
1425
 
    break;
1426
 
  case INTERVAL_SECOND_MICROSECOND:
1427
 
    if (get_interval_info(str,length,cs,2,array,1))
1428
 
      return (1);
1429
 
    interval->second= array[0];
1430
 
    interval->second_part= array[1];
1431
 
    break;
1432
 
  case INTERVAL_LAST: /* purecov: begin deadcode */
1433
 
    assert(0); 
1434
 
    break;            /* purecov: end */
1435
 
  }
1436
 
  return 0;
1437
 
}
1438
 
 
1439
 
 
1440
 
String *Item_date::val_str(String *str)
1441
 
{
1442
 
  assert(fixed == 1);
1443
 
  DRIZZLE_TIME ltime;
1444
 
  if (get_date(&ltime, TIME_FUZZY_DATE))
1445
 
    return (String *) 0;
1446
 
  if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
1447
 
  {
1448
 
    null_value= 1;
1449
 
    return (String *) 0;
1450
 
  }
1451
 
  make_date((DATE_TIME_FORMAT *) 0, &ltime, str);
1452
 
  return str;
1453
 
}
1454
 
 
1455
 
 
1456
 
int64_t Item_date::val_int()
1457
 
{
1458
 
  assert(fixed == 1);
1459
 
  DRIZZLE_TIME ltime;
1460
 
  if (get_date(&ltime, TIME_FUZZY_DATE))
1461
 
    return 0;
1462
 
  return (int64_t) (ltime.year*10000L+ltime.month*100+ltime.day);
1463
 
}
1464
 
 
1465
 
 
1466
 
bool Item_func_from_days::get_date(DRIZZLE_TIME *ltime, uint32_t fuzzy_date __attribute__((unused)))
1467
 
{
1468
 
  int64_t value=args[0]->val_int();
1469
 
  if ((null_value=args[0]->null_value))
1470
 
    return 1;
1471
 
  memset(ltime, 0, sizeof(DRIZZLE_TIME));
1472
 
  get_date_from_daynr((long) value, &ltime->year, &ltime->month, &ltime->day);
1473
 
  ltime->time_type= DRIZZLE_TIMESTAMP_DATE;
1474
 
  return 0;
1475
 
}
1476
 
 
1477
 
 
1478
 
void Item_func_curdate::fix_length_and_dec()
1479
 
{
1480
 
  collation.set(&my_charset_bin);
1481
 
  decimals=0; 
1482
 
  max_length=MAX_DATE_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
1483
 
 
1484
 
  store_now_in_TIME(&ltime);
1485
 
  
1486
 
  /* We don't need to set second_part and neg because they already 0 */
1487
 
  ltime.hour= ltime.minute= ltime.second= 0;
1488
 
  ltime.time_type= DRIZZLE_TIMESTAMP_DATE;
1489
 
  value= (int64_t) TIME_to_uint64_t_date(&ltime);
1490
 
}
1491
 
 
1492
 
String *Item_func_curdate::val_str(String *str)
1493
 
{
1494
 
  assert(fixed == 1);
1495
 
  if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
1496
 
  {
1497
 
    null_value= 1;
1498
 
    return (String *) 0;
1499
 
  }
1500
 
  make_date((DATE_TIME_FORMAT *) 0, &ltime, str);
1501
 
  return str;
1502
 
}
1503
 
 
1504
 
/**
1505
 
    Converts current time in my_time_t to DRIZZLE_TIME represenatation for local
1506
 
    time zone. Defines time zone (local) used for whole CURDATE function.
1507
 
*/
1508
 
void Item_func_curdate_local::store_now_in_TIME(DRIZZLE_TIME *now_time)
1509
 
{
1510
 
  THD *thd= current_thd;
1511
 
  thd->variables.time_zone->gmt_sec_to_TIME(now_time, 
1512
 
                                             (my_time_t)thd->query_start());
1513
 
  thd->time_zone_used= 1;
1514
 
}
1515
 
 
1516
 
 
1517
 
/**
1518
 
    Converts current time in my_time_t to DRIZZLE_TIME represenatation for UTC
1519
 
    time zone. Defines time zone (UTC) used for whole UTC_DATE function.
1520
 
*/
1521
 
void Item_func_curdate_utc::store_now_in_TIME(DRIZZLE_TIME *now_time)
1522
 
{
1523
 
  my_tz_UTC->gmt_sec_to_TIME(now_time, 
1524
 
                             (my_time_t)(current_thd->query_start()));
1525
 
  /* 
1526
 
    We are not flagging this query as using time zone, since it uses fixed
1527
 
    UTC-SYSTEM time-zone.
1528
 
  */
1529
 
}
1530
 
 
1531
 
 
1532
 
bool Item_func_curdate::get_date(DRIZZLE_TIME *res,
1533
 
                                 uint32_t fuzzy_date __attribute__((unused)))
1534
 
{
1535
 
  *res=ltime;
1536
 
  return 0;
1537
 
}
1538
 
 
1539
 
 
1540
 
String *Item_func_curtime::val_str(String *str __attribute__((unused)))
1541
 
{
1542
 
  assert(fixed == 1);
1543
 
  str_value.set(buff, buff_length, &my_charset_bin);
1544
 
  return &str_value;
1545
 
}
1546
 
 
1547
 
 
1548
 
void Item_func_curtime::fix_length_and_dec()
1549
 
{
1550
 
  DRIZZLE_TIME ltime;
1551
 
 
1552
 
  decimals= DATETIME_DEC;
1553
 
  collation.set(&my_charset_bin);
1554
 
  store_now_in_TIME(&ltime);
1555
 
  value= TIME_to_uint64_t_time(&ltime);
1556
 
  buff_length= (uint) my_time_to_str(&ltime, buff);
1557
 
  max_length= buff_length;
1558
 
}
1559
 
 
1560
 
 
1561
 
/**
1562
 
    Converts current time in my_time_t to DRIZZLE_TIME represenatation for local
1563
 
    time zone. Defines time zone (local) used for whole CURTIME function.
1564
 
*/
1565
 
void Item_func_curtime_local::store_now_in_TIME(DRIZZLE_TIME *now_time)
1566
 
{
1567
 
  THD *thd= current_thd;
1568
 
  thd->variables.time_zone->gmt_sec_to_TIME(now_time, 
1569
 
                                             (my_time_t)thd->query_start());
1570
 
  thd->time_zone_used= 1;
1571
 
}
1572
 
 
1573
 
 
1574
 
/**
1575
 
    Converts current time in my_time_t to DRIZZLE_TIME represenatation for UTC
1576
 
    time zone. Defines time zone (UTC) used for whole UTC_TIME function.
1577
 
*/
1578
 
void Item_func_curtime_utc::store_now_in_TIME(DRIZZLE_TIME *now_time)
1579
 
{
1580
 
  my_tz_UTC->gmt_sec_to_TIME(now_time, 
1581
 
                             (my_time_t)(current_thd->query_start()));
1582
 
  /* 
1583
 
    We are not flagging this query as using time zone, since it uses fixed
1584
 
    UTC-SYSTEM time-zone.
1585
 
  */
1586
 
}
1587
 
 
1588
 
 
1589
 
String *Item_func_now::val_str(String *str __attribute__((unused)))
1590
 
{
1591
 
  assert(fixed == 1);
1592
 
  str_value.set(buff,buff_length, &my_charset_bin);
1593
 
  return &str_value;
1594
 
}
1595
 
 
1596
 
 
1597
 
void Item_func_now::fix_length_and_dec()
1598
 
{
1599
 
  decimals= DATETIME_DEC;
1600
 
  collation.set(&my_charset_bin);
1601
 
 
1602
 
  store_now_in_TIME(&ltime);
1603
 
  value= (int64_t) TIME_to_uint64_t_datetime(&ltime);
1604
 
 
1605
 
  buff_length= (uint) my_datetime_to_str(&ltime, buff);
1606
 
  max_length= buff_length;
1607
 
}
1608
 
 
1609
 
 
1610
 
/**
1611
 
    Converts current time in my_time_t to DRIZZLE_TIME represenatation for local
1612
 
    time zone. Defines time zone (local) used for whole NOW function.
1613
 
*/
1614
 
void Item_func_now_local::store_now_in_TIME(DRIZZLE_TIME *now_time)
1615
 
{
1616
 
  THD *thd= current_thd;
1617
 
  thd->variables.time_zone->gmt_sec_to_TIME(now_time, 
1618
 
                                             (my_time_t)thd->query_start());
1619
 
  thd->time_zone_used= 1;
1620
 
}
1621
 
 
1622
 
 
1623
 
/**
1624
 
    Converts current time in my_time_t to DRIZZLE_TIME represenatation for UTC
1625
 
    time zone. Defines time zone (UTC) used for whole UTC_TIMESTAMP function.
1626
 
*/
1627
 
void Item_func_now_utc::store_now_in_TIME(DRIZZLE_TIME *now_time)
1628
 
{
1629
 
  my_tz_UTC->gmt_sec_to_TIME(now_time, 
1630
 
                             (my_time_t)(current_thd->query_start()));
1631
 
  /* 
1632
 
    We are not flagging this query as using time zone, since it uses fixed
1633
 
    UTC-SYSTEM time-zone.
1634
 
  */
1635
 
}
1636
 
 
1637
 
 
1638
 
bool Item_func_now::get_date(DRIZZLE_TIME *res,
1639
 
                             uint32_t fuzzy_date __attribute__((unused)))
1640
 
{
1641
 
  *res= ltime;
1642
 
  return 0;
1643
 
}
1644
 
 
1645
 
 
1646
 
int Item_func_now::save_in_field(Field *to, bool no_conversions __attribute__((unused)))
1647
 
{
1648
 
  to->set_notnull();
1649
 
  return to->store_time(&ltime, DRIZZLE_TIMESTAMP_DATETIME);
1650
 
}
1651
 
 
1652
 
 
1653
 
/**
1654
 
    Converts current time in my_time_t to DRIZZLE_TIME represenatation for local
1655
 
    time zone. Defines time zone (local) used for whole SYSDATE function.
1656
 
*/
1657
 
void Item_func_sysdate_local::store_now_in_TIME(DRIZZLE_TIME *now_time)
1658
 
{
1659
 
  THD *thd= current_thd;
1660
 
  thd->variables.time_zone->gmt_sec_to_TIME(now_time, (my_time_t) my_time(0));
1661
 
  thd->time_zone_used= 1;
1662
 
}
1663
 
 
1664
 
 
1665
 
String *Item_func_sysdate_local::val_str(String *str __attribute__((unused)))
1666
 
{
1667
 
  assert(fixed == 1);
1668
 
  store_now_in_TIME(&ltime);
1669
 
  buff_length= (uint) my_datetime_to_str(&ltime, buff);
1670
 
  str_value.set(buff, buff_length, &my_charset_bin);
1671
 
  return &str_value;
1672
 
}
1673
 
 
1674
 
 
1675
 
int64_t Item_func_sysdate_local::val_int()
1676
 
{
1677
 
  assert(fixed == 1);
1678
 
  store_now_in_TIME(&ltime);
1679
 
  return (int64_t) TIME_to_uint64_t_datetime(&ltime);
1680
 
}
1681
 
 
1682
 
 
1683
 
double Item_func_sysdate_local::val_real()
1684
 
{
1685
 
  assert(fixed == 1);
1686
 
  store_now_in_TIME(&ltime);
1687
 
  return uint64_t2double(TIME_to_uint64_t_datetime(&ltime));
1688
 
}
1689
 
 
1690
 
 
1691
 
void Item_func_sysdate_local::fix_length_and_dec()
1692
 
{
1693
 
  decimals= 0;
1694
 
  collation.set(&my_charset_bin);
1695
 
  max_length= MAX_DATETIME_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
1696
 
}
1697
 
 
1698
 
 
1699
 
bool Item_func_sysdate_local::get_date(DRIZZLE_TIME *res,
1700
 
                                       uint32_t fuzzy_date __attribute__((unused)))
1701
 
{
1702
 
  store_now_in_TIME(&ltime);
1703
 
  *res= ltime;
1704
 
  return 0;
1705
 
}
1706
 
 
1707
 
 
1708
 
int Item_func_sysdate_local::save_in_field(Field *to, bool no_conversions __attribute__((unused)))
1709
 
{
1710
 
  store_now_in_TIME(&ltime);
1711
 
  to->set_notnull();
1712
 
  to->store_time(&ltime, DRIZZLE_TIMESTAMP_DATETIME);
1713
 
  return 0;
1714
 
}
1715
 
 
1716
 
 
1717
 
String *Item_func_sec_to_time::val_str(String *str)
1718
 
{
1719
 
  assert(fixed == 1);
1720
 
  DRIZZLE_TIME ltime;
1721
 
  int64_t arg_val= args[0]->val_int(); 
1722
 
 
1723
 
  if ((null_value=args[0]->null_value) ||
1724
 
      str->alloc(MAX_DATE_STRING_REP_LENGTH))
1725
 
  {
1726
 
    null_value= 1;
1727
 
    return (String*) 0;
1728
 
  }
1729
 
 
1730
 
  sec_to_time(arg_val, args[0]->unsigned_flag, &ltime);
1731
 
  
1732
 
  make_time((DATE_TIME_FORMAT *) 0, &ltime, str);
1733
 
  return str;
1734
 
}
1735
 
 
1736
 
 
1737
 
int64_t Item_func_sec_to_time::val_int()
1738
 
{
1739
 
  assert(fixed == 1);
1740
 
  DRIZZLE_TIME ltime;
1741
 
  int64_t arg_val= args[0]->val_int(); 
1742
 
  
1743
 
  if ((null_value=args[0]->null_value))
1744
 
    return 0;
1745
 
 
1746
 
  sec_to_time(arg_val, args[0]->unsigned_flag, &ltime);
1747
 
 
1748
 
  return (ltime.neg ? -1 : 1) *
1749
 
    ((ltime.hour)*10000 + ltime.minute*100 + ltime.second);
1750
 
}
1751
 
 
1752
 
 
1753
 
void Item_func_date_format::fix_length_and_dec()
1754
 
{
1755
 
  THD* thd= current_thd;
1756
 
  /*
1757
 
    Must use this_item() in case it's a local SP variable
1758
 
    (for ->max_length and ->str_value)
1759
 
  */
1760
 
  Item *arg1= args[1]->this_item();
1761
 
 
1762
 
  decimals=0;
1763
 
  const CHARSET_INFO * const cs= thd->variables.collation_connection;
1764
 
  uint32_t repertoire= arg1->collation.repertoire;
1765
 
  if (!thd->variables.lc_time_names->is_ascii)
1766
 
    repertoire|= MY_REPERTOIRE_EXTENDED;
1767
 
  collation.set(cs, arg1->collation.derivation, repertoire);
1768
 
  if (arg1->type() == STRING_ITEM)
1769
 
  {                                             // Optimize the normal case
1770
 
    fixed_length=1;
1771
 
    max_length= format_length(&arg1->str_value) *
1772
 
                collation.collation->mbmaxlen;
1773
 
  }
1774
 
  else
1775
 
  {
1776
 
    fixed_length=0;
1777
 
    max_length=cmin(arg1->max_length,(uint32_t) MAX_BLOB_WIDTH) * 10 *
1778
 
                   collation.collation->mbmaxlen;
1779
 
    set_if_smaller(max_length,MAX_BLOB_WIDTH);
1780
 
  }
1781
 
  maybe_null=1;                                 // If wrong date
1782
 
}
1783
 
 
1784
 
 
1785
 
bool Item_func_date_format::eq(const Item *item, bool binary_cmp) const
1786
 
{
1787
 
  Item_func_date_format *item_func;
1788
 
 
1789
 
  if (item->type() != FUNC_ITEM)
1790
 
    return 0;
1791
 
  if (func_name() != ((Item_func*) item)->func_name())
1792
 
    return 0;
1793
 
  if (this == item)
1794
 
    return 1;
1795
 
  item_func= (Item_func_date_format*) item;
1796
 
  if (!args[0]->eq(item_func->args[0], binary_cmp))
1797
 
    return 0;
1798
 
  /*
1799
 
    We must compare format string case sensitive.
1800
 
    This needed because format modifiers with different case,
1801
 
    for example %m and %M, have different meaning.
1802
 
  */
1803
 
  if (!args[1]->eq(item_func->args[1], 1))
1804
 
    return 0;
1805
 
  return 1;
1806
 
}
1807
 
 
1808
 
 
1809
 
 
1810
 
uint32_t Item_func_date_format::format_length(const String *format)
1811
 
{
1812
 
  uint32_t size=0;
1813
 
  const char *ptr=format->ptr();
1814
 
  const char *end=ptr+format->length();
1815
 
 
1816
 
  for (; ptr != end ; ptr++)
1817
 
  {
1818
 
    if (*ptr != '%' || ptr == end-1)
1819
 
      size++;
1820
 
    else
1821
 
    {
1822
 
      switch(*++ptr) {
1823
 
      case 'M': /* month, textual */
1824
 
      case 'W': /* day (of the week), textual */
1825
 
        size += 64; /* large for UTF8 locale data */
1826
 
        break;
1827
 
      case 'D': /* day (of the month), numeric plus english suffix */
1828
 
      case 'Y': /* year, numeric, 4 digits */
1829
 
      case 'x': /* Year, used with 'v' */
1830
 
      case 'X': /* Year, used with 'v, where week starts with Monday' */
1831
 
        size += 4;
1832
 
        break;
1833
 
      case 'a': /* locale's abbreviated weekday name (Sun..Sat) */
1834
 
      case 'b': /* locale's abbreviated month name (Jan.Dec) */
1835
 
        size += 32; /* large for UTF8 locale data */
1836
 
        break;
1837
 
      case 'j': /* day of year (001..366) */
1838
 
        size += 3;
1839
 
        break;
1840
 
      case 'U': /* week (00..52) */
1841
 
      case 'u': /* week (00..52), where week starts with Monday */
1842
 
      case 'V': /* week 1..53 used with 'x' */
1843
 
      case 'v': /* week 1..53 used with 'x', where week starts with Monday */
1844
 
      case 'y': /* year, numeric, 2 digits */
1845
 
      case 'm': /* month, numeric */
1846
 
      case 'd': /* day (of the month), numeric */
1847
 
      case 'h': /* hour (01..12) */
1848
 
      case 'I': /* --||-- */
1849
 
      case 'i': /* minutes, numeric */
1850
 
      case 'l': /* hour ( 1..12) */
1851
 
      case 'p': /* locale's AM or PM */
1852
 
      case 'S': /* second (00..61) */
1853
 
      case 's': /* seconds, numeric */
1854
 
      case 'c': /* month (0..12) */
1855
 
      case 'e': /* day (0..31) */
1856
 
        size += 2;
1857
 
        break;
1858
 
      case 'k': /* hour ( 0..23) */
1859
 
      case 'H': /* hour (00..23; value > 23 OK, padding always 2-digit) */
1860
 
        size += 7; /* docs allow > 23, range depends on sizeof(unsigned int) */
1861
 
        break;
1862
 
      case 'r': /* time, 12-hour (hh:mm:ss [AP]M) */
1863
 
        size += 11;
1864
 
        break;
1865
 
      case 'T': /* time, 24-hour (hh:mm:ss) */
1866
 
        size += 8;
1867
 
        break;
1868
 
      case 'f': /* microseconds */
1869
 
        size += 6;
1870
 
        break;
1871
 
      case 'w': /* day (of the week), numeric */
1872
 
      case '%':
1873
 
      default:
1874
 
        size++;
1875
 
        break;
1876
 
      }
1877
 
    }
1878
 
  }
1879
 
  return size;
1880
 
}
1881
 
 
1882
 
 
1883
 
String *Item_func_date_format::val_str(String *str)
1884
 
{
1885
 
  String *format;
1886
 
  DRIZZLE_TIME l_time;
1887
 
  uint32_t size;
1888
 
  assert(fixed == 1);
1889
 
 
1890
 
  if (!is_time_format)
1891
 
  {
1892
 
    if (get_arg0_date(&l_time, TIME_FUZZY_DATE))
1893
 
      return 0;
1894
 
  }
1895
 
  else
1896
 
  {
1897
 
    String *res;
1898
 
    if (!(res=args[0]->val_str(str)) ||
1899
 
        (str_to_time_with_warn(res->ptr(), res->length(), &l_time)))
1900
 
      goto null_date;
1901
 
 
1902
 
    l_time.year=l_time.month=l_time.day=0;
1903
 
    null_value=0;
1904
 
  }
1905
 
 
1906
 
  if (!(format = args[1]->val_str(str)) || !format->length())
1907
 
    goto null_date;
1908
 
 
1909
 
  if (fixed_length)
1910
 
    size=max_length;
1911
 
  else
1912
 
    size=format_length(format);
1913
 
 
1914
 
  if (size < MAX_DATE_STRING_REP_LENGTH)
1915
 
    size= MAX_DATE_STRING_REP_LENGTH;
1916
 
 
1917
 
  if (format == str)
1918
 
    str= &value;                                // Save result here
1919
 
  if (str->alloc(size))
1920
 
    goto null_date;
1921
 
 
1922
 
  DATE_TIME_FORMAT date_time_format;
1923
 
  date_time_format.format.str=    (char*) format->ptr();
1924
 
  date_time_format.format.length= format->length(); 
1925
 
 
1926
 
  /* Create the result string */
1927
 
  str->set_charset(collation.collation);
1928
 
  if (!make_date_time(&date_time_format, &l_time,
1929
 
                      is_time_format ? DRIZZLE_TIMESTAMP_TIME :
1930
 
                                       DRIZZLE_TIMESTAMP_DATE,
1931
 
                      str))
1932
 
    return str;
1933
 
 
1934
 
null_date:
1935
 
  null_value=1;
1936
 
  return 0;
1937
 
}
1938
 
 
1939
 
 
1940
 
void Item_func_from_unixtime::fix_length_and_dec()
1941
 
{ 
1942
 
  thd= current_thd;
1943
 
  collation.set(&my_charset_bin);
1944
 
  decimals= DATETIME_DEC;
1945
 
  max_length=MAX_DATETIME_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
1946
 
  maybe_null= 1;
1947
 
  thd->time_zone_used= 1;
1948
 
}
1949
 
 
1950
 
 
1951
 
String *Item_func_from_unixtime::val_str(String *str)
1952
 
{
1953
 
  DRIZZLE_TIME time_tmp;
1954
 
 
1955
 
  assert(fixed == 1);
1956
 
 
1957
 
  if (get_date(&time_tmp, 0))
1958
 
    return 0;
1959
 
 
1960
 
  if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
1961
 
  {
1962
 
    null_value= 1;
1963
 
    return 0;
1964
 
  }
1965
 
 
1966
 
  make_datetime((DATE_TIME_FORMAT *) 0, &time_tmp, str);
1967
 
 
1968
 
  return str;
1969
 
}
1970
 
 
1971
 
 
1972
 
int64_t Item_func_from_unixtime::val_int()
1973
 
{
1974
 
  DRIZZLE_TIME time_tmp;
1975
 
 
1976
 
  assert(fixed == 1);
1977
 
 
1978
 
  if (get_date(&time_tmp, 0))
1979
 
    return 0;
1980
 
 
1981
 
  return (int64_t) TIME_to_uint64_t_datetime(&time_tmp);
1982
 
}
1983
 
 
1984
 
bool Item_func_from_unixtime::get_date(DRIZZLE_TIME *ltime,
1985
 
                                       uint32_t fuzzy_date __attribute__((unused)))
1986
 
{
1987
 
  uint64_t tmp= (uint64_t)(args[0]->val_int());
1988
 
  /*
1989
 
    "tmp > TIMESTAMP_MAX_VALUE" check also covers case of negative
1990
 
    from_unixtime() argument since tmp is unsigned.
1991
 
  */
1992
 
  if ((null_value= (args[0]->null_value || tmp > TIMESTAMP_MAX_VALUE)))
1993
 
    return 1;
1994
 
 
1995
 
  thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)tmp);
1996
 
 
1997
 
  return 0;
1998
 
}
1999
 
 
2000
 
 
2001
 
void Item_date_add_interval::fix_length_and_dec()
2002
 
{
2003
 
  enum_field_types arg0_field_type;
2004
 
 
2005
 
  collation.set(&my_charset_bin);
2006
 
  maybe_null=1;
2007
 
  max_length=MAX_DATETIME_FULL_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
2008
 
  value.alloc(max_length);
2009
 
 
2010
 
  /*
2011
 
    The field type for the result of an Item_date function is defined as
2012
 
    follows:
2013
 
 
2014
 
    - If first arg is a DRIZZLE_TYPE_DATETIME result is DRIZZLE_TYPE_DATETIME
2015
 
    - If first arg is a DRIZZLE_TYPE_NEWDATE and the interval type uses hours,
2016
 
      minutes or seconds then type is DRIZZLE_TYPE_DATETIME.
2017
 
    - Otherwise the result is DRIZZLE_TYPE_VARCHAR
2018
 
      (This is because you can't know if the string contains a DATE, DRIZZLE_TIME or
2019
 
      DATETIME argument)
2020
 
  */
2021
 
  cached_field_type= DRIZZLE_TYPE_VARCHAR;
2022
 
  arg0_field_type= args[0]->field_type();
2023
 
  if (arg0_field_type == DRIZZLE_TYPE_DATETIME ||
2024
 
      arg0_field_type == DRIZZLE_TYPE_TIMESTAMP)
2025
 
    cached_field_type= DRIZZLE_TYPE_DATETIME;
2026
 
  else if (arg0_field_type == DRIZZLE_TYPE_NEWDATE)
2027
 
  {
2028
 
    if (int_type <= INTERVAL_DAY || int_type == INTERVAL_YEAR_MONTH)
2029
 
      cached_field_type= arg0_field_type;
2030
 
    else
2031
 
      cached_field_type= DRIZZLE_TYPE_DATETIME;
2032
 
  }
2033
 
}
2034
 
 
2035
 
 
2036
 
/* Here arg[1] is a Item_interval object */
2037
 
 
2038
 
bool Item_date_add_interval::get_date(DRIZZLE_TIME *ltime, uint32_t fuzzy_date __attribute__((unused)))
2039
 
{
2040
 
  INTERVAL interval;
2041
 
 
2042
 
  if (args[0]->get_date(ltime, TIME_NO_ZERO_DATE) ||
2043
 
      get_interval_value(args[1], int_type, &value, &interval))
2044
 
    return (null_value=1);
2045
 
 
2046
 
  if (date_sub_interval)
2047
 
    interval.neg = !interval.neg;
2048
 
 
2049
 
  if ((null_value= date_add_interval(ltime, int_type, interval)))
2050
 
    return 1;
2051
 
  return 0;
2052
 
}
2053
 
 
2054
 
 
2055
 
String *Item_date_add_interval::val_str(String *str)
2056
 
{
2057
 
  assert(fixed == 1);
2058
 
  DRIZZLE_TIME ltime;
2059
 
  enum date_time_format_types format;
2060
 
 
2061
 
  if (Item_date_add_interval::get_date(&ltime, TIME_NO_ZERO_DATE))
2062
 
    return 0;
2063
 
 
2064
 
  if (ltime.time_type == DRIZZLE_TIMESTAMP_DATE)
2065
 
    format= DATE_ONLY;
2066
 
  else if (ltime.second_part)
2067
 
    format= DATE_TIME_MICROSECOND;
2068
 
  else
2069
 
    format= DATE_TIME;
2070
 
 
2071
 
  if (!make_datetime(format, &ltime, str))
2072
 
    return str;
2073
 
 
2074
 
  null_value=1;
2075
 
  return 0;
2076
 
}
2077
 
 
2078
 
 
2079
 
int64_t Item_date_add_interval::val_int()
2080
 
{
2081
 
  assert(fixed == 1);
2082
 
  DRIZZLE_TIME ltime;
2083
 
  int64_t date;
2084
 
  if (Item_date_add_interval::get_date(&ltime, TIME_NO_ZERO_DATE))
2085
 
    return (int64_t) 0;
2086
 
  date = (ltime.year*100L + ltime.month)*100L + ltime.day;
2087
 
  return ltime.time_type == DRIZZLE_TIMESTAMP_DATE ? date :
2088
 
    ((date*100L + ltime.hour)*100L+ ltime.minute)*100L + ltime.second;
2089
 
}
2090
 
 
2091
 
 
2092
 
 
2093
 
bool Item_date_add_interval::eq(const Item *item, bool binary_cmp) const
2094
 
{
2095
 
  Item_date_add_interval *other= (Item_date_add_interval*) item;
2096
 
  if (!Item_func::eq(item, binary_cmp))
2097
 
    return 0;
2098
 
  return ((int_type == other->int_type) &&
2099
 
          (date_sub_interval == other->date_sub_interval));
2100
 
}
2101
 
 
2102
 
/*
2103
 
   'interval_names' reflects the order of the enumeration interval_type.
2104
 
   See item_timefunc.h
2105
 
 */
2106
 
 
2107
 
static const char *interval_names[]=
2108
 
{
2109
 
  "year", "quarter", "month", "week", "day",  
2110
 
  "hour", "minute", "second", "microsecond",
2111
 
  "year_month", "day_hour", "day_minute", 
2112
 
  "day_second", "hour_minute", "hour_second",
2113
 
  "minute_second", "day_microsecond",
2114
 
  "hour_microsecond", "minute_microsecond",
2115
 
  "second_microsecond"
2116
 
};
2117
 
 
2118
 
void Item_date_add_interval::print(String *str, enum_query_type query_type)
2119
 
{
2120
 
  str->append('(');
2121
 
  args[0]->print(str, query_type);
2122
 
  str->append(date_sub_interval?" - interval ":" + interval ");
2123
 
  args[1]->print(str, query_type);
2124
 
  str->append(' ');
2125
 
  str->append(interval_names[int_type]);
2126
 
  str->append(')');
2127
 
}
2128
 
 
2129
 
void Item_extract::print(String *str, enum_query_type query_type)
2130
 
{
2131
 
  str->append(STRING_WITH_LEN("extract("));
2132
 
  str->append(interval_names[int_type]);
2133
 
  str->append(STRING_WITH_LEN(" from "));
2134
 
  args[0]->print(str, query_type);
2135
 
  str->append(')');
2136
 
}
2137
 
 
2138
 
void Item_extract::fix_length_and_dec()
2139
 
{
2140
 
  value.alloc(32);                              // alloc buffer
2141
 
 
2142
 
  maybe_null=1;                                 // If wrong date
2143
 
  switch (int_type) {
2144
 
  case INTERVAL_YEAR:           max_length=4; date_value=1; break;
2145
 
  case INTERVAL_YEAR_MONTH:     max_length=6; date_value=1; break;
2146
 
  case INTERVAL_QUARTER:        max_length=2; date_value=1; break;
2147
 
  case INTERVAL_MONTH:          max_length=2; date_value=1; break;
2148
 
  case INTERVAL_WEEK:           max_length=2; date_value=1; break;
2149
 
  case INTERVAL_DAY:            max_length=2; date_value=1; break;
2150
 
  case INTERVAL_DAY_HOUR:       max_length=9; date_value=0; break;
2151
 
  case INTERVAL_DAY_MINUTE:     max_length=11; date_value=0; break;
2152
 
  case INTERVAL_DAY_SECOND:     max_length=13; date_value=0; break;
2153
 
  case INTERVAL_HOUR:           max_length=2; date_value=0; break;
2154
 
  case INTERVAL_HOUR_MINUTE:    max_length=4; date_value=0; break;
2155
 
  case INTERVAL_HOUR_SECOND:    max_length=6; date_value=0; break;
2156
 
  case INTERVAL_MINUTE:         max_length=2; date_value=0; break;
2157
 
  case INTERVAL_MINUTE_SECOND:  max_length=4; date_value=0; break;
2158
 
  case INTERVAL_SECOND:         max_length=2; date_value=0; break;
2159
 
  case INTERVAL_MICROSECOND:    max_length=2; date_value=0; break;
2160
 
  case INTERVAL_DAY_MICROSECOND: max_length=20; date_value=0; break;
2161
 
  case INTERVAL_HOUR_MICROSECOND: max_length=13; date_value=0; break;
2162
 
  case INTERVAL_MINUTE_MICROSECOND: max_length=11; date_value=0; break;
2163
 
  case INTERVAL_SECOND_MICROSECOND: max_length=9; date_value=0; break;
2164
 
  case INTERVAL_LAST: assert(0); break; /* purecov: deadcode */
2165
 
  }
2166
 
}
2167
 
 
2168
 
 
2169
 
int64_t Item_extract::val_int()
2170
 
{
2171
 
  assert(fixed == 1);
2172
 
  DRIZZLE_TIME ltime;
2173
 
  uint32_t year;
2174
 
  ulong week_format;
2175
 
  long neg;
2176
 
  if (date_value)
2177
 
  {
2178
 
    if (get_arg0_date(&ltime, TIME_FUZZY_DATE))
2179
 
      return 0;
2180
 
    neg=1;
2181
 
  }
2182
 
  else
2183
 
  {
2184
 
    String *res= args[0]->val_str(&value);
2185
 
    if (!res || str_to_time_with_warn(res->ptr(), res->length(), &ltime))
2186
 
    {
2187
 
      null_value=1;
2188
 
      return 0;
2189
 
    }
2190
 
    neg= ltime.neg ? -1 : 1;
2191
 
    null_value=0;
2192
 
  }
2193
 
  switch (int_type) {
2194
 
  case INTERVAL_YEAR:           return ltime.year;
2195
 
  case INTERVAL_YEAR_MONTH:     return ltime.year*100L+ltime.month;
2196
 
  case INTERVAL_QUARTER:        return (ltime.month+2)/3;
2197
 
  case INTERVAL_MONTH:          return ltime.month;
2198
 
  case INTERVAL_WEEK:
2199
 
  {
2200
 
    week_format= current_thd->variables.default_week_format;
2201
 
    return calc_week(&ltime, week_mode(week_format), &year);
2202
 
  }
2203
 
  case INTERVAL_DAY:            return ltime.day;
2204
 
  case INTERVAL_DAY_HOUR:       return (long) (ltime.day*100L+ltime.hour)*neg;
2205
 
  case INTERVAL_DAY_MINUTE:     return (long) (ltime.day*10000L+
2206
 
                                               ltime.hour*100L+
2207
 
                                               ltime.minute)*neg;
2208
 
  case INTERVAL_DAY_SECOND:      return ((int64_t) ltime.day*1000000L+
2209
 
                                         (int64_t) (ltime.hour*10000L+
2210
 
                                                     ltime.minute*100+
2211
 
                                                     ltime.second))*neg;
2212
 
  case INTERVAL_HOUR:           return (long) ltime.hour*neg;
2213
 
  case INTERVAL_HOUR_MINUTE:    return (long) (ltime.hour*100+ltime.minute)*neg;
2214
 
  case INTERVAL_HOUR_SECOND:    return (long) (ltime.hour*10000+ltime.minute*100+
2215
 
                                               ltime.second)*neg;
2216
 
  case INTERVAL_MINUTE:         return (long) ltime.minute*neg;
2217
 
  case INTERVAL_MINUTE_SECOND:  return (long) (ltime.minute*100+ltime.second)*neg;
2218
 
  case INTERVAL_SECOND:         return (long) ltime.second*neg;
2219
 
  case INTERVAL_MICROSECOND:    return (long) ltime.second_part*neg;
2220
 
  case INTERVAL_DAY_MICROSECOND: return (((int64_t)ltime.day*1000000L +
2221
 
                                          (int64_t)ltime.hour*10000L +
2222
 
                                          ltime.minute*100 +
2223
 
                                          ltime.second)*1000000L +
2224
 
                                         ltime.second_part)*neg;
2225
 
  case INTERVAL_HOUR_MICROSECOND: return (((int64_t)ltime.hour*10000L +
2226
 
                                           ltime.minute*100 +
2227
 
                                           ltime.second)*1000000L +
2228
 
                                          ltime.second_part)*neg;
2229
 
  case INTERVAL_MINUTE_MICROSECOND: return (((int64_t)(ltime.minute*100+
2230
 
                                                        ltime.second))*1000000L+
2231
 
                                            ltime.second_part)*neg;
2232
 
  case INTERVAL_SECOND_MICROSECOND: return ((int64_t)ltime.second*1000000L+
2233
 
                                            ltime.second_part)*neg;
2234
 
  case INTERVAL_LAST: assert(0); break;  /* purecov: deadcode */
2235
 
  }
2236
 
  return 0;                                     // Impossible
2237
 
}
2238
 
 
2239
 
bool Item_extract::eq(const Item *item, bool binary_cmp) const
2240
 
{
2241
 
  if (this == item)
2242
 
    return 1;
2243
 
  if (item->type() != FUNC_ITEM ||
2244
 
      functype() != ((Item_func*)item)->functype())
2245
 
    return 0;
2246
 
 
2247
 
  Item_extract* ie= (Item_extract*)item;
2248
 
  if (ie->int_type != int_type)
2249
 
    return 0;
2250
 
 
2251
 
  if (!args[0]->eq(ie->args[0], binary_cmp))
2252
 
      return 0;
2253
 
  return 1;
2254
 
}
2255
 
 
2256
 
 
2257
 
bool Item_char_typecast::eq(const Item *item, bool binary_cmp) const
2258
 
{
2259
 
  if (this == item)
2260
 
    return 1;
2261
 
  if (item->type() != FUNC_ITEM ||
2262
 
      functype() != ((Item_func*)item)->functype())
2263
 
    return 0;
2264
 
 
2265
 
  Item_char_typecast *cast= (Item_char_typecast*)item;
2266
 
  if (cast_length != cast->cast_length ||
2267
 
      cast_cs     != cast->cast_cs)
2268
 
    return 0;
2269
 
 
2270
 
  if (!args[0]->eq(cast->args[0], binary_cmp))
2271
 
      return 0;
2272
 
  return 1;
2273
 
}
2274
 
 
2275
 
void Item_typecast::print(String *str, enum_query_type query_type)
2276
 
{
2277
 
  str->append(STRING_WITH_LEN("cast("));
2278
 
  args[0]->print(str, query_type);
2279
 
  str->append(STRING_WITH_LEN(" as "));
2280
 
  str->append(cast_type());
2281
 
  str->append(')');
2282
 
}
2283
 
 
2284
 
 
2285
 
void Item_char_typecast::print(String *str, enum_query_type query_type)
2286
 
{
2287
 
  str->append(STRING_WITH_LEN("cast("));
2288
 
  args[0]->print(str, query_type);
2289
 
  str->append(STRING_WITH_LEN(" as char"));
2290
 
  if (cast_length >= 0)
2291
 
  {
2292
 
    str->append('(');
2293
 
    char buffer[20];
2294
 
    // my_charset_bin is good enough for numbers
2295
 
    String st(buffer, sizeof(buffer), &my_charset_bin);
2296
 
    st.set((uint64_t)cast_length, &my_charset_bin);
2297
 
    str->append(st);
2298
 
    str->append(')');
2299
 
  }
2300
 
  if (cast_cs)
2301
 
  {
2302
 
    str->append(STRING_WITH_LEN(" charset "));
2303
 
    str->append(cast_cs->csname);
2304
 
  }
2305
 
  str->append(')');
2306
 
}
2307
 
 
2308
 
String *Item_char_typecast::val_str(String *str)
2309
 
{
2310
 
  assert(fixed == 1);
2311
 
  String *res;
2312
 
  uint32_t length;
2313
 
 
2314
 
  if (!charset_conversion)
2315
 
  {
2316
 
    if (!(res= args[0]->val_str(str)))
2317
 
    {
2318
 
      null_value= 1;
2319
 
      return 0;
2320
 
    }
2321
 
  }
2322
 
  else
2323
 
  {
2324
 
    // Convert character set if differ
2325
 
    uint32_t dummy_errors;
2326
 
    if (!(res= args[0]->val_str(&tmp_value)) ||
2327
 
        str->copy(res->ptr(), res->length(), from_cs,
2328
 
        cast_cs, &dummy_errors))
2329
 
    {
2330
 
      null_value= 1;
2331
 
      return 0;
2332
 
    }
2333
 
    res= str;
2334
 
  }
2335
 
 
2336
 
  res->set_charset(cast_cs);
2337
 
 
2338
 
  /*
2339
 
    Cut the tail if cast with length
2340
 
    and the result is longer than cast length, e.g.
2341
 
    CAST('string' AS CHAR(1))
2342
 
  */
2343
 
  if (cast_length >= 0)
2344
 
  {
2345
 
    if (res->length() > (length= (uint32_t) res->charpos(cast_length)))
2346
 
    {                                           // Safe even if const arg
2347
 
      char char_type[40];
2348
 
      snprintf(char_type, sizeof(char_type), "%s(%lu)",
2349
 
               cast_cs == &my_charset_bin ? "BINARY" : "CHAR",
2350
 
               (ulong) length);
2351
 
 
2352
 
      if (!res->alloced_length())
2353
 
      {                                         // Don't change const str
2354
 
        str_value= *res;                        // Not malloced string
2355
 
        res= &str_value;
2356
 
      }
2357
 
      push_warning_printf(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
2358
 
                          ER_TRUNCATED_WRONG_VALUE,
2359
 
                          ER(ER_TRUNCATED_WRONG_VALUE), char_type,
2360
 
                          res->c_ptr_safe());
2361
 
      res->length((uint) length);
2362
 
    }
2363
 
    else if (cast_cs == &my_charset_bin && res->length() < (uint) cast_length)
2364
 
    {
2365
 
      if (res->alloced_length() < (uint) cast_length)
2366
 
      {
2367
 
        str->alloc(cast_length);
2368
 
        str->copy(*res);
2369
 
        res= str;
2370
 
      }
2371
 
      memset(res->ptr() + res->length(), 0,
2372
 
             (uint) cast_length - res->length());
2373
 
      res->length(cast_length);
2374
 
    }
2375
 
  }
2376
 
  null_value= 0;
2377
 
  return res;
2378
 
}
2379
 
 
2380
 
 
2381
 
void Item_char_typecast::fix_length_and_dec()
2382
 
{
2383
 
  uint32_t char_length;
2384
 
  /* 
2385
 
     We always force character set conversion if cast_cs
2386
 
     is a multi-byte character set. It garantees that the
2387
 
     result of CAST is a well-formed string.
2388
 
     For single-byte character sets we allow just to copy
2389
 
     from the argument. A single-byte character sets string
2390
 
     is always well-formed. 
2391
 
     
2392
 
     There is a special trick to convert form a number to ucs2.
2393
 
     As numbers have my_charset_bin as their character set,
2394
 
     it wouldn't do conversion to ucs2 without an additional action.
2395
 
     To force conversion, we should pretend to be non-binary.
2396
 
     Let's choose from_cs this way:
2397
 
     - If the argument in a number and cast_cs is ucs2 (i.e. mbminlen > 1),
2398
 
       then from_cs is set to latin1, to perform latin1 -> ucs2 conversion.
2399
 
     - If the argument is a number and cast_cs is ASCII-compatible
2400
 
       (i.e. mbminlen == 1), then from_cs is set to cast_cs,
2401
 
       which allows just to take over the args[0]->val_str() result
2402
 
       and thus avoid unnecessary character set conversion.
2403
 
     - If the argument is not a number, then from_cs is set to
2404
 
       the argument's charset.
2405
 
  */
2406
 
  from_cs= (args[0]->result_type() == INT_RESULT || 
2407
 
            args[0]->result_type() == DECIMAL_RESULT ||
2408
 
            args[0]->result_type() == REAL_RESULT) ?
2409
 
           (cast_cs->mbminlen == 1 ? cast_cs : &my_charset_utf8_general_ci) :
2410
 
           args[0]->collation.collation;
2411
 
  charset_conversion= (cast_cs->mbmaxlen > 1) ||
2412
 
                      (!my_charset_same(from_cs, cast_cs) && from_cs != &my_charset_bin && cast_cs != &my_charset_bin);
2413
 
  collation.set(cast_cs, DERIVATION_IMPLICIT);
2414
 
  char_length= (cast_length >= 0) ? cast_length : 
2415
 
               args[0]->max_length/from_cs->mbmaxlen;
2416
 
  max_length= char_length * cast_cs->mbmaxlen;
2417
 
}
2418
 
 
2419
 
 
2420
 
String *Item_datetime_typecast::val_str(String *str)
2421
 
{
2422
 
  assert(fixed == 1);
2423
 
  DRIZZLE_TIME ltime;
2424
 
 
2425
 
  if (!get_arg0_date(&ltime, TIME_FUZZY_DATE) &&
2426
 
      !make_datetime(ltime.second_part ? DATE_TIME_MICROSECOND : DATE_TIME, 
2427
 
                     &ltime, str))
2428
 
    return str;
2429
 
 
2430
 
  null_value=1;
2431
 
  return 0;
2432
 
}
2433
 
 
2434
 
 
2435
 
int64_t Item_datetime_typecast::val_int()
2436
 
{
2437
 
  assert(fixed == 1);
2438
 
  DRIZZLE_TIME ltime;
2439
 
  if (get_arg0_date(&ltime,1))
2440
 
  {
2441
 
    null_value= 1;
2442
 
    return 0;
2443
 
  }
2444
 
 
2445
 
  return TIME_to_uint64_t_datetime(&ltime);
2446
 
}
2447
 
 
2448
 
 
2449
 
bool Item_time_typecast::get_time(DRIZZLE_TIME *ltime)
2450
 
{
2451
 
  bool res= get_arg0_time(ltime);
2452
 
  /*
2453
 
    For DRIZZLE_TIMESTAMP_TIME value we can have non-zero day part,
2454
 
    which we should not lose.
2455
 
  */
2456
 
  if (ltime->time_type == DRIZZLE_TIMESTAMP_DATETIME)
2457
 
    ltime->year= ltime->month= ltime->day= 0;
2458
 
  ltime->time_type= DRIZZLE_TIMESTAMP_TIME;
2459
 
  return res;
2460
 
}
2461
 
 
2462
 
 
2463
 
int64_t Item_time_typecast::val_int()
2464
 
{
2465
 
  DRIZZLE_TIME ltime;
2466
 
  if (get_time(&ltime))
2467
 
  {
2468
 
    null_value= 1;
2469
 
    return 0;
2470
 
  }
2471
 
  return ltime.hour * 10000L + ltime.minute * 100 + ltime.second;
2472
 
}
2473
 
 
2474
 
String *Item_time_typecast::val_str(String *str)
2475
 
{
2476
 
  assert(fixed == 1);
2477
 
  DRIZZLE_TIME ltime;
2478
 
 
2479
 
  if (!get_arg0_time(&ltime) &&
2480
 
      !make_datetime(ltime.second_part ? TIME_MICROSECOND : TIME_ONLY,
2481
 
                     &ltime, str))
2482
 
    return str;
2483
 
 
2484
 
  null_value=1;
2485
 
  return 0;
2486
 
}
2487
 
 
2488
 
 
2489
 
bool Item_date_typecast::get_date(DRIZZLE_TIME *ltime, uint32_t fuzzy_date __attribute__((unused)))
2490
 
{
2491
 
  bool res= get_arg0_date(ltime, TIME_FUZZY_DATE);
2492
 
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= 0;
2493
 
  ltime->time_type= DRIZZLE_TIMESTAMP_DATE;
2494
 
  return res;
2495
 
}
2496
 
 
2497
 
 
2498
 
bool Item_date_typecast::get_time(DRIZZLE_TIME *ltime)
2499
 
{
2500
 
  memset(ltime, 0, sizeof(DRIZZLE_TIME));
2501
 
  return args[0]->null_value;
2502
 
}
2503
 
 
2504
 
 
2505
 
String *Item_date_typecast::val_str(String *str)
2506
 
{
2507
 
  assert(fixed == 1);
2508
 
  DRIZZLE_TIME ltime;
2509
 
 
2510
 
  if (!get_arg0_date(&ltime, TIME_FUZZY_DATE) &&
2511
 
      !str->alloc(MAX_DATE_STRING_REP_LENGTH))
2512
 
  {
2513
 
    make_date((DATE_TIME_FORMAT *) 0, &ltime, str);
2514
 
    return str;
2515
 
  }
2516
 
 
2517
 
  null_value=1;
2518
 
  return 0;
2519
 
}
2520
 
 
2521
 
int64_t Item_date_typecast::val_int()
2522
 
{
2523
 
  assert(fixed == 1);
2524
 
  DRIZZLE_TIME ltime;
2525
 
  if ((null_value= args[0]->get_date(&ltime, TIME_FUZZY_DATE)))
2526
 
    return 0;
2527
 
  return (int64_t) (ltime.year * 10000L + ltime.month * 100 + ltime.day);
2528
 
}
2529
 
 
2530
 
/**
2531
 
  MAKEDATE(a,b) is a date function that creates a date value 
2532
 
  from a year and day value.
2533
 
 
2534
 
  NOTES:
2535
 
    As arguments are integers, we can't know if the year is a 2 digit or 4 digit year.
2536
 
    In this case we treat all years < 100 as 2 digit years. Ie, this is not safe
2537
 
    for dates between 0000-01-01 and 0099-12-31
2538
 
*/
2539
 
 
2540
 
String *Item_func_makedate::val_str(String *str)
2541
 
{
2542
 
  assert(fixed == 1);
2543
 
  DRIZZLE_TIME l_time;
2544
 
  long daynr=  (long) args[1]->val_int();
2545
 
  long year= (long) args[0]->val_int();
2546
 
  long days;
2547
 
 
2548
 
  if (args[0]->null_value || args[1]->null_value ||
2549
 
      year < 0 || daynr <= 0)
2550
 
    goto err;
2551
 
 
2552
 
  if (year < 100)
2553
 
    year= year_2000_handling(year);
2554
 
 
2555
 
  days= calc_daynr(year,1,1) + daynr - 1;
2556
 
  /* Day number from year 0 to 9999-12-31 */
2557
 
  if (days >= 0 && days <= MAX_DAY_NUMBER)
2558
 
  {
2559
 
    null_value=0;
2560
 
    get_date_from_daynr(days,&l_time.year,&l_time.month,&l_time.day);
2561
 
    if (str->alloc(MAX_DATE_STRING_REP_LENGTH))
2562
 
      goto err;
2563
 
    make_date((DATE_TIME_FORMAT *) 0, &l_time, str);
2564
 
    return str;
2565
 
  }
2566
 
 
2567
 
err:
2568
 
  null_value=1;
2569
 
  return 0;
2570
 
}
2571
 
 
2572
 
 
2573
 
/*
2574
 
  MAKEDATE(a,b) is a date function that creates a date value 
2575
 
  from a year and day value.
2576
 
 
2577
 
  NOTES:
2578
 
    As arguments are integers, we can't know if the year is a 2 digit or 4 digit year.
2579
 
    In this case we treat all years < 100 as 2 digit years. Ie, this is not safe
2580
 
    for dates between 0000-01-01 and 0099-12-31
2581
 
*/
2582
 
 
2583
 
int64_t Item_func_makedate::val_int()
2584
 
{
2585
 
  assert(fixed == 1);
2586
 
  DRIZZLE_TIME l_time;
2587
 
  long daynr=  (long) args[1]->val_int();
2588
 
  long year= (long) args[0]->val_int();
2589
 
  long days;
2590
 
 
2591
 
  if (args[0]->null_value || args[1]->null_value ||
2592
 
      year < 0 || daynr <= 0)
2593
 
    goto err;
2594
 
 
2595
 
  if (year < 100)
2596
 
    year= year_2000_handling(year);
2597
 
 
2598
 
  days= calc_daynr(year,1,1) + daynr - 1;
2599
 
  /* Day number from year 0 to 9999-12-31 */
2600
 
  if (days >= 0 && days < MAX_DAY_NUMBER)
2601
 
  {
2602
 
    null_value=0;
2603
 
    get_date_from_daynr(days,&l_time.year,&l_time.month,&l_time.day);
2604
 
    return (int64_t) (l_time.year * 10000L + l_time.month * 100 + l_time.day);
2605
 
  }
2606
 
 
2607
 
err:
2608
 
  null_value= 1;
2609
 
  return 0;
2610
 
}
2611
 
 
2612
 
 
2613
 
void Item_func_add_time::fix_length_and_dec()
2614
 
{
2615
 
  enum_field_types arg0_field_type;
2616
 
  decimals=0;
2617
 
  max_length=MAX_DATETIME_FULL_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
2618
 
  maybe_null= 1;
2619
 
 
2620
 
  /*
2621
 
    The field type for the result of an Item_func_add_time function is defined
2622
 
    as follows:
2623
 
 
2624
 
    - If first arg is a DRIZZLE_TYPE_DATETIME or DRIZZLE_TYPE_TIMESTAMP 
2625
 
      result is DRIZZLE_TYPE_DATETIME
2626
 
    - If first arg is a DRIZZLE_TYPE_TIME result is DRIZZLE_TYPE_TIME
2627
 
    - Otherwise the result is DRIZZLE_TYPE_VARCHAR
2628
 
  */
2629
 
 
2630
 
  cached_field_type= DRIZZLE_TYPE_VARCHAR;
2631
 
  arg0_field_type= args[0]->field_type();
2632
 
  if (arg0_field_type == DRIZZLE_TYPE_NEWDATE ||
2633
 
      arg0_field_type == DRIZZLE_TYPE_DATETIME ||
2634
 
      arg0_field_type == DRIZZLE_TYPE_TIMESTAMP)
2635
 
    cached_field_type= DRIZZLE_TYPE_DATETIME;
2636
 
  else if (arg0_field_type == DRIZZLE_TYPE_TIME)
2637
 
    cached_field_type= DRIZZLE_TYPE_TIME;
2638
 
}
2639
 
 
2640
 
/**
2641
 
  ADDTIME(t,a) and SUBTIME(t,a) are time functions that calculate a
2642
 
  time/datetime value 
2643
 
 
2644
 
  t: time_or_datetime_expression
2645
 
  a: time_expression
2646
 
  
2647
 
  Result: Time value or datetime value
2648
 
*/
2649
 
 
2650
 
String *Item_func_add_time::val_str(String *str)
2651
 
{
2652
 
  assert(fixed == 1);
2653
 
  DRIZZLE_TIME l_time1, l_time2, l_time3;
2654
 
  bool is_time= 0;
2655
 
  long days, microseconds;
2656
 
  int64_t seconds;
2657
 
  int l_sign= sign;
2658
 
 
2659
 
  null_value=0;
2660
 
  if (is_date)                        // TIMESTAMP function
2661
 
  {
2662
 
    if (get_arg0_date(&l_time1, TIME_FUZZY_DATE) || 
2663
 
        args[1]->get_time(&l_time2) ||
2664
 
        l_time1.time_type == DRIZZLE_TIMESTAMP_TIME || 
2665
 
        l_time2.time_type != DRIZZLE_TIMESTAMP_TIME)
2666
 
      goto null_date;
2667
 
  }
2668
 
  else                                // ADDTIME function
2669
 
  {
2670
 
    if (args[0]->get_time(&l_time1) || 
2671
 
        args[1]->get_time(&l_time2) ||
2672
 
        l_time2.time_type == DRIZZLE_TIMESTAMP_DATETIME)
2673
 
      goto null_date;
2674
 
    is_time= (l_time1.time_type == DRIZZLE_TIMESTAMP_TIME);
2675
 
  }
2676
 
  if (l_time1.neg != l_time2.neg)
2677
 
    l_sign= -l_sign;
2678
 
  
2679
 
  memset(&l_time3, 0, sizeof(l_time3));
2680
 
  
2681
 
  l_time3.neg= calc_time_diff(&l_time1, &l_time2, -l_sign,
2682
 
                              &seconds, &microseconds);
2683
 
 
2684
 
  /*
2685
 
    If first argument was negative and diff between arguments
2686
 
    is non-zero we need to swap sign to get proper result.
2687
 
  */
2688
 
  if (l_time1.neg && (seconds || microseconds))
2689
 
    l_time3.neg= 1-l_time3.neg;         // Swap sign of result
2690
 
 
2691
 
  if (!is_time && l_time3.neg)
2692
 
    goto null_date;
2693
 
 
2694
 
  days= (long)(seconds/86400L);
2695
 
 
2696
 
  calc_time_from_sec(&l_time3, (long)(seconds%86400L), microseconds);
2697
 
 
2698
 
  if (!is_time)
2699
 
  {
2700
 
    get_date_from_daynr(days,&l_time3.year,&l_time3.month,&l_time3.day);
2701
 
    if (l_time3.day &&
2702
 
        !make_datetime(l_time1.second_part || l_time2.second_part ?
2703
 
                       DATE_TIME_MICROSECOND : DATE_TIME,
2704
 
                       &l_time3, str))
2705
 
      return str;
2706
 
    goto null_date;
2707
 
  }
2708
 
  
2709
 
  l_time3.hour+= days*24;
2710
 
  if (!make_datetime_with_warn(l_time1.second_part || l_time2.second_part ?
2711
 
                               TIME_MICROSECOND : TIME_ONLY,
2712
 
                               &l_time3, str))
2713
 
    return str;
2714
 
 
2715
 
null_date:
2716
 
  null_value=1;
2717
 
  return 0;
2718
 
}
2719
 
 
2720
 
 
2721
 
void Item_func_add_time::print(String *str, enum_query_type query_type)
2722
 
{
2723
 
  if (is_date)
2724
 
  {
2725
 
    assert(sign > 0);
2726
 
    str->append(STRING_WITH_LEN("timestamp("));
2727
 
  }
2728
 
  else
2729
 
  {
2730
 
    if (sign > 0)
2731
 
      str->append(STRING_WITH_LEN("addtime("));
2732
 
    else
2733
 
      str->append(STRING_WITH_LEN("subtime("));
2734
 
  }
2735
 
  args[0]->print(str, query_type);
2736
 
  str->append(',');
2737
 
  args[1]->print(str, query_type);
2738
 
  str->append(')');
2739
 
}
2740
 
 
2741
 
 
2742
 
/**
2743
 
  TIMEDIFF(t,s) is a time function that calculates the 
2744
 
  time value between a start and end time.
2745
 
 
2746
 
  t and s: time_or_datetime_expression
2747
 
  Result: Time value
2748
 
*/
2749
 
 
2750
 
String *Item_func_timediff::val_str(String *str)
2751
 
{
2752
 
  assert(fixed == 1);
2753
 
  int64_t seconds;
2754
 
  long microseconds;
2755
 
  int l_sign= 1;
2756
 
  DRIZZLE_TIME l_time1 ,l_time2, l_time3;
2757
 
 
2758
 
  null_value= 0;  
2759
 
  if (args[0]->get_time(&l_time1) ||
2760
 
      args[1]->get_time(&l_time2) ||
2761
 
      l_time1.time_type != l_time2.time_type)
2762
 
    goto null_date;
2763
 
 
2764
 
  if (l_time1.neg != l_time2.neg)
2765
 
    l_sign= -l_sign;
2766
 
 
2767
 
  memset(&l_time3, 0, sizeof(l_time3));
2768
 
  
2769
 
  l_time3.neg= calc_time_diff(&l_time1, &l_time2, l_sign,
2770
 
                              &seconds, &microseconds);
2771
 
 
2772
 
  /*
2773
 
    For DRIZZLE_TIMESTAMP_TIME only:
2774
 
      If first argument was negative and diff between arguments
2775
 
      is non-zero we need to swap sign to get proper result.
2776
 
  */
2777
 
  if (l_time1.neg && (seconds || microseconds))
2778
 
    l_time3.neg= 1-l_time3.neg;         // Swap sign of result
2779
 
 
2780
 
  calc_time_from_sec(&l_time3, (long) seconds, microseconds);
2781
 
 
2782
 
  if (!make_datetime_with_warn(l_time1.second_part || l_time2.second_part ?
2783
 
                               TIME_MICROSECOND : TIME_ONLY,
2784
 
                               &l_time3, str))
2785
 
    return str;
2786
 
 
2787
 
null_date:
2788
 
  null_value=1;
2789
 
  return 0;
2790
 
}
2791
 
 
2792
 
/**
2793
 
  MAKETIME(h,m,s) is a time function that calculates a time value 
2794
 
  from the total number of hours, minutes, and seconds.
2795
 
  Result: Time value
2796
 
*/
2797
 
 
2798
 
String *Item_func_maketime::val_str(String *str)
2799
 
{
2800
 
  assert(fixed == 1);
2801
 
  DRIZZLE_TIME ltime;
2802
 
  bool overflow= 0;
2803
 
 
2804
 
  int64_t hour=   args[0]->val_int();
2805
 
  int64_t minute= args[1]->val_int();
2806
 
  int64_t second= args[2]->val_int();
2807
 
 
2808
 
  if ((null_value=(args[0]->null_value || 
2809
 
                   args[1]->null_value ||
2810
 
                   args[2]->null_value ||
2811
 
                   minute < 0 || minute > 59 ||
2812
 
                   second < 0 || second > 59 ||
2813
 
                   str->alloc(MAX_DATE_STRING_REP_LENGTH))))
2814
 
    return 0;
2815
 
 
2816
 
  memset(&ltime, 0, sizeof(ltime));
2817
 
  ltime.neg= 0;
2818
 
 
2819
 
  /* Check for integer overflows */
2820
 
  if (hour < 0)
2821
 
  {
2822
 
    if (args[0]->unsigned_flag)
2823
 
      overflow= 1;
2824
 
    else
2825
 
      ltime.neg= 1;
2826
 
  }
2827
 
  if (-hour > UINT_MAX || hour > UINT_MAX)
2828
 
    overflow= 1;
2829
 
 
2830
 
  if (!overflow)
2831
 
  {
2832
 
    ltime.hour=   (uint) ((hour < 0 ? -hour : hour));
2833
 
    ltime.minute= (uint) minute;
2834
 
    ltime.second= (uint) second;
2835
 
  }
2836
 
  else
2837
 
  {
2838
 
    ltime.hour= TIME_MAX_HOUR;
2839
 
    ltime.minute= TIME_MAX_MINUTE;
2840
 
    ltime.second= TIME_MAX_SECOND;
2841
 
    char buf[28];
2842
 
    char *ptr= int64_t10_to_str(hour, buf, args[0]->unsigned_flag ? 10 : -10);
2843
 
    int len = (int)(ptr - buf) +
2844
 
      sprintf(ptr, ":%02u:%02u", (uint)minute, (uint)second);
2845
 
    make_truncated_value_warning(current_thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
2846
 
                                 buf, len, DRIZZLE_TIMESTAMP_TIME,
2847
 
                                 NULL);
2848
 
  }
2849
 
  
2850
 
  if (make_time_with_warn((DATE_TIME_FORMAT *) 0, &ltime, str))
2851
 
  {
2852
 
    null_value= 1;
2853
 
    return 0;
2854
 
  }
2855
 
  return str;
2856
 
}
2857
 
 
2858
 
 
2859
 
/**
2860
 
  MICROSECOND(a) is a function ( extraction) that extracts the microseconds
2861
 
  from a.
2862
 
 
2863
 
  a: Datetime or time value
2864
 
  Result: int value
2865
 
*/
2866
 
 
2867
 
int64_t Item_func_microsecond::val_int()
2868
 
{
2869
 
  assert(fixed == 1);
2870
 
  DRIZZLE_TIME ltime;
2871
 
  if (!get_arg0_time(&ltime))
2872
 
    return ltime.second_part;
2873
 
  return 0;
2874
 
}
2875
 
 
2876
 
 
2877
 
int64_t Item_func_timestamp_diff::val_int()
2878
 
{
2879
 
  DRIZZLE_TIME ltime1, ltime2;
2880
 
  int64_t seconds;
2881
 
  long microseconds;
2882
 
  long months= 0;
2883
 
  int neg= 1;
2884
 
 
2885
 
  null_value= 0;  
2886
 
  if (args[0]->get_date(&ltime1, TIME_NO_ZERO_DATE) ||
2887
 
      args[1]->get_date(&ltime2, TIME_NO_ZERO_DATE))
2888
 
    goto null_date;
2889
 
 
2890
 
  if (calc_time_diff(&ltime2,&ltime1, 1,
2891
 
                     &seconds, &microseconds))
2892
 
    neg= -1;
2893
 
 
2894
 
  if (int_type == INTERVAL_YEAR ||
2895
 
      int_type == INTERVAL_QUARTER ||
2896
 
      int_type == INTERVAL_MONTH)
2897
 
  {
2898
 
    uint32_t year_beg, year_end, month_beg, month_end, day_beg, day_end;
2899
 
    uint32_t years= 0;
2900
 
    uint32_t second_beg, second_end, microsecond_beg, microsecond_end;
2901
 
 
2902
 
    if (neg == -1)
2903
 
    {
2904
 
      year_beg= ltime2.year;
2905
 
      year_end= ltime1.year;
2906
 
      month_beg= ltime2.month;
2907
 
      month_end= ltime1.month;
2908
 
      day_beg= ltime2.day;
2909
 
      day_end= ltime1.day;
2910
 
      second_beg= ltime2.hour * 3600 + ltime2.minute * 60 + ltime2.second;
2911
 
      second_end= ltime1.hour * 3600 + ltime1.minute * 60 + ltime1.second;
2912
 
      microsecond_beg= ltime2.second_part;
2913
 
      microsecond_end= ltime1.second_part;
2914
 
    }
2915
 
    else
2916
 
    {
2917
 
      year_beg= ltime1.year;
2918
 
      year_end= ltime2.year;
2919
 
      month_beg= ltime1.month;
2920
 
      month_end= ltime2.month;
2921
 
      day_beg= ltime1.day;
2922
 
      day_end= ltime2.day;
2923
 
      second_beg= ltime1.hour * 3600 + ltime1.minute * 60 + ltime1.second;
2924
 
      second_end= ltime2.hour * 3600 + ltime2.minute * 60 + ltime2.second;
2925
 
      microsecond_beg= ltime1.second_part;
2926
 
      microsecond_end= ltime2.second_part;
2927
 
    }
2928
 
 
2929
 
    /* calc years */
2930
 
    years= year_end - year_beg;
2931
 
    if (month_end < month_beg || (month_end == month_beg && day_end < day_beg))
2932
 
      years-= 1;
2933
 
 
2934
 
    /* calc months */
2935
 
    months= 12*years;
2936
 
    if (month_end < month_beg || (month_end == month_beg && day_end < day_beg))
2937
 
      months+= 12 - (month_beg - month_end);
2938
 
    else
2939
 
      months+= (month_end - month_beg);
2940
 
 
2941
 
    if (day_end < day_beg)
2942
 
      months-= 1;
2943
 
    else if ((day_end == day_beg) &&
2944
 
             ((second_end < second_beg) ||
2945
 
              (second_end == second_beg && microsecond_end < microsecond_beg)))
2946
 
      months-= 1;
2947
 
  }
2948
 
 
2949
 
  switch (int_type) {
2950
 
  case INTERVAL_YEAR:
2951
 
    return months/12*neg;
2952
 
  case INTERVAL_QUARTER:
2953
 
    return months/3*neg;
2954
 
  case INTERVAL_MONTH:
2955
 
    return months*neg;
2956
 
  case INTERVAL_WEEK:          
2957
 
    return seconds/86400L/7L*neg;
2958
 
  case INTERVAL_DAY:            
2959
 
    return seconds/86400L*neg;
2960
 
  case INTERVAL_HOUR:           
2961
 
    return seconds/3600L*neg;
2962
 
  case INTERVAL_MINUTE:         
2963
 
    return seconds/60L*neg;
2964
 
  case INTERVAL_SECOND:         
2965
 
    return seconds*neg;
2966
 
  case INTERVAL_MICROSECOND:
2967
 
    /*
2968
 
      In MySQL difference between any two valid datetime values
2969
 
      in microseconds fits into int64_t.
2970
 
    */
2971
 
    return (seconds*1000000L+microseconds)*neg;
2972
 
  default:
2973
 
    break;
2974
 
  }
2975
 
 
2976
 
null_date:
2977
 
  null_value=1;
2978
 
  return 0;
2979
 
}
2980
 
 
2981
 
 
2982
 
void Item_func_timestamp_diff::print(String *str, enum_query_type query_type)
2983
 
{
2984
 
  str->append(func_name());
2985
 
  str->append('(');
2986
 
 
2987
 
  switch (int_type) {
2988
 
  case INTERVAL_YEAR:
2989
 
    str->append(STRING_WITH_LEN("YEAR"));
2990
 
    break;
2991
 
  case INTERVAL_QUARTER:
2992
 
    str->append(STRING_WITH_LEN("QUARTER"));
2993
 
    break;
2994
 
  case INTERVAL_MONTH:
2995
 
    str->append(STRING_WITH_LEN("MONTH"));
2996
 
    break;
2997
 
  case INTERVAL_WEEK:          
2998
 
    str->append(STRING_WITH_LEN("WEEK"));
2999
 
    break;
3000
 
  case INTERVAL_DAY:            
3001
 
    str->append(STRING_WITH_LEN("DAY"));
3002
 
    break;
3003
 
  case INTERVAL_HOUR:
3004
 
    str->append(STRING_WITH_LEN("HOUR"));
3005
 
    break;
3006
 
  case INTERVAL_MINUTE:         
3007
 
    str->append(STRING_WITH_LEN("MINUTE"));
3008
 
    break;
3009
 
  case INTERVAL_SECOND:
3010
 
    str->append(STRING_WITH_LEN("SECOND"));
3011
 
    break;              
3012
 
  case INTERVAL_MICROSECOND:
3013
 
    str->append(STRING_WITH_LEN("SECOND_FRAC"));
3014
 
    break;
3015
 
  default:
3016
 
    break;
3017
 
  }
3018
 
 
3019
 
  for (uint32_t i=0 ; i < 2 ; i++)
3020
 
  {
3021
 
    str->append(',');
3022
 
    args[i]->print(str, query_type);
3023
 
  }
3024
 
  str->append(')');
3025
 
}
3026
 
 
3027
 
 
3028
 
String *Item_func_get_format::val_str(String *str)
3029
 
{
3030
 
  assert(fixed == 1);
3031
 
  const char *format_name;
3032
 
  KNOWN_DATE_TIME_FORMAT *format;
3033
 
  String *val= args[0]->val_str(str);
3034
 
  ulong val_len;
3035
 
 
3036
 
  if ((null_value= args[0]->null_value))
3037
 
    return 0;    
3038
 
 
3039
 
  val_len= val->length();
3040
 
  for (format= &known_date_time_formats[0];
3041
 
       (format_name= format->format_name);
3042
 
       format++)
3043
 
  {
3044
 
    uint32_t format_name_len;
3045
 
    format_name_len= strlen(format_name);
3046
 
    if (val_len == format_name_len &&
3047
 
        !my_strnncoll(&my_charset_utf8_general_ci, 
3048
 
                      (const unsigned char *) val->ptr(), val_len, 
3049
 
                      (const unsigned char *) format_name, val_len))
3050
 
    {
3051
 
      const char *format_str= get_date_time_format_str(format, type);
3052
 
      str->set(format_str, strlen(format_str), &my_charset_bin);
3053
 
      return str;
3054
 
    }
3055
 
  }
3056
 
 
3057
 
  null_value= 1;
3058
 
  return 0;
3059
 
}
3060
 
 
3061
 
 
3062
 
void Item_func_get_format::print(String *str, enum_query_type query_type)
3063
 
{
3064
 
  str->append(func_name());
3065
 
  str->append('(');
3066
 
 
3067
 
  switch (type) {
3068
 
  case DRIZZLE_TIMESTAMP_DATE:
3069
 
    str->append(STRING_WITH_LEN("DATE, "));
3070
 
    break;
3071
 
  case DRIZZLE_TIMESTAMP_DATETIME:
3072
 
    str->append(STRING_WITH_LEN("DATETIME, "));
3073
 
    break;
3074
 
  case DRIZZLE_TIMESTAMP_TIME:
3075
 
    str->append(STRING_WITH_LEN("TIME, "));
3076
 
    break;
3077
 
  default:
3078
 
    assert(0);
3079
 
  }
3080
 
  args[0]->print(str, query_type);
3081
 
  str->append(')');
3082
 
}
3083
 
 
3084
 
 
3085
 
/**
3086
 
  Get type of datetime value (DATE/TIME/...) which will be produced
3087
 
  according to format string.
3088
 
 
3089
 
  @param format   format string
3090
 
  @param length   length of format string
3091
 
 
3092
 
  @note
3093
 
    We don't process day format's characters('D', 'd', 'e') because day
3094
 
    may be a member of all date/time types.
3095
 
 
3096
 
  @note
3097
 
    Format specifiers supported by this function should be in sync with
3098
 
    specifiers supported by extract_date_time() function.
3099
 
 
3100
 
  @return
3101
 
    One of date_time_format_types values:
3102
 
    - DATE_TIME_MICROSECOND
3103
 
    - DATE_TIME
3104
 
    - DATE_ONLY
3105
 
    - TIME_MICROSECOND
3106
 
    - TIME_ONLY
3107
 
*/
3108
 
 
3109
 
static date_time_format_types
3110
 
get_date_time_result_type(const char *format, uint32_t length)
3111
 
{
3112
 
  const char *time_part_frms= "HISThiklrs";
3113
 
  const char *date_part_frms= "MVUXYWabcjmvuxyw";
3114
 
  bool date_part_used= 0, time_part_used= 0, frac_second_used= 0;
3115
 
  
3116
 
  const char *val= format;
3117
 
  const char *end= format + length;
3118
 
 
3119
 
  for (; val != end && val != end; val++)
3120
 
  {
3121
 
    if (*val == '%' && val+1 != end)
3122
 
    {
3123
 
      val++;
3124
 
      if (*val == 'f')
3125
 
        frac_second_used= time_part_used= 1;
3126
 
      else if (!time_part_used && strchr(time_part_frms, *val))
3127
 
        time_part_used= 1;
3128
 
      else if (!date_part_used && strchr(date_part_frms, *val))
3129
 
        date_part_used= 1;
3130
 
      if (date_part_used && frac_second_used)
3131
 
      {
3132
 
        /*
3133
 
          frac_second_used implies time_part_used, and thus we already
3134
 
          have all types of date-time components and can end our search.
3135
 
        */
3136
 
        return DATE_TIME_MICROSECOND;
3137
 
    }
3138
 
  }
3139
 
  }
3140
 
 
3141
 
  /* We don't have all three types of date-time components */
3142
 
  if (frac_second_used)
3143
 
    return TIME_MICROSECOND;
3144
 
  if (time_part_used)
3145
 
  {
3146
 
    if (date_part_used)
3147
 
      return DATE_TIME;
3148
 
    return TIME_ONLY;
3149
 
  }
3150
 
  return DATE_ONLY;
3151
 
}
3152
 
 
3153
 
 
3154
 
void Item_func_str_to_date::fix_length_and_dec()
3155
 
{
3156
 
  maybe_null= 1;
3157
 
  decimals=0;
3158
 
  cached_field_type= DRIZZLE_TYPE_DATETIME;
3159
 
  max_length= MAX_DATETIME_FULL_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
3160
 
  cached_timestamp_type= DRIZZLE_TIMESTAMP_NONE;
3161
 
  if ((const_item= args[1]->const_item()))
3162
 
  {
3163
 
    char format_buff[64];
3164
 
    String format_str(format_buff, sizeof(format_buff), &my_charset_bin);
3165
 
    String *format= args[1]->val_str(&format_str);
3166
 
    if (!args[1]->null_value)
3167
 
    {
3168
 
      cached_format_type= get_date_time_result_type(format->ptr(),
3169
 
                                                    format->length());
3170
 
      switch (cached_format_type) {
3171
 
      case DATE_ONLY:
3172
 
        cached_timestamp_type= DRIZZLE_TIMESTAMP_DATE;
3173
 
        cached_field_type= DRIZZLE_TYPE_NEWDATE; 
3174
 
        max_length= MAX_DATE_WIDTH * MY_CHARSET_BIN_MB_MAXLEN;
3175
 
        break;
3176
 
      case TIME_ONLY:
3177
 
      case TIME_MICROSECOND:
3178
 
        cached_timestamp_type= DRIZZLE_TIMESTAMP_TIME;
3179
 
        cached_field_type= DRIZZLE_TYPE_TIME; 
3180
 
        max_length= MAX_TIME_WIDTH * MY_CHARSET_BIN_MB_MAXLEN;
3181
 
        break;
3182
 
      default:
3183
 
        cached_timestamp_type= DRIZZLE_TIMESTAMP_DATETIME;
3184
 
        cached_field_type= DRIZZLE_TYPE_DATETIME; 
3185
 
        break;
3186
 
      }
3187
 
    }
3188
 
  }
3189
 
}
3190
 
 
3191
 
 
3192
 
bool Item_func_str_to_date::get_date(DRIZZLE_TIME *ltime, uint32_t fuzzy_date)
3193
 
{
3194
 
  DATE_TIME_FORMAT date_time_format;
3195
 
  char val_buff[64], format_buff[64];
3196
 
  String val_string(val_buff, sizeof(val_buff), &my_charset_bin), *val;
3197
 
  String format_str(format_buff, sizeof(format_buff), &my_charset_bin), *format;
3198
 
 
3199
 
  val=    args[0]->val_str(&val_string);
3200
 
  format= args[1]->val_str(&format_str);
3201
 
  if (args[0]->null_value || args[1]->null_value)
3202
 
    goto null_date;
3203
 
 
3204
 
  null_value= 0;
3205
 
  memset(ltime, 0, sizeof(*ltime));
3206
 
  date_time_format.format.str=    (char*) format->ptr();
3207
 
  date_time_format.format.length= format->length();
3208
 
  if (extract_date_time(&date_time_format, val->ptr(), val->length(),
3209
 
                        ltime, cached_timestamp_type, 0, "datetime") ||
3210
 
      ((fuzzy_date & TIME_NO_ZERO_DATE) &&
3211
 
       (ltime->year == 0 || ltime->month == 0 || ltime->day == 0)))
3212
 
    goto null_date;
3213
 
  if (cached_timestamp_type == DRIZZLE_TIMESTAMP_TIME && ltime->day)
3214
 
  {
3215
 
    /*
3216
 
      Day part for time type can be nonzero value and so 
3217
 
      we should add hours from day part to hour part to
3218
 
      keep valid time value.
3219
 
    */
3220
 
    ltime->hour+= ltime->day*24;
3221
 
    ltime->day= 0;
3222
 
  }
3223
 
  return 0;
3224
 
 
3225
 
null_date:
3226
 
  return (null_value=1);
3227
 
}
3228
 
 
3229
 
 
3230
 
String *Item_func_str_to_date::val_str(String *str)
3231
 
{
3232
 
  assert(fixed == 1);
3233
 
  DRIZZLE_TIME ltime;
3234
 
 
3235
 
  if (Item_func_str_to_date::get_date(&ltime, TIME_FUZZY_DATE))
3236
 
    return 0;
3237
 
 
3238
 
  if (!make_datetime((const_item ? cached_format_type :
3239
 
                     (ltime.second_part ? DATE_TIME_MICROSECOND : DATE_TIME)),
3240
 
                     &ltime, str))
3241
 
    return str;
3242
 
  return 0;
3243
 
}
3244
 
 
3245
 
 
3246
 
bool Item_func_last_day::get_date(DRIZZLE_TIME *ltime, uint32_t fuzzy_date)
3247
 
{
3248
 
  if (get_arg0_date(ltime, fuzzy_date & ~TIME_FUZZY_DATE) ||
3249
 
      (ltime->month == 0))
3250
 
  {
3251
 
    null_value= 1;
3252
 
    return 1;
3253
 
  }
3254
 
  null_value= 0;
3255
 
  uint32_t month_idx= ltime->month-1;
3256
 
  ltime->day= days_in_month[month_idx];
3257
 
  if ( month_idx == 1 && calc_days_in_year(ltime->year) == 366)
3258
 
    ltime->day= 29;
3259
 
  ltime->hour= ltime->minute= ltime->second= 0;
3260
 
  ltime->second_part= 0;
3261
 
  ltime->time_type= DRIZZLE_TIMESTAMP_DATE;
3262
 
  return 0;
3263
 
}