← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/time.cc

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/time.cc
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008-2009 Sun Microsystems, Inc.
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
 
1
/* Copyright (C) 2000-2006 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 */
19
15
 
20
16
 
21
17
/* Functions to handle date and time */
22
18
 
23
 
#include "config.h"
24
 
#include "drizzled/error.h"
25
 
#include "drizzled/util/test.h"
26
 
#include "drizzled/tztime.h"
27
 
#include "drizzled/session.h"
28
 
#include "drizzled/time_functions.h"
29
 
 
30
 
namespace drizzled
31
 
{
32
 
 
33
 
/* Some functions to calculate dates */
34
 
 
 
19
#include "mysql_priv.h"
 
20
#include <m_ctype.h>
 
21
 
 
22
 
 
23
        /* Some functions to calculate dates */
 
24
 
 
25
#ifndef TESTTIME
 
26
 
 
27
/*
 
28
  Name description of interval names used in statements.
 
29
 
 
30
  'interval_type_to_name' is ordered and sorted on interval size and
 
31
  interval complexity.
 
32
  Order of elements in 'interval_type_to_name' should correspond to 
 
33
  the order of elements in 'interval_type' enum
 
34
  
 
35
  See also interval_type, interval_names
 
36
*/
 
37
 
 
38
LEX_STRING interval_type_to_name[INTERVAL_LAST] = {
 
39
  { C_STRING_WITH_LEN("YEAR")},
 
40
  { C_STRING_WITH_LEN("QUARTER")},
 
41
  { C_STRING_WITH_LEN("MONTH")},
 
42
  { C_STRING_WITH_LEN("WEEK")},
 
43
  { C_STRING_WITH_LEN("DAY")},
 
44
  { C_STRING_WITH_LEN("HOUR")},
 
45
  { C_STRING_WITH_LEN("MINUTE")},
 
46
  { C_STRING_WITH_LEN("SECOND")},
 
47
  { C_STRING_WITH_LEN("MICROSECOND")},
 
48
  { C_STRING_WITH_LEN("YEAR_MONTH")},
 
49
  { C_STRING_WITH_LEN("DAY_HOUR")},
 
50
  { C_STRING_WITH_LEN("DAY_MINUTE")},
 
51
  { C_STRING_WITH_LEN("DAY_SECOND")},
 
52
  { C_STRING_WITH_LEN("HOUR_MINUTE")},
 
53
  { C_STRING_WITH_LEN("HOUR_SECOND")},
 
54
  { C_STRING_WITH_LEN("MINUTE_SECOND")},
 
55
  { C_STRING_WITH_LEN("DAY_MICROSECOND")},
 
56
  { C_STRING_WITH_LEN("HOUR_MICROSECOND")},
 
57
  { C_STRING_WITH_LEN("MINUTE_MICROSECOND")},
 
58
  { C_STRING_WITH_LEN("SECOND_MICROSECOND")}
 
59
}; 
 
60
 
 
61
        /* Calc weekday from daynr */
 
62
        /* Returns 0 for monday, 1 for tuesday .... */
35
63
 
36
64
int calc_weekday(long daynr,bool sunday_first_day_of_week)
37
65
{
38
 
  return ((int) ((daynr + 5L + (sunday_first_day_of_week ? 1L : 0L)) % 7));
 
66
  DBUG_ENTER("calc_weekday");
 
67
  DBUG_RETURN ((int) ((daynr + 5L + (sunday_first_day_of_week ? 1L : 0L)) % 7));
39
68
}
40
69
 
41
 
 
42
 
uint32_t calc_week(type::Time *l_time, uint32_t week_behaviour, uint32_t *year)
 
70
/*
 
71
  The bits in week_format has the following meaning:
 
72
   WEEK_MONDAY_FIRST (0)  If not set    Sunday is first day of week
 
73
                          If set        Monday is first day of week
 
74
   WEEK_YEAR (1)          If not set    Week is in range 0-53
 
75
 
 
76
        Week 0 is returned for the the last week of the previous year (for
 
77
        a date at start of january) In this case one can get 53 for the
 
78
        first week of next year.  This flag ensures that the week is
 
79
        relevant for the given year. Note that this flag is only
 
80
        releveant if WEEK_JANUARY is not set.
 
81
 
 
82
                          If set         Week is in range 1-53.
 
83
 
 
84
        In this case one may get week 53 for a date in January (when
 
85
        the week is that last week of previous year) and week 1 for a
 
86
        date in December.
 
87
 
 
88
  WEEK_FIRST_WEEKDAY (2)  If not set    Weeks are numbered according
 
89
                                        to ISO 8601:1988
 
90
                          If set        The week that contains the first
 
91
                                        'first-day-of-week' is week 1.
 
92
        
 
93
        ISO 8601:1988 means that if the week containing January 1 has
 
94
        four or more days in the new year, then it is week 1;
 
95
        Otherwise it is the last week of the previous year, and the
 
96
        next week is week 1.
 
97
*/
 
98
 
 
99
uint calc_week(MYSQL_TIME *l_time, uint week_behaviour, uint *year)
43
100
{
44
 
  uint32_t days;
45
 
  uint32_t daynr= calc_daynr(l_time->year,l_time->month,l_time->day);
46
 
  uint32_t first_daynr= calc_daynr(l_time->year,1,1);
 
101
  uint days;
 
102
  ulong daynr=calc_daynr(l_time->year,l_time->month,l_time->day);
 
103
  ulong first_daynr=calc_daynr(l_time->year,1,1);
47
104
  bool monday_first= test(week_behaviour & WEEK_MONDAY_FIRST);
48
105
  bool week_year= test(week_behaviour & WEEK_YEAR);
49
106
  bool first_weekday= test(week_behaviour & WEEK_FIRST_WEEKDAY);
50
107
 
51
 
  uint32_t weekday= calc_weekday(first_daynr, !monday_first);
 
108
  uint weekday=calc_weekday(first_daynr, !monday_first);
52
109
  *year=l_time->year;
53
110
 
54
111
  if (l_time->month == 1 && l_time->day <= 7-weekday)
79
136
  return days/7+1;
80
137
}
81
138
 
 
139
        /* Change a daynr to year, month and day */
 
140
        /* Daynr 0 is returned as date 00.00.00 */
82
141
 
83
 
void get_date_from_daynr(long daynr,
84
 
                         uint32_t *ret_year,
85
 
                         uint32_t *ret_month,
86
 
                                           uint32_t *ret_day)
 
142
void get_date_from_daynr(long daynr,uint *ret_year,uint *ret_month,
 
143
                         uint *ret_day)
87
144
{
88
 
  uint32_t year,temp,leap_day,day_of_year,days_in_year;
89
 
  unsigned char *month_pos;
 
145
  uint year,temp,leap_day,day_of_year,days_in_year;
 
146
  uchar *month_pos;
 
147
  DBUG_ENTER("get_date_from_daynr");
90
148
 
91
149
  if (daynr <= 365L || daynr >= 3652500)
92
150
  {                                             /* Fix if wrong daynr */
94
152
  }
95
153
  else
96
154
  {
97
 
    year= (uint32_t) (daynr*100 / 36525L);
 
155
    year= (uint) (daynr*100 / 36525L);
98
156
    temp=(((year-1)/100+1)*3)/4;
99
 
    day_of_year=(uint32_t) (daynr - (long) year * 365L) - (year-1)/4 +temp;
 
157
    day_of_year=(uint) (daynr - (long) year * 365L) - (year-1)/4 +temp;
100
158
    while (day_of_year > (days_in_year= calc_days_in_year(year)))
101
159
    {
102
160
      day_of_year-=days_in_year;
107
165
    {
108
166
      if (day_of_year > 31+28)
109
167
      {
110
 
        day_of_year--;
111
 
        if (day_of_year == 31+28)
112
 
          leap_day=1;           /* Handle leapyears leapday */
 
168
        day_of_year--;
 
169
        if (day_of_year == 31+28)
 
170
          leap_day=1;           /* Handle leapyears leapday */
113
171
      }
114
172
    }
115
173
    *ret_month=1;
116
174
    for (month_pos= days_in_month ;
117
 
         day_of_year > (uint32_t) *month_pos ;
118
 
         day_of_year-= *(month_pos++), (*ret_month)++)
 
175
         day_of_year > (uint) *month_pos ;
 
176
         day_of_year-= *(month_pos++), (*ret_month)++)
119
177
      ;
120
178
    *ret_year=year;
121
179
    *ret_day=day_of_year+leap_day;
122
180
  }
123
 
  return;
124
 
}
125
 
 
126
 
 
127
 
type::timestamp_t str_to_datetime_with_warn(Session *session,
128
 
                                            const char *str, 
129
 
                                            uint32_t length, 
130
 
                                            type::Time *l_time,
131
 
                                            uint32_t flags)
132
 
{
133
 
  type::cut_t was_cut= type::VALID;
134
 
  type::timestamp_t ts_type;
135
 
 
136
 
  ts_type= l_time->store(str, length,
137
 
                         (flags | (session->variables.sql_mode &
138
 
                                   (MODE_INVALID_DATES |
139
 
                                    MODE_NO_ZERO_DATE))),
140
 
                         was_cut);
141
 
  if (was_cut || ts_type <= type::DRIZZLE_TIMESTAMP_ERROR)
142
 
    make_truncated_value_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
143
 
                                 str, length, ts_type,  NULL);
144
 
 
 
181
  DBUG_VOID_RETURN;
 
182
}
 
183
 
 
184
        /* Functions to handle periods */
 
185
 
 
186
ulong convert_period_to_month(ulong period)
 
187
{
 
188
  ulong a,b;
 
189
  if (period == 0)
 
190
    return 0L;
 
191
  if ((a=period/100) < YY_PART_YEAR)
 
192
    a+=2000;
 
193
  else if (a < 100)
 
194
    a+=1900;
 
195
  b=period%100;
 
196
  return a*12+b-1;
 
197
}
 
198
 
 
199
 
 
200
ulong convert_month_to_period(ulong month)
 
201
{
 
202
  ulong year;
 
203
  if (month == 0L)
 
204
    return 0L;
 
205
  if ((year=month/12) < 100)
 
206
  {
 
207
    year+=(year < YY_PART_YEAR) ? 2000 : 1900;
 
208
  }
 
209
  return year*100+month%12+1;
 
210
}
 
211
 
 
212
 
 
213
/*
 
214
  Convert a timestamp string to a MYSQL_TIME value and produce a warning 
 
215
  if string was truncated during conversion.
 
216
 
 
217
  NOTE
 
218
    See description of str_to_datetime() for more information.
 
219
*/
 
220
 
 
221
timestamp_type
 
222
str_to_datetime_with_warn(const char *str, uint length, MYSQL_TIME *l_time,
 
223
                          uint flags)
 
224
{
 
225
  int was_cut;
 
226
  THD *thd= current_thd;
 
227
  timestamp_type ts_type;
 
228
  
 
229
  ts_type= str_to_datetime(str, length, l_time,
 
230
                           (flags | (thd->variables.sql_mode &
 
231
                                     (MODE_INVALID_DATES |
 
232
                                      MODE_NO_ZERO_DATE))),
 
233
                           &was_cut);
 
234
  if (was_cut || ts_type <= MYSQL_TIMESTAMP_ERROR)
 
235
    make_truncated_value_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
 
236
                                 str, length, ts_type,  NullS);
145
237
  return ts_type;
146
238
}
147
239
 
148
240
 
 
241
/*
 
242
  Convert a datetime from broken-down MYSQL_TIME representation to corresponding 
 
243
  TIMESTAMP value.
 
244
 
 
245
  SYNOPSIS
 
246
    TIME_to_timestamp()
 
247
      thd             - current thread
 
248
      t               - datetime in broken-down representation, 
 
249
      in_dst_time_gap - pointer to bool which is set to true if t represents
 
250
                        value which doesn't exists (falls into the spring 
 
251
                        time-gap) or to false otherwise.
 
252
   
 
253
  RETURN
 
254
     Number seconds in UTC since start of Unix Epoch corresponding to t.
 
255
     0 - t contains datetime value which is out of TIMESTAMP range.
 
256
     
 
257
*/
 
258
my_time_t TIME_to_timestamp(THD *thd, const MYSQL_TIME *t, my_bool *in_dst_time_gap)
 
259
{
 
260
  my_time_t timestamp;
 
261
 
 
262
  *in_dst_time_gap= 0;
 
263
  thd->time_zone_used= 1;
 
264
 
 
265
  timestamp= thd->variables.time_zone->TIME_to_gmt_sec(t, in_dst_time_gap);
 
266
  if (timestamp)
 
267
  {
 
268
    return timestamp;
 
269
  }
 
270
 
 
271
  /* If we are here we have range error. */
 
272
  return(0);
 
273
}
 
274
 
 
275
 
 
276
/*
 
277
  Convert a time string to a MYSQL_TIME struct and produce a warning
 
278
  if string was cut during conversion.
 
279
 
 
280
  NOTE
 
281
    See str_to_time() for more info.
 
282
*/
149
283
bool
150
 
str_to_time_with_warn(Session *session, const char *str, uint32_t length, type::Time *l_time)
 
284
str_to_time_with_warn(const char *str, uint length, MYSQL_TIME *l_time)
151
285
{
152
286
  int warning;
153
 
  bool ret_val= l_time->store(str, length, warning, type::DRIZZLE_TIMESTAMP_TIME);
 
287
  bool ret_val= str_to_time(str, length, l_time, &warning);
154
288
  if (ret_val || warning)
155
 
    make_truncated_value_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
156
 
                                 str, length, type::DRIZZLE_TIMESTAMP_TIME, NULL);
 
289
    make_truncated_value_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
 
290
                                 str, length, MYSQL_TIMESTAMP_TIME, NullS);
157
291
  return ret_val;
158
292
}
159
293
 
160
294
 
161
 
void make_truncated_value_warning(Session *session, 
162
 
                                  DRIZZLE_ERROR::enum_warning_level level,
 
295
/*
 
296
  Convert a system time structure to TIME
 
297
*/
 
298
 
 
299
void localtime_to_TIME(MYSQL_TIME *to, struct tm *from)
 
300
{
 
301
  to->neg=0;
 
302
  to->second_part=0;
 
303
  to->year=     (int) ((from->tm_year+1900) % 10000);
 
304
  to->month=    (int) from->tm_mon+1;
 
305
  to->day=      (int) from->tm_mday;
 
306
  to->hour=     (int) from->tm_hour;
 
307
  to->minute=   (int) from->tm_min;
 
308
  to->second=   (int) from->tm_sec;
 
309
}
 
310
 
 
311
void calc_time_from_sec(MYSQL_TIME *to, long seconds, long microseconds)
 
312
{
 
313
  long t_seconds;
 
314
  // to->neg is not cleared, it may already be set to a useful value
 
315
  to->time_type= MYSQL_TIMESTAMP_TIME;
 
316
  to->year= 0;
 
317
  to->month= 0;
 
318
  to->day= 0;
 
319
  to->hour= seconds/3600L;
 
320
  t_seconds= seconds%3600L;
 
321
  to->minute= t_seconds/60L;
 
322
  to->second= t_seconds%60L;
 
323
  to->second_part= microseconds;
 
324
}
 
325
 
 
326
 
 
327
/*
 
328
  Parse a format string specification
 
329
 
 
330
  SYNOPSIS
 
331
    parse_date_time_format()
 
332
    format_type         Format of string (time, date or datetime)
 
333
    format_str          String to parse
 
334
    format_length       Length of string
 
335
    date_time_format    Format to fill in
 
336
 
 
337
  NOTES
 
338
    Fills in date_time_format->positions for all date time parts.
 
339
 
 
340
    positions marks the position for a datetime element in the format string.
 
341
    The position array elements are in the following order:
 
342
    YYYY-DD-MM HH-MM-DD.FFFFFF AM
 
343
    0    1  2  3  4  5  6      7
 
344
 
 
345
    If positions[0]= 5, it means that year will be the forth element to
 
346
    read from the parsed date string.
 
347
 
 
348
  RETURN
 
349
    0   ok
 
350
    1   error
 
351
*/
 
352
 
 
353
bool parse_date_time_format(timestamp_type format_type, 
 
354
                            const char *format, uint format_length,
 
355
                            DATE_TIME_FORMAT *date_time_format)
 
356
{
 
357
  uint offset= 0, separators= 0;
 
358
  const char *ptr= format, *format_str;
 
359
  const char *end= ptr+format_length;
 
360
  uchar *dt_pos= date_time_format->positions;
 
361
  /* need_p is set if we are using AM/PM format */
 
362
  bool need_p= 0, allow_separator= 0;
 
363
  ulong part_map= 0, separator_map= 0;
 
364
  const char *parts[16];
 
365
 
 
366
  date_time_format->time_separator= 0;
 
367
  date_time_format->flag= 0;                    // For future
 
368
 
 
369
  /*
 
370
    Fill position with 'dummy' arguments to found out if a format tag is
 
371
    used twice (This limit's the format to 255 characters, but this is ok)
 
372
  */
 
373
  dt_pos[0]= dt_pos[1]= dt_pos[2]= dt_pos[3]=
 
374
    dt_pos[4]= dt_pos[5]= dt_pos[6]= dt_pos[7]= 255;
 
375
 
 
376
  for (; ptr != end; ptr++)
 
377
  {
 
378
    if (*ptr == '%' && ptr+1 != end)
 
379
    {
 
380
      uint position;
 
381
      switch (*++ptr) {
 
382
      case 'y':                                 // Year
 
383
      case 'Y':
 
384
        position= 0;
 
385
        break;
 
386
      case 'c':                                 // Month
 
387
      case 'm':
 
388
        position= 1;
 
389
        break;
 
390
      case 'd':
 
391
      case 'e':
 
392
        position= 2;
 
393
        break;
 
394
      case 'h':
 
395
      case 'I':
 
396
      case 'l':
 
397
        need_p= 1;                              // Need AM/PM
 
398
        /* Fall through */
 
399
      case 'k':
 
400
      case 'H':
 
401
        position= 3;
 
402
        break;
 
403
      case 'i':
 
404
        position= 4;
 
405
        break;
 
406
      case 's':
 
407
      case 'S':
 
408
        position= 5;
 
409
        break;
 
410
      case 'f':
 
411
        position= 6;
 
412
        if (dt_pos[5] != offset-1 || ptr[-2] != '.')
 
413
          return 1;                             // Wrong usage of %f
 
414
        break;
 
415
      case 'p':                                 // AM/PM
 
416
        if (offset == 0)                        // Can't be first
 
417
          return 0;
 
418
        position= 7;
 
419
        break;
 
420
      default:
 
421
        return 1;                               // Unknown controll char
 
422
      }
 
423
      if (dt_pos[position] != 255)              // Don't allow same tag twice
 
424
        return 1;
 
425
      parts[position]= ptr-1;
 
426
 
 
427
      /*
 
428
        If switching from time to date, ensure that all time parts
 
429
        are used
 
430
      */
 
431
      if (part_map && position <= 2 && !(part_map & (1 | 2 | 4)))
 
432
        offset=5;
 
433
      part_map|= (ulong) 1 << position;
 
434
      dt_pos[position]= offset++;
 
435
      allow_separator= 1;
 
436
    }
 
437
    else
 
438
    {
 
439
      /*
 
440
        Don't allow any characters in format as this could easily confuse
 
441
        the date reader
 
442
      */
 
443
      if (!allow_separator)
 
444
        return 1;                               // No separator here
 
445
      allow_separator= 0;                       // Don't allow two separators
 
446
      separators++;
 
447
      /* Store in separator_map which parts are punct characters */
 
448
      if (my_ispunct(&my_charset_latin1, *ptr))
 
449
        separator_map|= (ulong) 1 << (offset-1);
 
450
      else if (!my_isspace(&my_charset_latin1, *ptr))
 
451
        return 1;
 
452
    }
 
453
  }
 
454
 
 
455
  /* If no %f, specify it after seconds.  Move %p up, if necessary */
 
456
  if ((part_map & 32) && !(part_map & 64))
 
457
  {
 
458
    dt_pos[6]= dt_pos[5] +1;
 
459
    parts[6]= parts[5];                         // For later test in (need_p)
 
460
    if (dt_pos[6] == dt_pos[7])                 // Move %p one step up if used
 
461
      dt_pos[7]++;
 
462
  }
 
463
 
 
464
  /*
 
465
    Check that we have not used a non legal format specifier and that all
 
466
    format specifiers have been used
 
467
 
 
468
    The last test is to ensure that %p is used if and only if
 
469
    it's needed.
 
470
  */
 
471
  if ((format_type == MYSQL_TIMESTAMP_DATETIME &&
 
472
       !test_all_bits(part_map, (1 | 2 | 4 | 8 | 16 | 32))) ||
 
473
      (format_type == MYSQL_TIMESTAMP_DATE && part_map != (1 | 2 | 4)) ||
 
474
      (format_type == MYSQL_TIMESTAMP_TIME &&
 
475
       !test_all_bits(part_map, 8 | 16 | 32)) ||
 
476
      !allow_separator ||                       // %option should be last
 
477
      (need_p && dt_pos[6] +1 != dt_pos[7]) ||
 
478
      (need_p ^ (dt_pos[7] != 255)))
 
479
    return 1;
 
480
 
 
481
  if (dt_pos[6] != 255)                         // If fractional seconds
 
482
  {
 
483
    /* remove fractional seconds from later tests */
 
484
    uint pos= dt_pos[6] -1;
 
485
    /* Remove separator before %f from sep map */
 
486
    separator_map= ((separator_map & ((ulong) (1 << pos)-1)) |
 
487
                    ((separator_map & ~((ulong) (1 << pos)-1)) >> 1));
 
488
    if (part_map & 64)                        
 
489
    {
 
490
      separators--;                             // There is always a separator
 
491
      need_p= 1;                                // force use of separators
 
492
    }
 
493
  }
 
494
 
 
495
  /*
 
496
    Remove possible separator before %p from sep_map
 
497
    (This can either be at position 3, 4, 6 or 7) h.m.d.%f %p
 
498
  */
 
499
  if (dt_pos[7] != 255)
 
500
  {
 
501
    if (need_p && parts[7] != parts[6]+2)
 
502
      separators--;
 
503
  }     
 
504
  /*
 
505
    Calculate if %p is in first or last part of the datetime field
 
506
 
 
507
    At this point we have either %H-%i-%s %p 'year parts' or
 
508
    'year parts' &H-%i-%s %p" as %f was removed above
 
509
  */
 
510
  offset= dt_pos[6] <= 3 ? 3 : 6;
 
511
  /* Remove separator before %p from sep map */
 
512
  separator_map= ((separator_map & ((ulong) (1 << offset)-1)) |
 
513
                  ((separator_map & ~((ulong) (1 << offset)-1)) >> 1));
 
514
 
 
515
  format_str= 0;
 
516
  switch (format_type) {
 
517
  case MYSQL_TIMESTAMP_DATE:
 
518
    format_str= known_date_time_formats[INTERNAL_FORMAT].date_format;
 
519
    /* fall through */
 
520
  case MYSQL_TIMESTAMP_TIME:
 
521
    if (!format_str)
 
522
      format_str=known_date_time_formats[INTERNAL_FORMAT].time_format;
 
523
 
 
524
    /*
 
525
      If there is no separators, allow the internal format as we can read
 
526
      this.  If separators are used, they must be between each part
 
527
    */
 
528
    if (format_length == 6 && !need_p &&
 
529
        !my_strnncoll(&my_charset_bin,
 
530
                      (const uchar *) format, 6, 
 
531
                      (const uchar *) format_str, 6))
 
532
      return 0;
 
533
    if (separator_map == (1 | 2))
 
534
    {
 
535
      if (format_type == MYSQL_TIMESTAMP_TIME)
 
536
      {
 
537
        if (*(format+2) != *(format+5))
 
538
          break;                                // Error
 
539
        /* Store the character used for time formats */
 
540
        date_time_format->time_separator= *(format+2);
 
541
      }
 
542
      return 0;
 
543
    }
 
544
    break;
 
545
  case MYSQL_TIMESTAMP_DATETIME:
 
546
    /*
 
547
      If there is no separators, allow the internal format as we can read
 
548
      this.  If separators are used, they must be between each part.
 
549
      Between DATE and TIME we also allow space as separator
 
550
    */
 
551
    if ((format_length == 12 && !need_p &&
 
552
         !my_strnncoll(&my_charset_bin, 
 
553
                       (const uchar *) format, 12,
 
554
                       (const uchar*) known_date_time_formats[INTERNAL_FORMAT].datetime_format,
 
555
                       12)) ||
 
556
        (separators == 5 && separator_map == (1 | 2 | 8 | 16)))
 
557
      return 0;
 
558
    break;
 
559
  default:
 
560
    DBUG_ASSERT(1);
 
561
    break;
 
562
  }
 
563
  return 1;                                     // Error
 
564
}
 
565
 
 
566
 
 
567
/*
 
568
  Create a DATE_TIME_FORMAT object from a format string specification
 
569
 
 
570
  SYNOPSIS
 
571
    date_time_format_make()
 
572
    format_type         Format to parse (time, date or datetime)
 
573
    format_str          String to parse
 
574
    format_length       Length of string
 
575
 
 
576
  NOTES
 
577
    The returned object should be freed with my_free()
 
578
 
 
579
  RETURN
 
580
    NULL ponter:        Error
 
581
    new object
 
582
*/
 
583
 
 
584
DATE_TIME_FORMAT
 
585
*date_time_format_make(timestamp_type format_type,
 
586
                       const char *format_str, uint format_length)
 
587
{
 
588
  DATE_TIME_FORMAT tmp;
 
589
 
 
590
  if (format_length && format_length < 255 &&
 
591
      !parse_date_time_format(format_type, format_str,
 
592
                              format_length, &tmp))
 
593
  {
 
594
    tmp.format.str=    (char*) format_str;
 
595
    tmp.format.length= format_length;
 
596
    return date_time_format_copy((THD *)0, &tmp);
 
597
  }
 
598
  return 0;
 
599
}
 
600
 
 
601
 
 
602
/*
 
603
  Create a copy of a DATE_TIME_FORMAT object
 
604
 
 
605
  SYNOPSIS
 
606
    date_and_time_format_copy()
 
607
    thd                 Set if variable should be allocated in thread mem
 
608
    format              format to copy
 
609
 
 
610
  NOTES
 
611
    The returned object should be freed with my_free()
 
612
 
 
613
  RETURN
 
614
    NULL ponter:        Error
 
615
    new object
 
616
*/
 
617
 
 
618
DATE_TIME_FORMAT *date_time_format_copy(THD *thd, DATE_TIME_FORMAT *format)
 
619
{
 
620
  DATE_TIME_FORMAT *new_format;
 
621
  ulong length= sizeof(*format) + format->format.length + 1;
 
622
 
 
623
  if (thd)
 
624
    new_format= (DATE_TIME_FORMAT *) thd->alloc(length);
 
625
  else
 
626
    new_format=  (DATE_TIME_FORMAT *) my_malloc(length, MYF(MY_WME));
 
627
  if (new_format)
 
628
  {
 
629
    /* Put format string after current pos */
 
630
    new_format->format.str= (char*) (new_format+1);
 
631
    memcpy((char*) new_format->positions, (char*) format->positions,
 
632
           sizeof(format->positions));
 
633
    new_format->time_separator= format->time_separator;
 
634
    /* We make the string null terminated for easy printf in SHOW VARIABLES */
 
635
    memcpy((char*) new_format->format.str, format->format.str,
 
636
           format->format.length);
 
637
    new_format->format.str[format->format.length]= 0;
 
638
    new_format->format.length= format->format.length;
 
639
  }
 
640
  return new_format;
 
641
}
 
642
 
 
643
 
 
644
KNOWN_DATE_TIME_FORMAT known_date_time_formats[6]=
 
645
{
 
646
  {"USA", "%m.%d.%Y", "%Y-%m-%d %H.%i.%s", "%h:%i:%s %p" },
 
647
  {"JIS", "%Y-%m-%d", "%Y-%m-%d %H:%i:%s", "%H:%i:%s" },
 
648
  {"ISO", "%Y-%m-%d", "%Y-%m-%d %H:%i:%s", "%H:%i:%s" },
 
649
  {"EUR", "%d.%m.%Y", "%Y-%m-%d %H.%i.%s", "%H.%i.%s" },
 
650
  {"INTERNAL", "%Y%m%d",   "%Y%m%d%H%i%s", "%H%i%s" },
 
651
  { 0, 0, 0, 0 }
 
652
};
 
653
 
 
654
 
 
655
/*
 
656
   Return format string according format name.
 
657
   If name is unknown, result is NULL
 
658
*/
 
659
 
 
660
const char *get_date_time_format_str(KNOWN_DATE_TIME_FORMAT *format,
 
661
                                     timestamp_type type)
 
662
{
 
663
  switch (type) {
 
664
  case MYSQL_TIMESTAMP_DATE:
 
665
    return format->date_format;
 
666
  case MYSQL_TIMESTAMP_DATETIME:
 
667
    return format->datetime_format;
 
668
  case MYSQL_TIMESTAMP_TIME:
 
669
    return format->time_format;
 
670
  default:
 
671
    DBUG_ASSERT(0);                             // Impossible
 
672
    return 0;
 
673
  }
 
674
}
 
675
 
 
676
/****************************************************************************
 
677
  Functions to create default time/date/datetime strings
 
678
 
 
679
  NOTE:
 
680
    For the moment the DATE_TIME_FORMAT argument is ignored becasue
 
681
    MySQL doesn't support comparing of date/time/datetime strings that
 
682
    are not in arbutary order as dates are compared as strings in some
 
683
    context)
 
684
    This functions don't check that given MYSQL_TIME structure members are
 
685
    in valid range. If they are not, return value won't reflect any 
 
686
    valid date either. Additionally, make_time doesn't take into
 
687
    account time->day member: it's assumed that days have been converted
 
688
    to hours already.
 
689
****************************************************************************/
 
690
 
 
691
void make_time(const DATE_TIME_FORMAT *format __attribute__((unused)),
 
692
               const MYSQL_TIME *l_time, String *str)
 
693
{
 
694
  uint length= (uint) my_time_to_str(l_time, (char*) str->ptr());
 
695
  str->length(length);
 
696
  str->set_charset(&my_charset_bin);
 
697
}
 
698
 
 
699
 
 
700
void make_date(const DATE_TIME_FORMAT *format __attribute__((unused)),
 
701
               const MYSQL_TIME *l_time, String *str)
 
702
{
 
703
  uint length= (uint) my_date_to_str(l_time, (char*) str->ptr());
 
704
  str->length(length);
 
705
  str->set_charset(&my_charset_bin);
 
706
}
 
707
 
 
708
 
 
709
void make_datetime(const DATE_TIME_FORMAT *format __attribute__((unused)),
 
710
                   const MYSQL_TIME *l_time, String *str)
 
711
{
 
712
  uint length= (uint) my_datetime_to_str(l_time, (char*) str->ptr());
 
713
  str->length(length);
 
714
  str->set_charset(&my_charset_bin);
 
715
}
 
716
 
 
717
 
 
718
void make_truncated_value_warning(THD *thd, MYSQL_ERROR::enum_warning_level level,
163
719
                                  const char *str_val,
164
 
                                                          uint32_t str_length,
165
 
                                  type::timestamp_t time_type,
 
720
                                  uint str_length, timestamp_type time_type,
166
721
                                  const char *field_name)
167
722
{
168
 
  char warn_buff[DRIZZLE_ERRMSG_SIZE];
 
723
  char warn_buff[MYSQL_ERRMSG_SIZE];
169
724
  const char *type_str;
170
 
  CHARSET_INFO *cs= &my_charset_utf8_general_ci;
 
725
  CHARSET_INFO *cs= &my_charset_latin1;
171
726
  char buff[128];
172
 
  String str(buff,(uint32_t) sizeof(buff), system_charset_info);
 
727
  String str(buff,(uint32) sizeof(buff), system_charset_info);
173
728
  str.copy(str_val, str_length, system_charset_info);
174
729
  str[str_length]= 0;               // Ensure we have end 0 for snprintf
175
730
 
176
731
  switch (time_type) {
177
 
  case type::DRIZZLE_TIMESTAMP_DATE:
178
 
    type_str= "date";
179
 
    break;
180
 
 
181
 
  case type::DRIZZLE_TIMESTAMP_TIME:
182
 
    type_str= "time";
183
 
    break;
184
 
 
185
 
  case type::DRIZZLE_TIMESTAMP_DATETIME:  // FALLTHROUGH
186
 
  default:
187
 
    type_str= "datetime";
188
 
    break;
 
732
    case MYSQL_TIMESTAMP_DATE: 
 
733
      type_str= "date";
 
734
      break;
 
735
    case MYSQL_TIMESTAMP_TIME:
 
736
      type_str= "time";
 
737
      break;
 
738
    case MYSQL_TIMESTAMP_DATETIME:  // FALLTHROUGH
 
739
    default:
 
740
      type_str= "datetime";
 
741
      break;
189
742
  }
190
 
 
191
743
  if (field_name)
192
 
  {
193
744
    cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff),
194
745
                       ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
195
746
                       type_str, str.c_ptr(), field_name,
196
 
                       (uint32_t) session->row_count);
197
 
  }
 
747
                       (ulong) thd->row_count);
198
748
  else
199
749
  {
200
 
    if (time_type > type::DRIZZLE_TIMESTAMP_ERROR)
201
 
    {
 
750
    if (time_type > MYSQL_TIMESTAMP_ERROR)
202
751
      cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff),
203
752
                         ER(ER_TRUNCATED_WRONG_VALUE),
204
753
                         type_str, str.c_ptr());
205
 
    }
206
754
    else
207
 
    {
208
755
      cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff),
209
756
                         ER(ER_WRONG_VALUE), type_str, str.c_ptr());
210
 
    }
211
757
  }
212
 
  push_warning(session, level,
 
758
  push_warning(thd, level,
213
759
               ER_TRUNCATED_WRONG_VALUE, warn_buff);
214
760
}
215
761
 
 
762
/* Daynumber from year 0 to 9999-12-31 */
 
763
#define MAX_DAY_NUMBER 3652424L
 
764
 
 
765
bool date_add_interval(MYSQL_TIME *ltime, interval_type int_type, INTERVAL interval)
 
766
{
 
767
  long period, sign;
 
768
 
 
769
  ltime->neg= 0;
 
770
 
 
771
  sign= (interval.neg ? -1 : 1);
 
772
 
 
773
  switch (int_type) {
 
774
  case INTERVAL_SECOND:
 
775
  case INTERVAL_SECOND_MICROSECOND:
 
776
  case INTERVAL_MICROSECOND:
 
777
  case INTERVAL_MINUTE:
 
778
  case INTERVAL_HOUR:
 
779
  case INTERVAL_MINUTE_MICROSECOND:
 
780
  case INTERVAL_MINUTE_SECOND:
 
781
  case INTERVAL_HOUR_MICROSECOND:
 
782
  case INTERVAL_HOUR_SECOND:
 
783
  case INTERVAL_HOUR_MINUTE:
 
784
  case INTERVAL_DAY_MICROSECOND:
 
785
  case INTERVAL_DAY_SECOND:
 
786
  case INTERVAL_DAY_MINUTE:
 
787
  case INTERVAL_DAY_HOUR:
 
788
  {
 
789
    longlong sec, days, daynr, microseconds, extra_sec;
 
790
    ltime->time_type= MYSQL_TIMESTAMP_DATETIME; // Return full date
 
791
    microseconds= ltime->second_part + sign*interval.second_part;
 
792
    extra_sec= microseconds/1000000L;
 
793
    microseconds= microseconds%1000000L;
 
794
 
 
795
    sec=((ltime->day-1)*3600*24L+ltime->hour*3600+ltime->minute*60+
 
796
         ltime->second +
 
797
         sign* (longlong) (interval.day*3600*24L +
 
798
                           interval.hour*LL(3600)+interval.minute*LL(60)+
 
799
                           interval.second))+ extra_sec;
 
800
    if (microseconds < 0)
 
801
    {
 
802
      microseconds+= LL(1000000);
 
803
      sec--;
 
804
    }
 
805
    days= sec/(3600*LL(24));
 
806
    sec-= days*3600*LL(24);
 
807
    if (sec < 0)
 
808
    {
 
809
      days--;
 
810
      sec+= 3600*LL(24);
 
811
    }
 
812
    ltime->second_part= (uint) microseconds;
 
813
    ltime->second= (uint) (sec % 60);
 
814
    ltime->minute= (uint) (sec/60 % 60);
 
815
    ltime->hour=   (uint) (sec/3600);
 
816
    daynr= calc_daynr(ltime->year,ltime->month,1) + days;
 
817
    /* Day number from year 0 to 9999-12-31 */
 
818
    if ((ulonglong) daynr > MAX_DAY_NUMBER)
 
819
      goto invalid_date;
 
820
    get_date_from_daynr((long) daynr, &ltime->year, &ltime->month,
 
821
                        &ltime->day);
 
822
    break;
 
823
  }
 
824
  case INTERVAL_DAY:
 
825
  case INTERVAL_WEEK:
 
826
    period= (calc_daynr(ltime->year,ltime->month,ltime->day) +
 
827
             sign * (long) interval.day);
 
828
    /* Daynumber from year 0 to 9999-12-31 */
 
829
    if ((ulong) period > MAX_DAY_NUMBER)
 
830
      goto invalid_date;
 
831
    get_date_from_daynr((long) period,&ltime->year,&ltime->month,&ltime->day);
 
832
    break;
 
833
  case INTERVAL_YEAR:
 
834
    ltime->year+= sign * (long) interval.year;
 
835
    if ((ulong) ltime->year >= 10000L)
 
836
      goto invalid_date;
 
837
    if (ltime->month == 2 && ltime->day == 29 &&
 
838
        calc_days_in_year(ltime->year) != 366)
 
839
      ltime->day=28;                            // Was leap-year
 
840
    break;
 
841
  case INTERVAL_YEAR_MONTH:
 
842
  case INTERVAL_QUARTER:
 
843
  case INTERVAL_MONTH:
 
844
    period= (ltime->year*12 + sign * (long) interval.year*12 +
 
845
             ltime->month-1 + sign * (long) interval.month);
 
846
    if ((ulong) period >= 120000L)
 
847
      goto invalid_date;
 
848
    ltime->year= (uint) (period / 12);
 
849
    ltime->month= (uint) (period % 12L)+1;
 
850
    /* Adjust day if the new month doesn't have enough days */
 
851
    if (ltime->day > days_in_month[ltime->month-1])
 
852
    {
 
853
      ltime->day = days_in_month[ltime->month-1];
 
854
      if (ltime->month == 2 && calc_days_in_year(ltime->year) == 366)
 
855
        ltime->day++;                           // Leap-year
 
856
    }
 
857
    break;
 
858
  default:
 
859
    goto null_date;
 
860
  }
 
861
 
 
862
  return 0;                                     // Ok
 
863
 
 
864
invalid_date:
 
865
  push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
 
866
                      ER_DATETIME_FUNCTION_OVERFLOW,
 
867
                      ER(ER_DATETIME_FUNCTION_OVERFLOW),
 
868
                      "datetime");
 
869
null_date:
 
870
  return 1;
 
871
}
 
872
 
 
873
 
 
874
/*
 
875
  Calculate difference between two datetime values as seconds + microseconds.
 
876
 
 
877
  SYNOPSIS
 
878
    calc_time_diff()
 
879
      l_time1         - TIME/DATE/DATETIME value
 
880
      l_time2         - TIME/DATE/DATETIME value
 
881
      l_sign          - 1 absolute values are substracted,
 
882
                        -1 absolute values are added.
 
883
      seconds_out     - Out parameter where difference between
 
884
                        l_time1 and l_time2 in seconds is stored.
 
885
      microseconds_out- Out parameter where microsecond part of difference
 
886
                        between l_time1 and l_time2 is stored.
 
887
 
 
888
  NOTE
 
889
    This function calculates difference between l_time1 and l_time2 absolute
 
890
    values. So one should set l_sign and correct result if he want to take
 
891
    signs into account (i.e. for MYSQL_TIME values).
 
892
 
 
893
  RETURN VALUES
 
894
    Returns sign of difference.
 
895
    1 means negative result
 
896
    0 means positive result
 
897
 
 
898
*/
216
899
 
217
900
bool
218
 
calc_time_diff(type::Time *l_time1, type::Time *l_time2, int l_sign, int64_t *seconds_out,
 
901
calc_time_diff(MYSQL_TIME *l_time1, MYSQL_TIME *l_time2, int l_sign, longlong *seconds_out,
219
902
               long *microseconds_out)
220
903
{
221
904
  long days;
222
905
  bool neg;
223
 
  int64_t microseconds;
 
906
  longlong microseconds;
224
907
 
225
908
  /*
226
 
    We suppose that if first argument is DRIZZLE_TIMESTAMP_TIME
 
909
    We suppose that if first argument is MYSQL_TIMESTAMP_TIME
227
910
    the second argument should be TIMESTAMP_TIME also.
228
911
    We should check it before calc_time_diff call.
229
912
  */
230
 
  if (l_time1->time_type == type::DRIZZLE_TIMESTAMP_TIME)  // Time value
 
913
  if (l_time1->time_type == MYSQL_TIMESTAMP_TIME)  // Time value
231
914
    days= (long)l_time1->day - l_sign * (long)l_time2->day;
232
915
  else
233
916
  {
234
 
    days= calc_daynr((uint32_t) l_time1->year,
235
 
                     (uint32_t) l_time1->month,
236
 
                     (uint32_t) l_time1->day);
237
 
    if (l_time2->time_type == type::DRIZZLE_TIMESTAMP_TIME)
 
917
    days= calc_daynr((uint) l_time1->year,
 
918
                     (uint) l_time1->month,
 
919
                     (uint) l_time1->day);
 
920
    if (l_time2->time_type == MYSQL_TIMESTAMP_TIME)
238
921
      days-= l_sign * (long)l_time2->day;
239
922
    else
240
 
      days-= l_sign*calc_daynr((uint32_t) l_time2->year,
241
 
                               (uint32_t) l_time2->month,
242
 
                               (uint32_t) l_time2->day);
 
923
      days-= l_sign*calc_daynr((uint) l_time2->year,
 
924
                               (uint) l_time2->month,
 
925
                               (uint) l_time2->day);
243
926
  }
244
927
 
245
 
  microseconds= ((int64_t)days*86400L +
246
 
                 (int64_t)(l_time1->hour*3600L +
247
 
                           l_time1->minute*60L +
248
 
                           l_time1->second) -
249
 
                 l_sign*(int64_t)(l_time2->hour*3600L +
250
 
                                  l_time2->minute*60L +
251
 
                                  l_time2->second)) * 1000000L +
252
 
    (int64_t)l_time1->second_part -
253
 
    l_sign*(int64_t)l_time2->second_part;
 
928
  microseconds= ((longlong)days*LL(86400) +
 
929
                 (longlong)(l_time1->hour*3600L +
 
930
                            l_time1->minute*60L +
 
931
                            l_time1->second) -
 
932
                 l_sign*(longlong)(l_time2->hour*3600L +
 
933
                                   l_time2->minute*60L +
 
934
                                   l_time2->second)) * LL(1000000) +
 
935
                (longlong)l_time1->second_part -
 
936
                l_sign*(longlong)l_time2->second_part;
254
937
 
255
938
  neg= 0;
256
939
  if (microseconds < 0)
263
946
  return neg;
264
947
}
265
948
 
266
 
} /* namespace drizzled */
 
949
 
 
950
/*
 
951
  Compares 2 MYSQL_TIME structures
 
952
 
 
953
  SYNOPSIS
 
954
    my_time_compare()
 
955
 
 
956
      a - first time
 
957
      b - second time
 
958
 
 
959
  RETURN VALUE
 
960
   -1   - a < b
 
961
    0   - a == b
 
962
    1   - a > b
 
963
 
 
964
  NOTES
 
965
    TIME.second_part is not considered during comparison
 
966
*/
 
967
 
 
968
int
 
969
my_time_compare(MYSQL_TIME *a, MYSQL_TIME *b)
 
970
{
 
971
  my_ulonglong a_t= TIME_to_ulonglong_datetime(a);
 
972
  my_ulonglong b_t= TIME_to_ulonglong_datetime(b);
 
973
 
 
974
  if (a_t > b_t)
 
975
    return 1;
 
976
  else if (a_t < b_t)
 
977
    return -1;
 
978
 
 
979
  return 0;
 
980
}
 
981
 
 
982
#endif