← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item_timefunc.h

Merged in latest plugin-slot-reorg.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item_timefunc.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
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
 
 */
19
 
 
20
 
 
21
 
/* Function items used by mysql */
22
 
 
23
 
#ifdef USE_PRAGMA_INTERFACE
24
 
#pragma interface                       /* gcc class implementation */
25
 
#endif
26
 
 
27
 
enum date_time_format_types 
28
 
{ 
29
 
  TIME_ONLY= 0, TIME_MICROSECOND, DATE_ONLY, DATE_TIME, DATE_TIME_MICROSECOND
30
 
};
31
 
 
32
 
bool get_interval_value(Item *args,interval_type int_type,
33
 
                               String *str_value, INTERVAL *interval);
34
 
 
35
 
class Item_func_period_add :public Item_int_func
36
 
{
37
 
public:
38
 
  Item_func_period_add(Item *a,Item *b) :Item_int_func(a,b) {}
39
 
  int64_t val_int();
40
 
  const char *func_name() const { return "period_add"; }
41
 
  void fix_length_and_dec() 
42
 
  { 
43
 
    max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
44
 
  }
45
 
};
46
 
 
47
 
 
48
 
class Item_func_period_diff :public Item_int_func
49
 
{
50
 
public:
51
 
  Item_func_period_diff(Item *a,Item *b) :Item_int_func(a,b) {}
52
 
  int64_t val_int();
53
 
  const char *func_name() const { return "period_diff"; }
54
 
  void fix_length_and_dec()
55
 
  { 
56
 
    decimals=0;
57
 
    max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
58
 
  }
59
 
};
60
 
 
61
 
 
62
 
class Item_func_to_days :public Item_int_func
63
 
{
64
 
public:
65
 
  Item_func_to_days(Item *a) :Item_int_func(a) {}
66
 
  int64_t val_int();
67
 
  const char *func_name() const { return "to_days"; }
68
 
  void fix_length_and_dec() 
69
 
  { 
70
 
    decimals=0; 
71
 
    max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
72
 
    maybe_null=1; 
73
 
  }
74
 
  enum_monotonicity_info get_monotonicity_info() const;
75
 
  int64_t val_int_endpoint(bool left_endp, bool *incl_endp);
76
 
};
77
 
 
78
 
 
79
 
class Item_func_dayofmonth :public Item_int_func
80
 
{
81
 
public:
82
 
  Item_func_dayofmonth(Item *a) :Item_int_func(a) {}
83
 
  int64_t val_int();
84
 
  const char *func_name() const { return "dayofmonth"; }
85
 
  void fix_length_and_dec() 
86
 
  { 
87
 
    decimals=0; 
88
 
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
89
 
    maybe_null=1; 
90
 
  }
91
 
};
92
 
 
93
 
 
94
 
class Item_func_month :public Item_func
95
 
{
96
 
public:
97
 
  Item_func_month(Item *a) :Item_func(a) {}
98
 
  int64_t val_int();
99
 
  double val_real()
100
 
  { assert(fixed == 1); return (double) Item_func_month::val_int(); }
101
 
  String *val_str(String *str) 
102
 
  {
103
 
    str->set(val_int(), &my_charset_bin);
104
 
    return null_value ? 0 : str;
105
 
  }
106
 
  const char *func_name() const { return "month"; }
107
 
  enum Item_result result_type () const { return INT_RESULT; }
108
 
  void fix_length_and_dec() 
109
 
  { 
110
 
    collation.set(&my_charset_bin);
111
 
    decimals=0;
112
 
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
113
 
    maybe_null=1; 
114
 
  }
115
 
};
116
 
 
117
 
 
118
 
class Item_func_monthname :public Item_func_month
119
 
{
120
 
public:
121
 
  Item_func_monthname(Item *a) :Item_func_month(a) {}
122
 
  const char *func_name() const { return "monthname"; }
123
 
  String *val_str(String *str);
124
 
  enum Item_result result_type () const { return STRING_RESULT; }
125
 
  void fix_length_and_dec() 
126
 
  {
127
 
    collation.set(&my_charset_bin);
128
 
    decimals=0;
129
 
    max_length=10*my_charset_bin.mbmaxlen;
130
 
    maybe_null=1; 
131
 
  }
132
 
};
133
 
 
134
 
 
135
 
class Item_func_dayofyear :public Item_int_func
136
 
{
137
 
public:
138
 
  Item_func_dayofyear(Item *a) :Item_int_func(a) {}
139
 
  int64_t val_int();
140
 
  const char *func_name() const { return "dayofyear"; }
141
 
  void fix_length_and_dec() 
142
 
  { 
143
 
    decimals=0;
144
 
    max_length=3*MY_CHARSET_BIN_MB_MAXLEN;
145
 
    maybe_null=1; 
146
 
  }
147
 
};
148
 
 
149
 
 
150
 
class Item_func_hour :public Item_int_func
151
 
{
152
 
public:
153
 
  Item_func_hour(Item *a) :Item_int_func(a) {}
154
 
  int64_t val_int();
155
 
  const char *func_name() const { return "hour"; }
156
 
  void fix_length_and_dec()
157
 
  {
158
 
    decimals=0;
159
 
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
160
 
    maybe_null=1;
161
 
  }
162
 
};
163
 
 
164
 
 
165
 
class Item_func_minute :public Item_int_func
166
 
{
167
 
public:
168
 
  Item_func_minute(Item *a) :Item_int_func(a) {}
169
 
  int64_t val_int();
170
 
  const char *func_name() const { return "minute"; }
171
 
  void fix_length_and_dec()
172
 
  {
173
 
    decimals=0;
174
 
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
175
 
    maybe_null=1;
176
 
  }
177
 
};
178
 
 
179
 
 
180
 
class Item_func_quarter :public Item_int_func
181
 
{
182
 
public:
183
 
  Item_func_quarter(Item *a) :Item_int_func(a) {}
184
 
  int64_t val_int();
185
 
  const char *func_name() const { return "quarter"; }
186
 
  void fix_length_and_dec()
187
 
  { 
188
 
     decimals=0;
189
 
     max_length=1*MY_CHARSET_BIN_MB_MAXLEN;
190
 
     maybe_null=1;
191
 
  }
192
 
};
193
 
 
194
 
 
195
 
class Item_func_second :public Item_int_func
196
 
{
197
 
public:
198
 
  Item_func_second(Item *a) :Item_int_func(a) {}
199
 
  int64_t val_int();
200
 
  const char *func_name() const { return "second"; }
201
 
  void fix_length_and_dec() 
202
 
  { 
203
 
    decimals=0;
204
 
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
205
 
    maybe_null=1;
206
 
  }
207
 
};
208
 
 
209
 
 
210
 
class Item_func_week :public Item_int_func
211
 
{
212
 
public:
213
 
  Item_func_week(Item *a,Item *b) :Item_int_func(a,b) {}
214
 
  int64_t val_int();
215
 
  const char *func_name() const { return "week"; }
216
 
  void fix_length_and_dec()
217
 
  { 
218
 
    decimals=0;
219
 
    max_length=2*MY_CHARSET_BIN_MB_MAXLEN;
220
 
    maybe_null=1;
221
 
  }
222
 
};
223
 
 
224
 
class Item_func_yearweek :public Item_int_func
225
 
{
226
 
public:
227
 
  Item_func_yearweek(Item *a,Item *b) :Item_int_func(a,b) {}
228
 
  int64_t val_int();
229
 
  const char *func_name() const { return "yearweek"; }
230
 
  void fix_length_and_dec()
231
 
  { 
232
 
    decimals=0;
233
 
    max_length=6*MY_CHARSET_BIN_MB_MAXLEN;
234
 
    maybe_null=1;
235
 
  }
236
 
};
237
 
 
238
 
 
239
 
class Item_func_year :public Item_int_func
240
 
{
241
 
public:
242
 
  Item_func_year(Item *a) :Item_int_func(a) {}
243
 
  int64_t val_int();
244
 
  const char *func_name() const { return "year"; }
245
 
  enum_monotonicity_info get_monotonicity_info() const;
246
 
  int64_t val_int_endpoint(bool left_endp, bool *incl_endp);
247
 
  void fix_length_and_dec()
248
 
  { 
249
 
    decimals=0;
250
 
    max_length=4*MY_CHARSET_BIN_MB_MAXLEN;
251
 
    maybe_null=1;
252
 
  }
253
 
};
254
 
 
255
 
 
256
 
class Item_func_weekday :public Item_func
257
 
{
258
 
  bool odbc_type;
259
 
public:
260
 
  Item_func_weekday(Item *a,bool type_arg)
261
 
    :Item_func(a), odbc_type(type_arg) {}
262
 
  int64_t val_int();
263
 
  double val_real() { assert(fixed == 1); return (double) val_int(); }
264
 
  String *val_str(String *str)
265
 
  {
266
 
    assert(fixed == 1);
267
 
    str->set(val_int(), &my_charset_bin);
268
 
    return null_value ? 0 : str;
269
 
  }
270
 
  const char *func_name() const
271
 
  {
272
 
     return (odbc_type ? "dayofweek" : "weekday");
273
 
  }
274
 
  enum Item_result result_type () const { return INT_RESULT; }
275
 
  void fix_length_and_dec()
276
 
  {
277
 
    collation.set(&my_charset_bin);
278
 
    decimals=0;
279
 
    max_length=1*MY_CHARSET_BIN_MB_MAXLEN;
280
 
    maybe_null=1;
281
 
  }
282
 
};
283
 
 
284
 
class Item_func_dayname :public Item_func_weekday
285
 
{
286
 
 public:
287
 
  Item_func_dayname(Item *a) :Item_func_weekday(a,0) {}
288
 
  const char *func_name() const { return "dayname"; }
289
 
  String *val_str(String *str);
290
 
  enum Item_result result_type () const { return STRING_RESULT; }
291
 
  void fix_length_and_dec() 
292
 
  { 
293
 
    collation.set(&my_charset_bin);
294
 
    decimals=0; 
295
 
    max_length=9*MY_CHARSET_BIN_MB_MAXLEN;
296
 
    maybe_null=1; 
297
 
  }
298
 
};
299
 
 
300
 
 
301
 
class Item_func_unix_timestamp :public Item_int_func
302
 
{
303
 
  String value;
304
 
public:
305
 
  Item_func_unix_timestamp() :Item_int_func() {}
306
 
  Item_func_unix_timestamp(Item *a) :Item_int_func(a) {}
307
 
  int64_t val_int();
308
 
  const char *func_name() const { return "unix_timestamp"; }
309
 
  void fix_length_and_dec()
310
 
  {
311
 
    decimals=0;
312
 
    max_length=10*MY_CHARSET_BIN_MB_MAXLEN;
313
 
  }
314
 
};
315
 
 
316
 
 
317
 
class Item_func_time_to_sec :public Item_int_func
318
 
{
319
 
public:
320
 
  Item_func_time_to_sec(Item *item) :Item_int_func(item) {}
321
 
  int64_t val_int();
322
 
  const char *func_name() const { return "time_to_sec"; }
323
 
  void fix_length_and_dec()
324
 
  {
325
 
    decimals=0;
326
 
    max_length=10*MY_CHARSET_BIN_MB_MAXLEN;
327
 
  }
328
 
};
329
 
 
330
 
 
331
 
/*
332
 
  This can't be a Item_str_func, because the val_real() functions are special
333
 
*/
334
 
 
335
 
class Item_date :public Item_func
336
 
{
337
 
public:
338
 
  Item_date() :Item_func() {}
339
 
  Item_date(Item *a) :Item_func(a) {}
340
 
  enum Item_result result_type () const { return STRING_RESULT; }
341
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_NEWDATE; }
342
 
  String *val_str(String *str);
343
 
  int64_t val_int();
344
 
  double val_real() { return val_real_from_decimal(); }
345
 
  const char *func_name() const { return "date"; }
346
 
  void fix_length_and_dec()
347
 
  { 
348
 
    collation.set(&my_charset_bin);
349
 
    decimals=0;
350
 
    max_length=MAX_DATE_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
351
 
  }
352
 
  Field *tmp_table_field(Table *table)
353
 
  {
354
 
    return tmp_table_field_from_field_type(table, 0);
355
 
  }
356
 
  bool result_as_int64_t() { return true; }
357
 
  my_decimal *val_decimal(my_decimal *decimal_value)
358
 
  {
359
 
    assert(fixed == 1);
360
 
    return  val_decimal_from_date(decimal_value);
361
 
  }
362
 
  int save_in_field(Field *field,
363
 
                    bool no_conversions __attribute__((unused)))
364
 
  {
365
 
    return save_date_in_field(field);
366
 
  }
367
 
};
368
 
 
369
 
 
370
 
class Item_date_func :public Item_str_func
371
 
{
372
 
public:
373
 
  Item_date_func() :Item_str_func() {}
374
 
  Item_date_func(Item *a) :Item_str_func(a) {}
375
 
  Item_date_func(Item *a,Item *b) :Item_str_func(a,b) {}
376
 
  Item_date_func(Item *a,Item *b, Item *c) :Item_str_func(a,b,c) {}
377
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_DATETIME; }
378
 
  Field *tmp_table_field(Table *table)
379
 
  {
380
 
    return tmp_table_field_from_field_type(table, 0);
381
 
  }
382
 
  bool result_as_int64_t() { return true; }
383
 
  double val_real() { return (double) val_int(); }
384
 
  my_decimal *val_decimal(my_decimal *decimal_value)
385
 
  {
386
 
    assert(fixed == 1);
387
 
    return  val_decimal_from_date(decimal_value);
388
 
  }
389
 
  int save_in_field(Field *field,
390
 
                    bool no_conversions __attribute__((unused)))
391
 
  {
392
 
    return save_date_in_field(field);
393
 
  }
394
 
};
395
 
 
396
 
 
397
 
class Item_str_timefunc :public Item_str_func
398
 
{
399
 
public:
400
 
  Item_str_timefunc() :Item_str_func() {}
401
 
  Item_str_timefunc(Item *a) :Item_str_func(a) {}
402
 
  Item_str_timefunc(Item *a,Item *b) :Item_str_func(a,b) {}
403
 
  Item_str_timefunc(Item *a, Item *b, Item *c) :Item_str_func(a, b ,c) {}
404
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_TIME; }
405
 
  void fix_length_and_dec()
406
 
  {
407
 
    decimals= DATETIME_DEC;
408
 
    max_length=MAX_TIME_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
409
 
  }
410
 
  Field *tmp_table_field(Table *table)
411
 
  {
412
 
    return tmp_table_field_from_field_type(table, 0);
413
 
  }
414
 
  double val_real() { return val_real_from_decimal(); }
415
 
  my_decimal *val_decimal(my_decimal *decimal_value)
416
 
  {
417
 
    assert(fixed == 1);
418
 
    return  val_decimal_from_time(decimal_value);
419
 
  }
420
 
  int save_in_field(Field *field,
421
 
                    bool no_conversions __attribute__((unused)))
422
 
  {
423
 
    return save_time_in_field(field);
424
 
  }
425
 
};
426
 
 
427
 
 
428
 
/* Abstract CURTIME function. Children should define what time zone is used */
429
 
 
430
 
class Item_func_curtime :public Item_str_timefunc
431
 
{
432
 
  int64_t value;
433
 
  char buff[9*2+32];
434
 
  uint32_t buff_length;
435
 
public:
436
 
  Item_func_curtime() :Item_str_timefunc() {}
437
 
  Item_func_curtime(Item *a) :Item_str_timefunc(a) {}
438
 
  double val_real() { assert(fixed == 1); return (double) value; }
439
 
  int64_t val_int() { assert(fixed == 1); return value; }
440
 
  String *val_str(String *str);
441
 
  void fix_length_and_dec();
442
 
  /* 
443
 
    Abstract method that defines which time zone is used for conversion.
444
 
    Converts time current time in my_time_t representation to broken-down
445
 
    DRIZZLE_TIME representation using UTC-SYSTEM or per-thread time zone.
446
 
  */
447
 
  virtual void store_now_in_TIME(DRIZZLE_TIME *now_time)=0;
448
 
  bool result_as_int64_t() { return true; }
449
 
};
450
 
 
451
 
 
452
 
class Item_func_curtime_local :public Item_func_curtime
453
 
{
454
 
public:
455
 
  Item_func_curtime_local() :Item_func_curtime() {}
456
 
  Item_func_curtime_local(Item *a) :Item_func_curtime(a) {}
457
 
  const char *func_name() const { return "curtime"; }
458
 
  virtual void store_now_in_TIME(DRIZZLE_TIME *now_time);
459
 
};
460
 
 
461
 
 
462
 
class Item_func_curtime_utc :public Item_func_curtime
463
 
{
464
 
public:
465
 
  Item_func_curtime_utc() :Item_func_curtime() {}
466
 
  Item_func_curtime_utc(Item *a) :Item_func_curtime(a) {}
467
 
  const char *func_name() const { return "utc_time"; }
468
 
  virtual void store_now_in_TIME(DRIZZLE_TIME *now_time);
469
 
};
470
 
 
471
 
 
472
 
/* Abstract CURDATE function. See also Item_func_curtime. */
473
 
 
474
 
class Item_func_curdate :public Item_date
475
 
{
476
 
  int64_t value;
477
 
  DRIZZLE_TIME ltime;
478
 
public:
479
 
  Item_func_curdate() :Item_date() {}
480
 
  int64_t val_int() { assert(fixed == 1); return (value) ; }
481
 
  String *val_str(String *str);
482
 
  void fix_length_and_dec();
483
 
  bool get_date(DRIZZLE_TIME *res, uint32_t fuzzy_date);
484
 
  virtual void store_now_in_TIME(DRIZZLE_TIME *now_time)=0;
485
 
};
486
 
 
487
 
 
488
 
class Item_func_curdate_local :public Item_func_curdate
489
 
{
490
 
public:
491
 
  Item_func_curdate_local() :Item_func_curdate() {}
492
 
  const char *func_name() const { return "curdate"; }
493
 
  void store_now_in_TIME(DRIZZLE_TIME *now_time);
494
 
};
495
 
 
496
 
 
497
 
class Item_func_curdate_utc :public Item_func_curdate
498
 
{
499
 
public:
500
 
  Item_func_curdate_utc() :Item_func_curdate() {}
501
 
  const char *func_name() const { return "utc_date"; }
502
 
  void store_now_in_TIME(DRIZZLE_TIME *now_time);
503
 
};
504
 
 
505
 
 
506
 
/* Abstract CURRENT_TIMESTAMP function. See also Item_func_curtime */
507
 
 
508
 
class Item_func_now :public Item_date_func
509
 
{
510
 
protected:
511
 
  int64_t value;
512
 
  char buff[20*2+32];   // +32 to make my_snprintf_{8bit|ucs2} happy
513
 
  uint32_t buff_length;
514
 
  DRIZZLE_TIME ltime;
515
 
public:
516
 
  Item_func_now() :Item_date_func() {}
517
 
  Item_func_now(Item *a) :Item_date_func(a) {}
518
 
  enum Item_result result_type () const { return STRING_RESULT; }
519
 
  int64_t val_int() { assert(fixed == 1); return value; }
520
 
  int save_in_field(Field *to, bool no_conversions);
521
 
  String *val_str(String *str);
522
 
  void fix_length_and_dec();
523
 
  bool get_date(DRIZZLE_TIME *res, uint32_t fuzzy_date);
524
 
  virtual void store_now_in_TIME(DRIZZLE_TIME *now_time)=0;
525
 
};
526
 
 
527
 
 
528
 
class Item_func_now_local :public Item_func_now
529
 
{
530
 
public:
531
 
  Item_func_now_local() :Item_func_now() {}
532
 
  Item_func_now_local(Item *a) :Item_func_now(a) {}
533
 
  const char *func_name() const { return "now"; }
534
 
  virtual void store_now_in_TIME(DRIZZLE_TIME *now_time);
535
 
  virtual enum Functype functype() const { return NOW_FUNC; }
536
 
};
537
 
 
538
 
 
539
 
class Item_func_now_utc :public Item_func_now
540
 
{
541
 
public:
542
 
  Item_func_now_utc() :Item_func_now() {}
543
 
  Item_func_now_utc(Item *a) :Item_func_now(a) {}
544
 
  const char *func_name() const { return "utc_timestamp"; }
545
 
  virtual void store_now_in_TIME(DRIZZLE_TIME *now_time);
546
 
};
547
 
 
548
 
 
549
 
/*
550
 
  This is like NOW(), but always uses the real current time, not the
551
 
  query_start(). This matches the Oracle behavior.
552
 
*/
553
 
class Item_func_sysdate_local :public Item_func_now
554
 
{
555
 
public:
556
 
  Item_func_sysdate_local() :Item_func_now() {}
557
 
  Item_func_sysdate_local(Item *a) :Item_func_now(a) {}
558
 
  bool const_item() const { return 0; }
559
 
  const char *func_name() const { return "sysdate"; }
560
 
  void store_now_in_TIME(DRIZZLE_TIME *now_time);
561
 
  double val_real();
562
 
  int64_t val_int();
563
 
  int save_in_field(Field *to, bool no_conversions);
564
 
  String *val_str(String *str);
565
 
  void fix_length_and_dec();
566
 
  bool get_date(DRIZZLE_TIME *res, uint32_t fuzzy_date);
567
 
  void update_used_tables()
568
 
  {
569
 
    Item_func_now::update_used_tables();
570
 
    used_tables_cache|= RAND_TABLE_BIT;
571
 
  }
572
 
};
573
 
 
574
 
 
575
 
class Item_func_from_days :public Item_date
576
 
{
577
 
public:
578
 
  Item_func_from_days(Item *a) :Item_date(a) {}
579
 
  const char *func_name() const { return "from_days"; }
580
 
  bool get_date(DRIZZLE_TIME *res, uint32_t fuzzy_date);
581
 
};
582
 
 
583
 
 
584
 
class Item_func_date_format :public Item_str_func
585
 
{
586
 
  int fixed_length;
587
 
  const bool is_time_format;
588
 
  String value;
589
 
public:
590
 
  Item_func_date_format(Item *a,Item *b,bool is_time_format_arg)
591
 
    :Item_str_func(a,b),is_time_format(is_time_format_arg) {}
592
 
  String *val_str(String *str);
593
 
  const char *func_name() const
594
 
    { return is_time_format ? "time_format" : "date_format"; }
595
 
  void fix_length_and_dec();
596
 
  uint32_t format_length(const String *format);
597
 
  bool eq(const Item *item, bool binary_cmp) const;
598
 
};
599
 
 
600
 
 
601
 
class Item_func_from_unixtime :public Item_date_func
602
 
{
603
 
  THD *thd;
604
 
 public:
605
 
  Item_func_from_unixtime(Item *a) :Item_date_func(a) {}
606
 
  int64_t val_int();
607
 
  String *val_str(String *str);
608
 
  const char *func_name() const { return "from_unixtime"; }
609
 
  void fix_length_and_dec();
610
 
  bool get_date(DRIZZLE_TIME *res, uint32_t fuzzy_date);
611
 
};
612
 
 
613
 
 
614
 
/* 
615
 
  We need Time_zone class declaration for storing pointers in
616
 
  Item_func_convert_tz.
617
 
*/
618
 
class Time_zone;
619
 
 
620
 
/*
621
 
  This class represents CONVERT_TZ() function.
622
 
  The important fact about this function that it is handled in special way.
623
 
  When such function is met in expression time_zone system tables are added
624
 
  to global list of tables to open, so later those already opened and locked
625
 
  tables can be used during this function calculation for loading time zone
626
 
  descriptions.
627
 
*/
628
 
class Item_func_convert_tz :public Item_date_func
629
 
{
630
 
  /*
631
 
    If time zone parameters are constants we are caching objects that
632
 
    represent them (we use separate from_tz_cached/to_tz_cached members
633
 
    to indicate this fact, since NULL is legal value for from_tz/to_tz
634
 
    members.
635
 
  */
636
 
  bool from_tz_cached, to_tz_cached;
637
 
  Time_zone *from_tz, *to_tz;
638
 
 public:
639
 
  Item_func_convert_tz(Item *a, Item *b, Item *c):
640
 
    Item_date_func(a, b, c), from_tz_cached(0), to_tz_cached(0) {}
641
 
  int64_t val_int();
642
 
  String *val_str(String *str);
643
 
  const char *func_name() const { return "convert_tz"; }
644
 
  void fix_length_and_dec();
645
 
  bool get_date(DRIZZLE_TIME *res, uint32_t fuzzy_date);
646
 
  void cleanup();
647
 
};
648
 
 
649
 
 
650
 
class Item_func_sec_to_time :public Item_str_timefunc
651
 
{
652
 
public:
653
 
  Item_func_sec_to_time(Item *item) :Item_str_timefunc(item) {}
654
 
  double val_real()
655
 
  {
656
 
    assert(fixed == 1);
657
 
    return (double) Item_func_sec_to_time::val_int();
658
 
  }
659
 
  int64_t val_int();
660
 
  String *val_str(String *);
661
 
  void fix_length_and_dec()
662
 
  { 
663
 
    Item_str_timefunc::fix_length_and_dec();
664
 
    collation.set(&my_charset_bin);
665
 
    maybe_null=1;
666
 
  }
667
 
  const char *func_name() const { return "sec_to_time"; }
668
 
  bool result_as_int64_t() { return true; }
669
 
};
670
 
 
671
 
 
672
 
class Item_date_add_interval :public Item_date_func
673
 
{
674
 
  String value;
675
 
  enum_field_types cached_field_type;
676
 
 
677
 
public:
678
 
  const interval_type int_type; // keep it public
679
 
  const bool date_sub_interval; // keep it public
680
 
  Item_date_add_interval(Item *a,Item *b,interval_type type_arg,bool neg_arg)
681
 
    :Item_date_func(a,b),int_type(type_arg), date_sub_interval(neg_arg) {}
682
 
  String *val_str(String *);
683
 
  const char *func_name() const { return "date_add_interval"; }
684
 
  void fix_length_and_dec();
685
 
  enum_field_types field_type() const { return cached_field_type; }
686
 
  int64_t val_int();
687
 
  bool get_date(DRIZZLE_TIME *res, uint32_t fuzzy_date);
688
 
  bool eq(const Item *item, bool binary_cmp) const;
689
 
  virtual void print(String *str, enum_query_type query_type);
690
 
};
691
 
 
692
 
 
693
 
class Item_extract :public Item_int_func
694
 
{
695
 
  String value;
696
 
  bool date_value;
697
 
 public:
698
 
  const interval_type int_type; // keep it public
699
 
  Item_extract(interval_type type_arg, Item *a)
700
 
    :Item_int_func(a), int_type(type_arg) {}
701
 
  int64_t val_int();
702
 
  enum Functype functype() const { return EXTRACT_FUNC; }
703
 
  const char *func_name() const { return "extract"; }
704
 
  void fix_length_and_dec();
705
 
  bool eq(const Item *item, bool binary_cmp) const;
706
 
  virtual void print(String *str, enum_query_type query_type);
707
 
};
708
 
 
709
 
 
710
 
class Item_typecast :public Item_str_func
711
 
{
712
 
public:
713
 
  Item_typecast(Item *a) :Item_str_func(a) {}
714
 
  String *val_str(String *a)
715
 
  {
716
 
    assert(fixed == 1);
717
 
    String *tmp=args[0]->val_str(a);
718
 
    null_value=args[0]->null_value;
719
 
    if (tmp)
720
 
      tmp->set_charset(collation.collation);
721
 
    return tmp;
722
 
  }
723
 
  void fix_length_and_dec()
724
 
  {
725
 
    collation.set(&my_charset_bin);
726
 
    max_length=args[0]->max_length;
727
 
  }
728
 
  virtual const char* cast_type() const= 0;
729
 
  virtual void print(String *str, enum_query_type query_type);
730
 
};
731
 
 
732
 
 
733
 
class Item_typecast_maybe_null :public Item_typecast
734
 
{
735
 
public:
736
 
  Item_typecast_maybe_null(Item *a) :Item_typecast(a) {}
737
 
  void fix_length_and_dec()
738
 
  {
739
 
    collation.set(&my_charset_bin);
740
 
    max_length=args[0]->max_length;
741
 
    maybe_null= 1;
742
 
  }
743
 
};
744
 
 
745
 
 
746
 
class Item_char_typecast :public Item_typecast
747
 
{
748
 
  int cast_length;
749
 
  const CHARSET_INFO *cast_cs, *from_cs;
750
 
  bool charset_conversion;
751
 
  String tmp_value;
752
 
public:
753
 
  Item_char_typecast(Item *a, int length_arg, const CHARSET_INFO * const cs_arg)
754
 
    :Item_typecast(a), cast_length(length_arg), cast_cs(cs_arg) {}
755
 
  enum Functype functype() const { return CHAR_TYPECAST_FUNC; }
756
 
  bool eq(const Item *item, bool binary_cmp) const;
757
 
  const char *func_name() const { return "cast_as_char"; }
758
 
  const char* cast_type() const { return "char"; };
759
 
  String *val_str(String *a);
760
 
  void fix_length_and_dec();
761
 
  virtual void print(String *str, enum_query_type query_type);
762
 
};
763
 
 
764
 
 
765
 
class Item_date_typecast :public Item_typecast_maybe_null
766
 
{
767
 
public:
768
 
  Item_date_typecast(Item *a) :Item_typecast_maybe_null(a) {}
769
 
  const char *func_name() const { return "cast_as_date"; }
770
 
  String *val_str(String *str);
771
 
  bool get_date(DRIZZLE_TIME *ltime, uint32_t fuzzy_date);
772
 
  bool get_time(DRIZZLE_TIME *ltime);
773
 
  const char *cast_type() const { return "date"; }
774
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_NEWDATE; }
775
 
  Field *tmp_table_field(Table *table)
776
 
  {
777
 
    return tmp_table_field_from_field_type(table, 0);
778
 
  }  
779
 
  void fix_length_and_dec()
780
 
  {
781
 
    collation.set(&my_charset_bin);
782
 
    max_length= 10;
783
 
    maybe_null= 1;
784
 
  }
785
 
  bool result_as_int64_t() { return true; }
786
 
  int64_t val_int();
787
 
  double val_real() { return (double) val_int(); }
788
 
  my_decimal *val_decimal(my_decimal *decimal_value)
789
 
  {
790
 
    assert(fixed == 1);
791
 
    return  val_decimal_from_date(decimal_value);
792
 
  }
793
 
  int save_in_field(Field *field,
794
 
                    bool no_conversions __attribute__((unused)))
795
 
  {
796
 
    return save_date_in_field(field);
797
 
  }
798
 
};
799
 
 
800
 
 
801
 
class Item_time_typecast :public Item_typecast_maybe_null
802
 
{
803
 
public:
804
 
  Item_time_typecast(Item *a) :Item_typecast_maybe_null(a) {}
805
 
  const char *func_name() const { return "cast_as_time"; }
806
 
  String *val_str(String *str);
807
 
  bool get_time(DRIZZLE_TIME *ltime);
808
 
  const char *cast_type() const { return "time"; }
809
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_TIME; }
810
 
  Field *tmp_table_field(Table *table)
811
 
  {
812
 
    return tmp_table_field_from_field_type(table, 0);
813
 
  }
814
 
  bool result_as_int64_t() { return true; }
815
 
  int64_t val_int();
816
 
  double val_real() { return val_real_from_decimal(); }
817
 
  my_decimal *val_decimal(my_decimal *decimal_value)
818
 
  {
819
 
    assert(fixed == 1);
820
 
    return  val_decimal_from_time(decimal_value);
821
 
  }
822
 
  int save_in_field(Field *field,
823
 
                    bool no_conversions __attribute__((unused)))
824
 
  {
825
 
    return save_time_in_field(field);
826
 
  }
827
 
};
828
 
 
829
 
 
830
 
class Item_datetime_typecast :public Item_typecast_maybe_null
831
 
{
832
 
public:
833
 
  Item_datetime_typecast(Item *a) :Item_typecast_maybe_null(a) {}
834
 
  const char *func_name() const { return "cast_as_datetime"; }
835
 
  String *val_str(String *str);
836
 
  const char *cast_type() const { return "datetime"; }
837
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_DATETIME; }
838
 
  Field *tmp_table_field(Table *table)
839
 
  {
840
 
    return tmp_table_field_from_field_type(table, 0);
841
 
  }
842
 
  void fix_length_and_dec()
843
 
  {
844
 
    collation.set(&my_charset_bin);
845
 
    maybe_null= 1;
846
 
    max_length= MAX_DATETIME_FULL_WIDTH * MY_CHARSET_BIN_MB_MAXLEN;
847
 
    decimals= DATETIME_DEC;
848
 
  }
849
 
  bool result_as_int64_t() { return true; }
850
 
  int64_t val_int();
851
 
  double val_real() { return val_real_from_decimal(); }
852
 
  double val() { return (double) val_int(); }
853
 
  my_decimal *val_decimal(my_decimal *decimal_value)
854
 
  {
855
 
    assert(fixed == 1);
856
 
    return  val_decimal_from_date(decimal_value);
857
 
  }
858
 
  int save_in_field(Field *field,
859
 
                    bool no_conversions __attribute__((unused)))
860
 
  {
861
 
    return save_date_in_field(field);
862
 
  }
863
 
};
864
 
 
865
 
class Item_func_makedate :public Item_date_func
866
 
{
867
 
public:
868
 
  Item_func_makedate(Item *a,Item *b) :Item_date_func(a,b) {}
869
 
  String *val_str(String *str);
870
 
  const char *func_name() const { return "makedate"; }
871
 
  enum_field_types field_type() const { return DRIZZLE_TYPE_NEWDATE; }
872
 
  void fix_length_and_dec()
873
 
  { 
874
 
    decimals=0;
875
 
    max_length=MAX_DATE_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
876
 
  }
877
 
  int64_t val_int();
878
 
};
879
 
 
880
 
 
881
 
class Item_func_add_time :public Item_str_func
882
 
{
883
 
  const bool is_date;
884
 
  int sign;
885
 
  enum_field_types cached_field_type;
886
 
 
887
 
public:
888
 
  Item_func_add_time(Item *a, Item *b, bool type_arg, bool neg_arg)
889
 
    :Item_str_func(a, b), is_date(type_arg) { sign= neg_arg ? -1 : 1; }
890
 
  String *val_str(String *str);
891
 
  enum_field_types field_type() const { return cached_field_type; }
892
 
  void fix_length_and_dec();
893
 
 
894
 
  Field *tmp_table_field(Table *table)
895
 
  {
896
 
    return tmp_table_field_from_field_type(table, 0);
897
 
  }
898
 
  virtual void print(String *str, enum_query_type query_type);
899
 
  const char *func_name() const { return "add_time"; }
900
 
  double val_real() { return val_real_from_decimal(); }
901
 
  my_decimal *val_decimal(my_decimal *decimal_value)
902
 
  {
903
 
    assert(fixed == 1);
904
 
    if (cached_field_type == DRIZZLE_TYPE_TIME)
905
 
      return  val_decimal_from_time(decimal_value);
906
 
    if (cached_field_type == DRIZZLE_TYPE_DATETIME)
907
 
      return  val_decimal_from_date(decimal_value);
908
 
    return Item_str_func::val_decimal(decimal_value);
909
 
  }
910
 
  int save_in_field(Field *field, bool no_conversions)
911
 
  {
912
 
    if (cached_field_type == DRIZZLE_TYPE_TIME)
913
 
      return save_time_in_field(field);
914
 
    if (cached_field_type == DRIZZLE_TYPE_DATETIME)
915
 
      return save_date_in_field(field);
916
 
    return Item_str_func::save_in_field(field, no_conversions);
917
 
  }
918
 
};
919
 
 
920
 
class Item_func_timediff :public Item_str_timefunc
921
 
{
922
 
public:
923
 
  Item_func_timediff(Item *a, Item *b)
924
 
    :Item_str_timefunc(a, b) {}
925
 
  String *val_str(String *str);
926
 
  const char *func_name() const { return "timediff"; }
927
 
  void fix_length_and_dec()
928
 
  {
929
 
    Item_str_timefunc::fix_length_and_dec();
930
 
    maybe_null= 1;
931
 
  }
932
 
};
933
 
 
934
 
class Item_func_maketime :public Item_str_timefunc
935
 
{
936
 
public:
937
 
  Item_func_maketime(Item *a, Item *b, Item *c)
938
 
    :Item_str_timefunc(a, b, c) 
939
 
  {
940
 
    maybe_null= true;
941
 
  }
942
 
  String *val_str(String *str);
943
 
  const char *func_name() const { return "maketime"; }
944
 
};
945
 
 
946
 
class Item_func_microsecond :public Item_int_func
947
 
{
948
 
public:
949
 
  Item_func_microsecond(Item *a) :Item_int_func(a) {}
950
 
  int64_t val_int();
951
 
  const char *func_name() const { return "microsecond"; }
952
 
  void fix_length_and_dec() 
953
 
  { 
954
 
    decimals=0;
955
 
    maybe_null=1;
956
 
  }
957
 
};
958
 
 
959
 
 
960
 
class Item_func_timestamp_diff :public Item_int_func
961
 
{
962
 
  const interval_type int_type;
963
 
public:
964
 
  Item_func_timestamp_diff(Item *a,Item *b,interval_type type_arg)
965
 
    :Item_int_func(a,b), int_type(type_arg) {}
966
 
  const char *func_name() const { return "timestampdiff"; }
967
 
  int64_t val_int();
968
 
  void fix_length_and_dec()
969
 
  {
970
 
    decimals=0;
971
 
    maybe_null=1;
972
 
  }
973
 
  virtual void print(String *str, enum_query_type query_type);
974
 
};
975
 
 
976
 
 
977
 
enum date_time_format
978
 
{
979
 
  USA_FORMAT, JIS_FORMAT, ISO_FORMAT, EUR_FORMAT, INTERNAL_FORMAT
980
 
};
981
 
 
982
 
class Item_func_get_format :public Item_str_func
983
 
{
984
 
public:
985
 
  const enum enum_drizzle_timestamp_type type; // keep it public
986
 
  Item_func_get_format(enum enum_drizzle_timestamp_type type_arg, Item *a)
987
 
    :Item_str_func(a), type(type_arg)
988
 
  {}
989
 
  String *val_str(String *str);
990
 
  const char *func_name() const { return "get_format"; }
991
 
  void fix_length_and_dec()
992
 
  {
993
 
    maybe_null= 1;
994
 
    decimals=0;
995
 
    max_length=17*MY_CHARSET_BIN_MB_MAXLEN;
996
 
  }
997
 
  virtual void print(String *str, enum_query_type query_type);
998
 
};
999
 
 
1000
 
 
1001
 
class Item_func_str_to_date :public Item_str_func
1002
 
{
1003
 
  enum_field_types cached_field_type;
1004
 
  date_time_format_types cached_format_type;
1005
 
  enum enum_drizzle_timestamp_type cached_timestamp_type;
1006
 
  bool const_item;
1007
 
public:
1008
 
  Item_func_str_to_date(Item *a, Item *b)
1009
 
    :Item_str_func(a, b), const_item(false)
1010
 
  {}
1011
 
  String *val_str(String *str);
1012
 
  bool get_date(DRIZZLE_TIME *ltime, uint32_t fuzzy_date);
1013
 
  const char *func_name() const { return "str_to_date"; }
1014
 
  enum_field_types field_type() const { return cached_field_type; }
1015
 
  void fix_length_and_dec();
1016
 
  Field *tmp_table_field(Table *table)
1017
 
  {
1018
 
    return tmp_table_field_from_field_type(table, 1);
1019
 
  }
1020
 
};
1021
 
 
1022
 
 
1023
 
class Item_func_last_day :public Item_date
1024
 
{
1025
 
public:
1026
 
  Item_func_last_day(Item *a) :Item_date(a) {}
1027
 
  const char *func_name() const { return "last_day"; }
1028
 
  bool get_date(DRIZZLE_TIME *res, uint32_t fuzzy_date);
1029
 
};