← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/item_func.h

  • 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/item_func.h
 
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 */
 
15
 
 
16
 
 
17
/* Function items used by mysql */
 
18
 
 
19
#ifdef USE_PRAGMA_INTERFACE
 
20
#pragma interface                       /* gcc class implementation */
 
21
#endif
 
22
 
 
23
#ifdef HAVE_IEEEFP_H
 
24
extern "C"                              /* Bug in BSDI include file */
 
25
{
 
26
#include <ieeefp.h>
 
27
}
 
28
#endif
 
29
 
 
30
class Item_func :public Item_result_field
 
31
{
 
32
protected:
 
33
  Item **args, *tmp_arg[2];
 
34
  /*
 
35
    Allowed numbers of columns in result (usually 1, which means scalar value)
 
36
    0 means get this number from first argument
 
37
  */
 
38
  uint allowed_arg_cols;
 
39
public:
 
40
  uint arg_count;
 
41
  table_map used_tables_cache, not_null_tables_cache;
 
42
  bool const_item_cache;
 
43
  enum Functype { UNKNOWN_FUNC,EQ_FUNC,EQUAL_FUNC,NE_FUNC,LT_FUNC,LE_FUNC,
 
44
                  GE_FUNC,GT_FUNC,FT_FUNC,
 
45
                  LIKE_FUNC,ISNULL_FUNC,ISNOTNULL_FUNC,
 
46
                  COND_AND_FUNC, COND_OR_FUNC, COND_XOR_FUNC,
 
47
                  BETWEEN, IN_FUNC, MULT_EQUAL_FUNC,
 
48
                  INTERVAL_FUNC, ISNOTNULLTEST_FUNC,
 
49
                  NOT_FUNC, NOT_ALL_FUNC,
 
50
                  NOW_FUNC, TRIG_COND_FUNC,
 
51
                  SUSERVAR_FUNC, GUSERVAR_FUNC, COLLATE_FUNC,
 
52
                  EXTRACT_FUNC, CHAR_TYPECAST_FUNC, FUNC_SP, UDF_FUNC,
 
53
                  NEG_FUNC };
 
54
  enum optimize_type { OPTIMIZE_NONE,OPTIMIZE_KEY,OPTIMIZE_OP, OPTIMIZE_NULL,
 
55
                       OPTIMIZE_EQUAL };
 
56
  enum Type type() const { return FUNC_ITEM; }
 
57
  virtual enum Functype functype() const   { return UNKNOWN_FUNC; }
 
58
  Item_func(void):
 
59
    allowed_arg_cols(1), arg_count(0)
 
60
  {
 
61
    with_sum_func= 0;
 
62
  }
 
63
  Item_func(Item *a):
 
64
    allowed_arg_cols(1), arg_count(1)
 
65
  {
 
66
    args= tmp_arg;
 
67
    args[0]= a;
 
68
    with_sum_func= a->with_sum_func;
 
69
  }
 
70
  Item_func(Item *a,Item *b):
 
71
    allowed_arg_cols(1), arg_count(2)
 
72
  {
 
73
    args= tmp_arg;
 
74
    args[0]= a; args[1]= b;
 
75
    with_sum_func= a->with_sum_func || b->with_sum_func;
 
76
  }
 
77
  Item_func(Item *a,Item *b,Item *c):
 
78
    allowed_arg_cols(1)
 
79
  {
 
80
    arg_count= 0;
 
81
    if ((args= (Item**) sql_alloc(sizeof(Item*)*3)))
 
82
    {
 
83
      arg_count= 3;
 
84
      args[0]= a; args[1]= b; args[2]= c;
 
85
      with_sum_func= a->with_sum_func || b->with_sum_func || c->with_sum_func;
 
86
    }
 
87
  }
 
88
  Item_func(Item *a,Item *b,Item *c,Item *d):
 
89
    allowed_arg_cols(1)
 
90
  {
 
91
    arg_count= 0;
 
92
    if ((args= (Item**) sql_alloc(sizeof(Item*)*4)))
 
93
    {
 
94
      arg_count= 4;
 
95
      args[0]= a; args[1]= b; args[2]= c; args[3]= d;
 
96
      with_sum_func= a->with_sum_func || b->with_sum_func ||
 
97
        c->with_sum_func || d->with_sum_func;
 
98
    }
 
99
  }
 
100
  Item_func(Item *a,Item *b,Item *c,Item *d,Item* e):
 
101
    allowed_arg_cols(1)
 
102
  {
 
103
    arg_count= 5;
 
104
    if ((args= (Item**) sql_alloc(sizeof(Item*)*5)))
 
105
    {
 
106
      args[0]= a; args[1]= b; args[2]= c; args[3]= d; args[4]= e;
 
107
      with_sum_func= a->with_sum_func || b->with_sum_func ||
 
108
        c->with_sum_func || d->with_sum_func || e->with_sum_func ;
 
109
    }
 
110
  }
 
111
  Item_func(List<Item> &list);
 
112
  // Constructor used for Item_cond_and/or (see Item comment)
 
113
  Item_func(THD *thd, Item_func *item);
 
114
  bool fix_fields(THD *, Item **ref);
 
115
  void fix_after_pullout(st_select_lex *new_parent, Item **ref);
 
116
  table_map used_tables() const;
 
117
  table_map not_null_tables() const;
 
118
  void update_used_tables();
 
119
  bool eq(const Item *item, bool binary_cmp) const;
 
120
  virtual optimize_type select_optimize() const { return OPTIMIZE_NONE; }
 
121
  virtual bool have_rev_func() const { return 0; }
 
122
  virtual Item *key_item() const { return args[0]; }
 
123
  /*
 
124
    This method is used for debug purposes to print the name of an
 
125
    item to the debug log. The second use of this method is as
 
126
    a helper function of print(), where it is applicable.
 
127
    To suit both goals it should return a meaningful,
 
128
    distinguishable and sintactically correct string.  This method
 
129
    should not be used for runtime type identification, use enum
 
130
    {Sum}Functype and Item_func::functype()/Item_sum::sum_func()
 
131
    instead.
 
132
  */
 
133
  virtual const char *func_name() const= 0;
 
134
  virtual bool const_item() const { return const_item_cache; }
 
135
  inline Item **arguments() const { return args; }
 
136
  void set_arguments(List<Item> &list);
 
137
  inline uint argument_count() const { return arg_count; }
 
138
  inline void remove_arguments() { arg_count=0; }
 
139
  void split_sum_func(THD *thd, Item **ref_pointer_array, List<Item> &fields);
 
140
  virtual void print(String *str, enum_query_type query_type);
 
141
  void print_op(String *str, enum_query_type query_type);
 
142
  void print_args(String *str, uint from, enum_query_type query_type);
 
143
  virtual void fix_num_length_and_dec();
 
144
  void count_only_length();
 
145
  void count_real_length();
 
146
  void count_decimal_length();
 
147
  inline bool get_arg0_date(MYSQL_TIME *ltime, uint fuzzy_date)
 
148
  {
 
149
    return (null_value=args[0]->get_date(ltime, fuzzy_date));
 
150
  }
 
151
  inline bool get_arg0_time(MYSQL_TIME *ltime)
 
152
  {
 
153
    return (null_value=args[0]->get_time(ltime));
 
154
  }
 
155
  bool is_null() { 
 
156
    update_null_value();
 
157
    return null_value; 
 
158
  }
 
159
  void signal_divide_by_null();
 
160
  friend class udf_handler;
 
161
  Field *tmp_table_field() { return result_field; }
 
162
  Field *tmp_table_field(TABLE *t_arg);
 
163
  Item *get_tmp_table_item(THD *thd);
 
164
 
 
165
  my_decimal *val_decimal(my_decimal *);
 
166
 
 
167
  bool agg_arg_collations(DTCollation &c, Item **items, uint nitems,
 
168
                          uint flags)
 
169
  {
 
170
    return agg_item_collations(c, func_name(), items, nitems, flags, 1);
 
171
  }
 
172
  bool agg_arg_collations_for_comparison(DTCollation &c,
 
173
                                         Item **items, uint nitems,
 
174
                                         uint flags)
 
175
  {
 
176
    return agg_item_collations_for_comparison(c, func_name(),
 
177
                                              items, nitems, flags);
 
178
  }
 
179
  bool agg_arg_charsets(DTCollation &c, Item **items, uint nitems,
 
180
                        uint flags, int item_sep)
 
181
  {
 
182
    return agg_item_charsets(c, func_name(), items, nitems, flags, item_sep);
 
183
  }
 
184
  bool walk(Item_processor processor, bool walk_subquery, uchar *arg);
 
185
  Item *transform(Item_transformer transformer, uchar *arg);
 
186
  Item* compile(Item_analyzer analyzer, uchar **arg_p,
 
187
                Item_transformer transformer, uchar *arg_t);
 
188
  void traverse_cond(Cond_traverser traverser,
 
189
                     void * arg, traverse_order order);
 
190
  inline double fix_result(double value)
 
191
  {
 
192
    if (isfinite(value))
 
193
      return value;
 
194
    null_value=1;
 
195
    return 0.0;
 
196
  }
 
197
};
 
198
 
 
199
 
 
200
class Item_real_func :public Item_func
 
201
{
 
202
public:
 
203
  Item_real_func() :Item_func() {}
 
204
  Item_real_func(Item *a) :Item_func(a) {}
 
205
  Item_real_func(Item *a,Item *b) :Item_func(a,b) {}
 
206
  Item_real_func(List<Item> &list) :Item_func(list) {}
 
207
  String *val_str(String*str);
 
208
  my_decimal *val_decimal(my_decimal *decimal_value);
 
209
  longlong val_int()
 
210
    { DBUG_ASSERT(fixed == 1); return (longlong) rint(val_real()); }
 
211
  enum Item_result result_type () const { return REAL_RESULT; }
 
212
  void fix_length_and_dec()
 
213
  { decimals= NOT_FIXED_DEC; max_length= float_length(decimals); }
 
214
};
 
215
 
 
216
 
 
217
class Item_func_numhybrid: public Item_func
 
218
{
 
219
protected:
 
220
  Item_result hybrid_type;
 
221
public:
 
222
  Item_func_numhybrid(Item *a) :Item_func(a), hybrid_type(REAL_RESULT)
 
223
  {}
 
224
  Item_func_numhybrid(Item *a,Item *b)
 
225
    :Item_func(a,b), hybrid_type(REAL_RESULT)
 
226
  {}
 
227
  Item_func_numhybrid(List<Item> &list)
 
228
    :Item_func(list), hybrid_type(REAL_RESULT)
 
229
  {}
 
230
 
 
231
  enum Item_result result_type () const { return hybrid_type; }
 
232
  void fix_length_and_dec();
 
233
  void fix_num_length_and_dec();
 
234
  virtual void find_num_type()= 0; /* To be called from fix_length_and_dec */
 
235
 
 
236
  double val_real();
 
237
  longlong val_int();
 
238
  my_decimal *val_decimal(my_decimal *);
 
239
  String *val_str(String*str);
 
240
 
 
241
  /**
 
242
     @brief Performs the operation that this functions implements when the
 
243
     result type is INT.
 
244
 
 
245
     @return The result of the operation.
 
246
  */
 
247
  virtual longlong int_op()= 0;
 
248
 
 
249
  /**
 
250
     @brief Performs the operation that this functions implements when the
 
251
     result type is REAL.
 
252
 
 
253
     @return The result of the operation.
 
254
  */
 
255
  virtual double real_op()= 0;
 
256
 
 
257
  /**
 
258
     @brief Performs the operation that this functions implements when the
 
259
     result type is DECIMAL.
 
260
 
 
261
     @param A pointer where the DECIMAL value will be allocated.
 
262
     @return 
 
263
       - 0 If the result is NULL
 
264
       - The same pointer it was given, with the area initialized to the
 
265
         result of the operation.
 
266
  */
 
267
  virtual my_decimal *decimal_op(my_decimal *)= 0;
 
268
 
 
269
  /**
 
270
     @brief Performs the operation that this functions implements when the
 
271
     result type is a string type.
 
272
 
 
273
     @return The result of the operation.
 
274
  */
 
275
  virtual String *str_op(String *)= 0;
 
276
  bool is_null() { update_null_value(); return null_value; }
 
277
};
 
278
 
 
279
/* function where type of result detected by first argument */
 
280
class Item_func_num1: public Item_func_numhybrid
 
281
{
 
282
public:
 
283
  Item_func_num1(Item *a) :Item_func_numhybrid(a) {}
 
284
  Item_func_num1(Item *a, Item *b) :Item_func_numhybrid(a, b) {}
 
285
 
 
286
  void fix_num_length_and_dec();
 
287
  void find_num_type();
 
288
  String *str_op(String *str) { DBUG_ASSERT(0); return 0; }
 
289
};
 
290
 
 
291
 
 
292
/* Base class for operations like '+', '-', '*' */
 
293
class Item_num_op :public Item_func_numhybrid
 
294
{
 
295
 public:
 
296
  Item_num_op(Item *a,Item *b) :Item_func_numhybrid(a, b) {}
 
297
  virtual void result_precision()= 0;
 
298
 
 
299
  virtual inline void print(String *str, enum_query_type query_type)
 
300
  {
 
301
    print_op(str, query_type);
 
302
  }
 
303
 
 
304
  void find_num_type();
 
305
  String *str_op(String *str) { DBUG_ASSERT(0); return 0; }
 
306
};
 
307
 
 
308
 
 
309
class Item_int_func :public Item_func
 
310
{
 
311
public:
 
312
  Item_int_func() :Item_func() { max_length= 21; }
 
313
  Item_int_func(Item *a) :Item_func(a) { max_length= 21; }
 
314
  Item_int_func(Item *a,Item *b) :Item_func(a,b) { max_length= 21; }
 
315
  Item_int_func(Item *a,Item *b,Item *c) :Item_func(a,b,c)
 
316
  { max_length= 21; }
 
317
  Item_int_func(List<Item> &list) :Item_func(list) { max_length= 21; }
 
318
  Item_int_func(THD *thd, Item_int_func *item) :Item_func(thd, item) {}
 
319
  double val_real();
 
320
  String *val_str(String*str);
 
321
  enum Item_result result_type () const { return INT_RESULT; }
 
322
  void fix_length_and_dec() {}
 
323
};
 
324
 
 
325
 
 
326
class Item_func_connection_id :public Item_int_func
 
327
{
 
328
  longlong value;
 
329
 
 
330
public:
 
331
  Item_func_connection_id() {}
 
332
  const char *func_name() const { return "connection_id"; }
 
333
  void fix_length_and_dec();
 
334
  bool fix_fields(THD *thd, Item **ref);
 
335
  longlong val_int() { DBUG_ASSERT(fixed == 1); return value; }
 
336
};
 
337
 
 
338
 
 
339
class Item_func_signed :public Item_int_func
 
340
{
 
341
public:
 
342
  Item_func_signed(Item *a) :Item_int_func(a) {}
 
343
  const char *func_name() const { return "cast_as_signed"; }
 
344
  longlong val_int();
 
345
  longlong val_int_from_str(int *error);
 
346
  void fix_length_and_dec()
 
347
  { max_length=args[0]->max_length; unsigned_flag=0; }
 
348
  virtual void print(String *str, enum_query_type query_type);
 
349
  uint decimal_precision() const { return args[0]->decimal_precision(); }
 
350
};
 
351
 
 
352
 
 
353
class Item_func_unsigned :public Item_func_signed
 
354
{
 
355
public:
 
356
  Item_func_unsigned(Item *a) :Item_func_signed(a) {}
 
357
  const char *func_name() const { return "cast_as_unsigned"; }
 
358
  void fix_length_and_dec()
 
359
  { max_length=args[0]->max_length; unsigned_flag=1; }
 
360
  longlong val_int();
 
361
  virtual void print(String *str, enum_query_type query_type);
 
362
};
 
363
 
 
364
 
 
365
class Item_decimal_typecast :public Item_func
 
366
{
 
367
  my_decimal decimal_value;
 
368
public:
 
369
  Item_decimal_typecast(Item *a, int len, int dec) :Item_func(a)
 
370
  {
 
371
    decimals= dec;
 
372
    max_length= my_decimal_precision_to_length(len, dec, unsigned_flag);
 
373
  }
 
374
  String *val_str(String *str);
 
375
  double val_real();
 
376
  longlong val_int();
 
377
  my_decimal *val_decimal(my_decimal*);
 
378
  enum Item_result result_type () const { return DECIMAL_RESULT; }
 
379
  enum_field_types field_type() const { return MYSQL_TYPE_NEWDECIMAL; }
 
380
  void fix_length_and_dec() {};
 
381
  const char *func_name() const { return "decimal_typecast"; }
 
382
  virtual void print(String *str, enum_query_type query_type);
 
383
};
 
384
 
 
385
 
 
386
class Item_func_additive_op :public Item_num_op
 
387
{
 
388
public:
 
389
  Item_func_additive_op(Item *a,Item *b) :Item_num_op(a,b) {}
 
390
  void result_precision();
 
391
};
 
392
 
 
393
 
 
394
class Item_func_plus :public Item_func_additive_op
 
395
{
 
396
public:
 
397
  Item_func_plus(Item *a,Item *b) :Item_func_additive_op(a,b) {}
 
398
  const char *func_name() const { return "+"; }
 
399
  longlong int_op();
 
400
  double real_op();
 
401
  my_decimal *decimal_op(my_decimal *);
 
402
};
 
403
 
 
404
class Item_func_minus :public Item_func_additive_op
 
405
{
 
406
public:
 
407
  Item_func_minus(Item *a,Item *b) :Item_func_additive_op(a,b) {}
 
408
  const char *func_name() const { return "-"; }
 
409
  longlong int_op();
 
410
  double real_op();
 
411
  my_decimal *decimal_op(my_decimal *);
 
412
  void fix_length_and_dec();
 
413
};
 
414
 
 
415
 
 
416
class Item_func_mul :public Item_num_op
 
417
{
 
418
public:
 
419
  Item_func_mul(Item *a,Item *b) :Item_num_op(a,b) {}
 
420
  const char *func_name() const { return "*"; }
 
421
  longlong int_op();
 
422
  double real_op();
 
423
  my_decimal *decimal_op(my_decimal *);
 
424
  void result_precision();
 
425
};
 
426
 
 
427
 
 
428
class Item_func_div :public Item_num_op
 
429
{
 
430
public:
 
431
  uint prec_increment;
 
432
  Item_func_div(Item *a,Item *b) :Item_num_op(a,b) {}
 
433
  longlong int_op() { DBUG_ASSERT(0); return 0; }
 
434
  double real_op();
 
435
  my_decimal *decimal_op(my_decimal *);
 
436
  const char *func_name() const { return "/"; }
 
437
  void fix_length_and_dec();
 
438
  void result_precision();
 
439
};
 
440
 
 
441
 
 
442
class Item_func_int_div :public Item_int_func
 
443
{
 
444
public:
 
445
  Item_func_int_div(Item *a,Item *b) :Item_int_func(a,b)
 
446
  {}
 
447
  longlong val_int();
 
448
  const char *func_name() const { return "DIV"; }
 
449
  void fix_length_and_dec();
 
450
 
 
451
  virtual inline void print(String *str, enum_query_type query_type)
 
452
  {
 
453
    print_op(str, query_type);
 
454
  }
 
455
 
 
456
};
 
457
 
 
458
 
 
459
class Item_func_mod :public Item_num_op
 
460
{
 
461
public:
 
462
  Item_func_mod(Item *a,Item *b) :Item_num_op(a,b) {}
 
463
  longlong int_op();
 
464
  double real_op();
 
465
  my_decimal *decimal_op(my_decimal *);
 
466
  const char *func_name() const { return "%"; }
 
467
  void result_precision();
 
468
  void fix_length_and_dec();
 
469
};
 
470
 
 
471
 
 
472
class Item_func_neg :public Item_func_num1
 
473
{
 
474
public:
 
475
  Item_func_neg(Item *a) :Item_func_num1(a) {}
 
476
  double real_op();
 
477
  longlong int_op();
 
478
  my_decimal *decimal_op(my_decimal *);
 
479
  const char *func_name() const { return "-"; }
 
480
  enum Functype functype() const   { return NEG_FUNC; }
 
481
  void fix_length_and_dec();
 
482
  void fix_num_length_and_dec();
 
483
  uint decimal_precision() const { return args[0]->decimal_precision(); }
 
484
};
 
485
 
 
486
 
 
487
class Item_func_abs :public Item_func_num1
 
488
{
 
489
public:
 
490
  Item_func_abs(Item *a) :Item_func_num1(a) {}
 
491
  double real_op();
 
492
  longlong int_op();
 
493
  my_decimal *decimal_op(my_decimal *);
 
494
  const char *func_name() const { return "abs"; }
 
495
  void fix_length_and_dec();
 
496
};
 
497
 
 
498
// A class to handle logarithmic and trigonometric functions
 
499
 
 
500
class Item_dec_func :public Item_real_func
 
501
{
 
502
 public:
 
503
  Item_dec_func(Item *a) :Item_real_func(a) {}
 
504
  Item_dec_func(Item *a,Item *b) :Item_real_func(a,b) {}
 
505
  void fix_length_and_dec()
 
506
  {
 
507
    decimals=NOT_FIXED_DEC; max_length=float_length(decimals);
 
508
    maybe_null=1;
 
509
  }
 
510
};
 
511
 
 
512
class Item_func_exp :public Item_dec_func
 
513
{
 
514
public:
 
515
  Item_func_exp(Item *a) :Item_dec_func(a) {}
 
516
  double val_real();
 
517
  const char *func_name() const { return "exp"; }
 
518
};
 
519
 
 
520
 
 
521
class Item_func_ln :public Item_dec_func
 
522
{
 
523
public:
 
524
  Item_func_ln(Item *a) :Item_dec_func(a) {}
 
525
  double val_real();
 
526
  const char *func_name() const { return "ln"; }
 
527
};
 
528
 
 
529
 
 
530
class Item_func_log :public Item_dec_func
 
531
{
 
532
public:
 
533
  Item_func_log(Item *a) :Item_dec_func(a) {}
 
534
  Item_func_log(Item *a,Item *b) :Item_dec_func(a,b) {}
 
535
  double val_real();
 
536
  const char *func_name() const { return "log"; }
 
537
};
 
538
 
 
539
 
 
540
class Item_func_log2 :public Item_dec_func
 
541
{
 
542
public:
 
543
  Item_func_log2(Item *a) :Item_dec_func(a) {}
 
544
  double val_real();
 
545
  const char *func_name() const { return "log2"; }
 
546
};
 
547
 
 
548
 
 
549
class Item_func_log10 :public Item_dec_func
 
550
{
 
551
public:
 
552
  Item_func_log10(Item *a) :Item_dec_func(a) {}
 
553
  double val_real();
 
554
  const char *func_name() const { return "log10"; }
 
555
};
 
556
 
 
557
 
 
558
class Item_func_sqrt :public Item_dec_func
 
559
{
 
560
public:
 
561
  Item_func_sqrt(Item *a) :Item_dec_func(a) {}
 
562
  double val_real();
 
563
  const char *func_name() const { return "sqrt"; }
 
564
};
 
565
 
 
566
 
 
567
class Item_func_pow :public Item_dec_func
 
568
{
 
569
public:
 
570
  Item_func_pow(Item *a,Item *b) :Item_dec_func(a,b) {}
 
571
  double val_real();
 
572
  const char *func_name() const { return "pow"; }
 
573
};
 
574
 
 
575
 
 
576
class Item_func_acos :public Item_dec_func
 
577
{
 
578
public:
 
579
  Item_func_acos(Item *a) :Item_dec_func(a) {}
 
580
  double val_real();
 
581
  const char *func_name() const { return "acos"; }
 
582
};
 
583
 
 
584
class Item_func_asin :public Item_dec_func
 
585
{
 
586
public:
 
587
  Item_func_asin(Item *a) :Item_dec_func(a) {}
 
588
  double val_real();
 
589
  const char *func_name() const { return "asin"; }
 
590
};
 
591
 
 
592
class Item_func_atan :public Item_dec_func
 
593
{
 
594
public:
 
595
  Item_func_atan(Item *a) :Item_dec_func(a) {}
 
596
  Item_func_atan(Item *a,Item *b) :Item_dec_func(a,b) {}
 
597
  double val_real();
 
598
  const char *func_name() const { return "atan"; }
 
599
};
 
600
 
 
601
class Item_func_cos :public Item_dec_func
 
602
{
 
603
public:
 
604
  Item_func_cos(Item *a) :Item_dec_func(a) {}
 
605
  double val_real();
 
606
  const char *func_name() const { return "cos"; }
 
607
};
 
608
 
 
609
class Item_func_sin :public Item_dec_func
 
610
{
 
611
public:
 
612
  Item_func_sin(Item *a) :Item_dec_func(a) {}
 
613
  double val_real();
 
614
  const char *func_name() const { return "sin"; }
 
615
};
 
616
 
 
617
class Item_func_tan :public Item_dec_func
 
618
{
 
619
public:
 
620
  Item_func_tan(Item *a) :Item_dec_func(a) {}
 
621
  double val_real();
 
622
  const char *func_name() const { return "tan"; }
 
623
};
 
624
 
 
625
class Item_func_integer :public Item_int_func
 
626
{
 
627
public:
 
628
  inline Item_func_integer(Item *a) :Item_int_func(a) {}
 
629
  void fix_length_and_dec();
 
630
};
 
631
 
 
632
 
 
633
class Item_func_int_val :public Item_func_num1
 
634
{
 
635
public:
 
636
  Item_func_int_val(Item *a) :Item_func_num1(a) {}
 
637
  void fix_num_length_and_dec();
 
638
  void find_num_type();
 
639
};
 
640
 
 
641
 
 
642
class Item_func_ceiling :public Item_func_int_val
 
643
{
 
644
public:
 
645
  Item_func_ceiling(Item *a) :Item_func_int_val(a) {}
 
646
  const char *func_name() const { return "ceiling"; }
 
647
  longlong int_op();
 
648
  double real_op();
 
649
  my_decimal *decimal_op(my_decimal *);
 
650
};
 
651
 
 
652
 
 
653
class Item_func_floor :public Item_func_int_val
 
654
{
 
655
public:
 
656
  Item_func_floor(Item *a) :Item_func_int_val(a) {}
 
657
  const char *func_name() const { return "floor"; }
 
658
  longlong int_op();
 
659
  double real_op();
 
660
  my_decimal *decimal_op(my_decimal *);
 
661
};
 
662
 
 
663
/* This handles round and truncate */
 
664
 
 
665
class Item_func_round :public Item_func_num1
 
666
{
 
667
  bool truncate;
 
668
public:
 
669
  Item_func_round(Item *a, Item *b, bool trunc_arg)
 
670
    :Item_func_num1(a,b), truncate(trunc_arg) {}
 
671
  const char *func_name() const { return truncate ? "truncate" : "round"; }
 
672
  double real_op();
 
673
  longlong int_op();
 
674
  my_decimal *decimal_op(my_decimal *);
 
675
  void fix_length_and_dec();
 
676
};
 
677
 
 
678
 
 
679
class Item_func_rand :public Item_real_func
 
680
{
 
681
  struct rand_struct *rand;
 
682
public:
 
683
  Item_func_rand(Item *a) :Item_real_func(a), rand(0) {}
 
684
  Item_func_rand()        :Item_real_func() {}
 
685
  double val_real();
 
686
  const char *func_name() const { return "rand"; }
 
687
  bool const_item() const { return 0; }
 
688
  void update_used_tables();
 
689
  bool fix_fields(THD *thd, Item **ref);
 
690
private:
 
691
  void seed_random (Item * val);  
 
692
};
 
693
 
 
694
 
 
695
class Item_func_sign :public Item_int_func
 
696
{
 
697
public:
 
698
  Item_func_sign(Item *a) :Item_int_func(a) {}
 
699
  const char *func_name() const { return "sign"; }
 
700
  longlong val_int();
 
701
};
 
702
 
 
703
 
 
704
class Item_func_units :public Item_real_func
 
705
{
 
706
  char *name;
 
707
  double mul,add;
 
708
public:
 
709
  Item_func_units(char *name_arg,Item *a,double mul_arg,double add_arg)
 
710
    :Item_real_func(a),name(name_arg),mul(mul_arg),add(add_arg) {}
 
711
  double val_real();
 
712
  const char *func_name() const { return name; }
 
713
  void fix_length_and_dec()
 
714
  { decimals= NOT_FIXED_DEC; max_length= float_length(decimals); }
 
715
};
 
716
 
 
717
 
 
718
class Item_func_min_max :public Item_func
 
719
{
 
720
  Item_result cmp_type;
 
721
  String tmp_value;
 
722
  int cmp_sign;
 
723
  /* TRUE <=> arguments should be compared in the DATETIME context. */
 
724
  bool compare_as_dates;
 
725
  /* An item used for issuing warnings while string to DATETIME conversion. */
 
726
  Item *datetime_item;
 
727
  THD *thd;
 
728
protected:
 
729
  enum_field_types cached_field_type;
 
730
public:
 
731
  Item_func_min_max(List<Item> &list,int cmp_sign_arg) :Item_func(list),
 
732
    cmp_type(INT_RESULT), cmp_sign(cmp_sign_arg), compare_as_dates(FALSE),
 
733
    datetime_item(0) {}
 
734
  double val_real();
 
735
  longlong val_int();
 
736
  String *val_str(String *);
 
737
  my_decimal *val_decimal(my_decimal *);
 
738
  void fix_length_and_dec();
 
739
  enum Item_result result_type () const { return cmp_type; }
 
740
  bool result_as_longlong() { return compare_as_dates; };
 
741
  uint cmp_datetimes(ulonglong *value);
 
742
  enum_field_types field_type() const { return cached_field_type; }
 
743
};
 
744
 
 
745
class Item_func_min :public Item_func_min_max
 
746
{
 
747
public:
 
748
  Item_func_min(List<Item> &list) :Item_func_min_max(list,1) {}
 
749
  const char *func_name() const { return "least"; }
 
750
};
 
751
 
 
752
class Item_func_max :public Item_func_min_max
 
753
{
 
754
public:
 
755
  Item_func_max(List<Item> &list) :Item_func_min_max(list,-1) {}
 
756
  const char *func_name() const { return "greatest"; }
 
757
};
 
758
 
 
759
 
 
760
/* 
 
761
  Objects of this class are used for ROLLUP queries to wrap up 
 
762
  each constant item referred to in GROUP BY list. 
 
763
*/
 
764
 
 
765
class Item_func_rollup_const :public Item_func
 
766
{
 
767
public:
 
768
  Item_func_rollup_const(Item *a) :Item_func(a)
 
769
  {
 
770
    name= a->name;
 
771
    name_length= a->name_length;
 
772
  }
 
773
  double val_real() { return args[0]->val_real(); }
 
774
  longlong val_int() { return args[0]->val_int(); }
 
775
  String *val_str(String *str) { return args[0]->val_str(str); }
 
776
  my_decimal *val_decimal(my_decimal *dec) { return args[0]->val_decimal(dec); }
 
777
  const char *func_name() const { return "rollup_const"; }
 
778
  bool const_item() const { return 0; }
 
779
  Item_result result_type() const { return args[0]->result_type(); }
 
780
  void fix_length_and_dec()
 
781
  {
 
782
    collation= args[0]->collation;
 
783
    max_length= args[0]->max_length;
 
784
    decimals=args[0]->decimals; 
 
785
    /* The item could be a NULL constant. */
 
786
    null_value= args[0]->is_null();
 
787
  }
 
788
};
 
789
 
 
790
 
 
791
class Item_func_length :public Item_int_func
 
792
{
 
793
  String value;
 
794
public:
 
795
  Item_func_length(Item *a) :Item_int_func(a) {}
 
796
  longlong val_int();
 
797
  const char *func_name() const { return "length"; }
 
798
  void fix_length_and_dec() { max_length=10; }
 
799
};
 
800
 
 
801
class Item_func_bit_length :public Item_func_length
 
802
{
 
803
public:
 
804
  Item_func_bit_length(Item *a) :Item_func_length(a) {}
 
805
  longlong val_int()
 
806
    { DBUG_ASSERT(fixed == 1); return Item_func_length::val_int()*8; }
 
807
  const char *func_name() const { return "bit_length"; }
 
808
};
 
809
 
 
810
class Item_func_char_length :public Item_int_func
 
811
{
 
812
  String value;
 
813
public:
 
814
  Item_func_char_length(Item *a) :Item_int_func(a) {}
 
815
  longlong val_int();
 
816
  const char *func_name() const { return "char_length"; }
 
817
  void fix_length_and_dec() { max_length=10; }
 
818
};
 
819
 
 
820
class Item_func_coercibility :public Item_int_func
 
821
{
 
822
public:
 
823
  Item_func_coercibility(Item *a) :Item_int_func(a) {}
 
824
  longlong val_int();
 
825
  const char *func_name() const { return "coercibility"; }
 
826
  void fix_length_and_dec() { max_length=10; maybe_null= 0; }
 
827
  table_map not_null_tables() const { return 0; }
 
828
};
 
829
 
 
830
class Item_func_locate :public Item_int_func
 
831
{
 
832
  String value1,value2;
 
833
  DTCollation cmp_collation;
 
834
public:
 
835
  Item_func_locate(Item *a,Item *b) :Item_int_func(a,b) {}
 
836
  Item_func_locate(Item *a,Item *b,Item *c) :Item_int_func(a,b,c) {}
 
837
  const char *func_name() const { return "locate"; }
 
838
  longlong val_int();
 
839
  void fix_length_and_dec();
 
840
  virtual void print(String *str, enum_query_type query_type);
 
841
};
 
842
 
 
843
 
 
844
class Item_func_field :public Item_int_func
 
845
{
 
846
  String value,tmp;
 
847
  Item_result cmp_type;
 
848
  DTCollation cmp_collation;
 
849
public:
 
850
  Item_func_field(List<Item> &list) :Item_int_func(list) {}
 
851
  longlong val_int();
 
852
  const char *func_name() const { return "field"; }
 
853
  void fix_length_and_dec();
 
854
};
 
855
 
 
856
 
 
857
class Item_func_ascii :public Item_int_func
 
858
{
 
859
  String value;
 
860
public:
 
861
  Item_func_ascii(Item *a) :Item_int_func(a) {}
 
862
  longlong val_int();
 
863
  const char *func_name() const { return "ascii"; }
 
864
  void fix_length_and_dec() { max_length=3; }
 
865
};
 
866
 
 
867
class Item_func_ord :public Item_int_func
 
868
{
 
869
  String value;
 
870
public:
 
871
  Item_func_ord(Item *a) :Item_int_func(a) {}
 
872
  longlong val_int();
 
873
  const char *func_name() const { return "ord"; }
 
874
};
 
875
 
 
876
class Item_func_find_in_set :public Item_int_func
 
877
{
 
878
  String value,value2;
 
879
  uint enum_value;
 
880
  ulonglong enum_bit;
 
881
  DTCollation cmp_collation;
 
882
public:
 
883
  Item_func_find_in_set(Item *a,Item *b) :Item_int_func(a,b),enum_value(0) {}
 
884
  longlong val_int();
 
885
  const char *func_name() const { return "find_in_set"; }
 
886
  void fix_length_and_dec();
 
887
};
 
888
 
 
889
/* Base class for all bit functions: '~', '|', '^', '&', '>>', '<<' */
 
890
 
 
891
class Item_func_bit: public Item_int_func
 
892
{
 
893
public:
 
894
  Item_func_bit(Item *a, Item *b) :Item_int_func(a, b) {}
 
895
  Item_func_bit(Item *a) :Item_int_func(a) {}
 
896
  void fix_length_and_dec() { unsigned_flag= 1; }
 
897
 
 
898
  virtual inline void print(String *str, enum_query_type query_type)
 
899
  {
 
900
    print_op(str, query_type);
 
901
  }
 
902
};
 
903
 
 
904
class Item_func_bit_or :public Item_func_bit
 
905
{
 
906
public:
 
907
  Item_func_bit_or(Item *a, Item *b) :Item_func_bit(a, b) {}
 
908
  longlong val_int();
 
909
  const char *func_name() const { return "|"; }
 
910
};
 
911
 
 
912
class Item_func_bit_and :public Item_func_bit
 
913
{
 
914
public:
 
915
  Item_func_bit_and(Item *a, Item *b) :Item_func_bit(a, b) {}
 
916
  longlong val_int();
 
917
  const char *func_name() const { return "&"; }
 
918
};
 
919
 
 
920
class Item_func_bit_count :public Item_int_func
 
921
{
 
922
public:
 
923
  Item_func_bit_count(Item *a) :Item_int_func(a) {}
 
924
  longlong val_int();
 
925
  const char *func_name() const { return "bit_count"; }
 
926
  void fix_length_and_dec() { max_length=2; }
 
927
};
 
928
 
 
929
class Item_func_shift_left :public Item_func_bit
 
930
{
 
931
public:
 
932
  Item_func_shift_left(Item *a, Item *b) :Item_func_bit(a, b) {}
 
933
  longlong val_int();
 
934
  const char *func_name() const { return "<<"; }
 
935
};
 
936
 
 
937
class Item_func_shift_right :public Item_func_bit
 
938
{
 
939
public:
 
940
  Item_func_shift_right(Item *a, Item *b) :Item_func_bit(a, b) {}
 
941
  longlong val_int();
 
942
  const char *func_name() const { return ">>"; }
 
943
};
 
944
 
 
945
class Item_func_bit_neg :public Item_func_bit
 
946
{
 
947
public:
 
948
  Item_func_bit_neg(Item *a) :Item_func_bit(a) {}
 
949
  longlong val_int();
 
950
  const char *func_name() const { return "~"; }
 
951
 
 
952
  virtual inline void print(String *str, enum_query_type query_type)
 
953
  {
 
954
    Item_func::print(str, query_type);
 
955
  }
 
956
};
 
957
 
 
958
 
 
959
class Item_func_last_insert_id :public Item_int_func
 
960
{
 
961
public:
 
962
  Item_func_last_insert_id() :Item_int_func() {}
 
963
  Item_func_last_insert_id(Item *a) :Item_int_func(a) {}
 
964
  longlong val_int();
 
965
  const char *func_name() const { return "last_insert_id"; }
 
966
  void fix_length_and_dec()
 
967
  {
 
968
    if (arg_count)
 
969
      max_length= args[0]->max_length;
 
970
  }
 
971
  bool fix_fields(THD *thd, Item **ref);
 
972
};
 
973
 
 
974
 
 
975
class Item_func_benchmark :public Item_int_func
 
976
{
 
977
public:
 
978
  Item_func_benchmark(Item *count_expr, Item *expr)
 
979
    :Item_int_func(count_expr, expr)
 
980
  {}
 
981
  longlong val_int();
 
982
  const char *func_name() const { return "benchmark"; }
 
983
  void fix_length_and_dec() { max_length=1; maybe_null=0; }
 
984
  virtual void print(String *str, enum_query_type query_type);
 
985
};
 
986
 
 
987
 
 
988
#ifdef HAVE_DLOPEN
 
989
 
 
990
class Item_udf_func :public Item_func
 
991
{
 
992
protected:
 
993
  udf_handler udf;
 
994
  bool is_expensive_processor(uchar *arg) { return TRUE; }
 
995
 
 
996
public:
 
997
  Item_udf_func(udf_func *udf_arg)
 
998
    :Item_func(), udf(udf_arg) {}
 
999
  Item_udf_func(udf_func *udf_arg, List<Item> &list)
 
1000
    :Item_func(list), udf(udf_arg) {}
 
1001
  const char *func_name() const { return udf.name(); }
 
1002
  enum Functype functype() const   { return UDF_FUNC; }
 
1003
  bool fix_fields(THD *thd, Item **ref)
 
1004
  {
 
1005
    DBUG_ASSERT(fixed == 0);
 
1006
    bool res= udf.fix_fields(thd, this, arg_count, args);
 
1007
    used_tables_cache= udf.used_tables_cache;
 
1008
    const_item_cache= udf.const_item_cache;
 
1009
    fixed= 1;
 
1010
    return res;
 
1011
  }
 
1012
  void update_used_tables() 
 
1013
  {
 
1014
    /*
 
1015
      TODO: Make a member in UDF_INIT and return if a UDF is deterministic or
 
1016
      not.
 
1017
      Currently UDF_INIT has a member (const_item) that is an in/out 
 
1018
      parameter to the init() call.
 
1019
      The code in udf_handler::fix_fields also duplicates the arguments 
 
1020
      handling code in Item_func::fix_fields().
 
1021
      
 
1022
      The lack of information if a UDF is deterministic makes writing
 
1023
      a correct update_used_tables() for UDFs impossible.
 
1024
      One solution to this would be :
 
1025
       - Add a is_deterministic member of UDF_INIT
 
1026
       - (optionally) deprecate the const_item member of UDF_INIT
 
1027
       - Take away the duplicate code from udf_handler::fix_fields() and
 
1028
         make Item_udf_func call Item_func::fix_fields() to process its 
 
1029
         arguments as for any other function.
 
1030
       - Store the deterministic flag returned by <udf>_init into the 
 
1031
       udf_handler. 
 
1032
       - Don't implement Item_udf_func::fix_fields, implement
 
1033
       Item_udf_func::fix_length_and_dec() instead (similar to non-UDF
 
1034
       functions).
 
1035
       - Override Item_func::update_used_tables to call 
 
1036
       Item_func::update_used_tables() and add a RAND_TABLE_BIT to the 
 
1037
       result of Item_func::update_used_tables() if the UDF is 
 
1038
       non-deterministic.
 
1039
       - (optionally) rename RAND_TABLE_BIT to NONDETERMINISTIC_BIT to
 
1040
       better describe its usage.
 
1041
       
 
1042
      The above would require a change of the UDF API.
 
1043
      Until that change is done here's how the current code works:
 
1044
      We call Item_func::update_used_tables() only when we know that
 
1045
      the function depends on real non-const tables and is deterministic.
 
1046
      This can be done only because we know that the optimizer will
 
1047
      call update_used_tables() only when there's possibly a new const
 
1048
      table. So update_used_tables() can only make a Item_func more
 
1049
      constant than it is currently.
 
1050
      That's why we don't need to do anything if a function is guaranteed
 
1051
      to return non-constant (it's non-deterministic) or is already a
 
1052
      const.
 
1053
    */  
 
1054
    if ((used_tables_cache & ~PSEUDO_TABLE_BITS) && 
 
1055
        !(used_tables_cache & RAND_TABLE_BIT))
 
1056
    {
 
1057
      Item_func::update_used_tables();
 
1058
      if (!const_item_cache && !used_tables_cache)
 
1059
        used_tables_cache= RAND_TABLE_BIT;
 
1060
    }
 
1061
  }
 
1062
  void cleanup();
 
1063
  Item_result result_type () const { return udf.result_type(); }
 
1064
  table_map not_null_tables() const { return 0; }
 
1065
  virtual void print(String *str, enum_query_type query_type);
 
1066
};
 
1067
 
 
1068
 
 
1069
class Item_func_udf_float :public Item_udf_func
 
1070
{
 
1071
 public:
 
1072
  Item_func_udf_float(udf_func *udf_arg)
 
1073
    :Item_udf_func(udf_arg) {}
 
1074
  Item_func_udf_float(udf_func *udf_arg,
 
1075
                      List<Item> &list)
 
1076
    :Item_udf_func(udf_arg, list) {}
 
1077
  longlong val_int()
 
1078
  {
 
1079
    DBUG_ASSERT(fixed == 1);
 
1080
    return (longlong) rint(Item_func_udf_float::val_real());
 
1081
  }
 
1082
  my_decimal *val_decimal(my_decimal *dec_buf)
 
1083
  {
 
1084
    double res=val_real();
 
1085
    if (null_value)
 
1086
      return NULL;
 
1087
    double2my_decimal(E_DEC_FATAL_ERROR, res, dec_buf);
 
1088
    return dec_buf;
 
1089
  }
 
1090
  double val_real();
 
1091
  String *val_str(String *str);
 
1092
  void fix_length_and_dec() { fix_num_length_and_dec(); }
 
1093
};
 
1094
 
 
1095
 
 
1096
class Item_func_udf_int :public Item_udf_func
 
1097
{
 
1098
public:
 
1099
  Item_func_udf_int(udf_func *udf_arg)
 
1100
    :Item_udf_func(udf_arg) {}
 
1101
  Item_func_udf_int(udf_func *udf_arg,
 
1102
                    List<Item> &list)
 
1103
    :Item_udf_func(udf_arg, list) {}
 
1104
  longlong val_int();
 
1105
  double val_real() { return (double) Item_func_udf_int::val_int(); }
 
1106
  String *val_str(String *str);
 
1107
  enum Item_result result_type () const { return INT_RESULT; }
 
1108
  void fix_length_and_dec() { decimals= 0; max_length= 21; }
 
1109
};
 
1110
 
 
1111
 
 
1112
class Item_func_udf_decimal :public Item_udf_func
 
1113
{
 
1114
public:
 
1115
  Item_func_udf_decimal(udf_func *udf_arg)
 
1116
    :Item_udf_func(udf_arg) {}
 
1117
  Item_func_udf_decimal(udf_func *udf_arg, List<Item> &list)
 
1118
    :Item_udf_func(udf_arg, list) {}
 
1119
  longlong val_int();
 
1120
  double val_real();
 
1121
  my_decimal *val_decimal(my_decimal *);
 
1122
  String *val_str(String *str);
 
1123
  enum Item_result result_type () const { return DECIMAL_RESULT; }
 
1124
  void fix_length_and_dec();
 
1125
};
 
1126
 
 
1127
 
 
1128
class Item_func_udf_str :public Item_udf_func
 
1129
{
 
1130
public:
 
1131
  Item_func_udf_str(udf_func *udf_arg)
 
1132
    :Item_udf_func(udf_arg) {}
 
1133
  Item_func_udf_str(udf_func *udf_arg, List<Item> &list)
 
1134
    :Item_udf_func(udf_arg, list) {}
 
1135
  String *val_str(String *);
 
1136
  double val_real()
 
1137
  {
 
1138
    int err_not_used;
 
1139
    char *end_not_used;
 
1140
    String *res;
 
1141
    res= val_str(&str_value);
 
1142
    return res ? my_strntod(res->charset(),(char*) res->ptr(), 
 
1143
                            res->length(), &end_not_used, &err_not_used) : 0.0;
 
1144
  }
 
1145
  longlong val_int()
 
1146
  {
 
1147
    int err_not_used;
 
1148
    String *res;  res=val_str(&str_value);
 
1149
    return res ? my_strntoll(res->charset(),res->ptr(),res->length(),10,
 
1150
                             (char**) 0, &err_not_used) : (longlong) 0;
 
1151
  }
 
1152
  my_decimal *val_decimal(my_decimal *dec_buf)
 
1153
  {
 
1154
    String *res=val_str(&str_value);
 
1155
    if (!res)
 
1156
      return NULL;
 
1157
    string2my_decimal(E_DEC_FATAL_ERROR, res, dec_buf);
 
1158
    return dec_buf;
 
1159
  }
 
1160
  enum Item_result result_type () const { return STRING_RESULT; }
 
1161
  void fix_length_and_dec();
 
1162
};
 
1163
 
 
1164
#else /* Dummy functions to get sql_yacc.cc compiled */
 
1165
 
 
1166
class Item_func_udf_float :public Item_real_func
 
1167
{
 
1168
 public:
 
1169
  Item_func_udf_float(udf_func *udf_arg)
 
1170
    :Item_real_func() {}
 
1171
  Item_func_udf_float(udf_func *udf_arg, List<Item> &list)
 
1172
    :Item_real_func(list) {}
 
1173
  double val_real() { DBUG_ASSERT(fixed == 1); return 0.0; }
 
1174
};
 
1175
 
 
1176
 
 
1177
class Item_func_udf_int :public Item_int_func
 
1178
{
 
1179
public:
 
1180
  Item_func_udf_int(udf_func *udf_arg)
 
1181
    :Item_int_func() {}
 
1182
  Item_func_udf_int(udf_func *udf_arg, List<Item> &list)
 
1183
    :Item_int_func(list) {}
 
1184
  longlong val_int() { DBUG_ASSERT(fixed == 1); return 0; }
 
1185
};
 
1186
 
 
1187
 
 
1188
class Item_func_udf_decimal :public Item_int_func
 
1189
{
 
1190
public:
 
1191
  Item_func_udf_decimal(udf_func *udf_arg)
 
1192
    :Item_int_func() {}
 
1193
  Item_func_udf_decimal(udf_func *udf_arg, List<Item> &list)
 
1194
    :Item_int_func(list) {}
 
1195
  my_decimal *val_decimal(my_decimal *) { DBUG_ASSERT(fixed == 1); return 0; }
 
1196
};
 
1197
 
 
1198
 
 
1199
class Item_func_udf_str :public Item_func
 
1200
{
 
1201
public:
 
1202
  Item_func_udf_str(udf_func *udf_arg)
 
1203
    :Item_func() {}
 
1204
  Item_func_udf_str(udf_func *udf_arg, List<Item> &list)
 
1205
    :Item_func(list) {}
 
1206
  String *val_str(String *)
 
1207
    { DBUG_ASSERT(fixed == 1); null_value=1; return 0; }
 
1208
  double val_real() { DBUG_ASSERT(fixed == 1); null_value= 1; return 0.0; }
 
1209
  longlong val_int() { DBUG_ASSERT(fixed == 1); null_value=1; return 0; }
 
1210
  enum Item_result result_type () const { return STRING_RESULT; }
 
1211
  void fix_length_and_dec() { maybe_null=1; max_length=0; }
 
1212
};
 
1213
 
 
1214
#endif /* HAVE_DLOPEN */
 
1215
 
 
1216
/* replication functions */
 
1217
 
 
1218
class Item_master_pos_wait :public Item_int_func
 
1219
{
 
1220
  String value;
 
1221
public:
 
1222
  Item_master_pos_wait(Item *a,Item *b) :Item_int_func(a,b) {}
 
1223
  Item_master_pos_wait(Item *a,Item *b,Item *c) :Item_int_func(a,b,c) {}
 
1224
  longlong val_int();
 
1225
  const char *func_name() const { return "master_pos_wait"; }
 
1226
  void fix_length_and_dec() { max_length=21; maybe_null=1;}
 
1227
};
 
1228
 
 
1229
 
 
1230
/* Handling of user definable variables */
 
1231
 
 
1232
class user_var_entry;
 
1233
 
 
1234
class Item_func_set_user_var :public Item_func
 
1235
{
 
1236
  enum Item_result cached_result_type;
 
1237
  user_var_entry *entry;
 
1238
  char buffer[MAX_FIELD_WIDTH];
 
1239
  String value;
 
1240
  my_decimal decimal_buff;
 
1241
  bool null_item;
 
1242
  union
 
1243
  {
 
1244
    longlong vint;
 
1245
    double vreal;
 
1246
    String *vstr;
 
1247
    my_decimal *vdec;
 
1248
  } save_result;
 
1249
 
 
1250
public:
 
1251
  LEX_STRING name; // keep it public
 
1252
  Item_func_set_user_var(LEX_STRING a,Item *b)
 
1253
    :Item_func(b), cached_result_type(INT_RESULT), name(a)
 
1254
  {}
 
1255
  enum Functype functype() const { return SUSERVAR_FUNC; }
 
1256
  double val_real();
 
1257
  longlong val_int();
 
1258
  String *val_str(String *str);
 
1259
  my_decimal *val_decimal(my_decimal *);
 
1260
  double val_result();
 
1261
  longlong val_int_result();
 
1262
  String *str_result(String *str);
 
1263
  my_decimal *val_decimal_result(my_decimal *);
 
1264
  bool update_hash(void *ptr, uint length, enum Item_result type,
 
1265
                   CHARSET_INFO *cs, Derivation dv, bool unsigned_arg);
 
1266
  bool send(Protocol *protocol, String *str_arg);
 
1267
  void make_field(Send_field *tmp_field);
 
1268
  bool check(bool use_result_field);
 
1269
  bool update();
 
1270
  enum Item_result result_type () const { return cached_result_type; }
 
1271
  bool fix_fields(THD *thd, Item **ref);
 
1272
  void fix_length_and_dec();
 
1273
  virtual void print(String *str, enum_query_type query_type);
 
1274
  void print_as_stmt(String *str, enum_query_type query_type);
 
1275
  const char *func_name() const { return "set_user_var"; }
 
1276
  int save_in_field(Field *field, bool no_conversions,
 
1277
                    bool can_use_result_field);
 
1278
  int save_in_field(Field *field, bool no_conversions)
 
1279
  {
 
1280
    return save_in_field(field, no_conversions, 1);
 
1281
  }
 
1282
  void save_org_in_field(Field *field) { (void)save_in_field(field, 1, 0); }
 
1283
  bool register_field_in_read_map(uchar *arg);
 
1284
};
 
1285
 
 
1286
 
 
1287
class Item_func_get_user_var :public Item_func
 
1288
{
 
1289
  user_var_entry *var_entry;
 
1290
  Item_result m_cached_result_type;
 
1291
 
 
1292
public:
 
1293
  LEX_STRING name; // keep it public
 
1294
  Item_func_get_user_var(LEX_STRING a):
 
1295
    Item_func(), m_cached_result_type(STRING_RESULT), name(a) {}
 
1296
  enum Functype functype() const { return GUSERVAR_FUNC; }
 
1297
  LEX_STRING get_name() { return name; }
 
1298
  double val_real();
 
1299
  longlong val_int();
 
1300
  my_decimal *val_decimal(my_decimal*);
 
1301
  String *val_str(String* str);
 
1302
  void fix_length_and_dec();
 
1303
  virtual void print(String *str, enum_query_type query_type);
 
1304
  enum Item_result result_type() const;
 
1305
  /*
 
1306
    We must always return variables as strings to guard against selects of type
 
1307
    select @t1:=1,@t1,@t:="hello",@t from foo where (@t1:= t2.b)
 
1308
  */
 
1309
  const char *func_name() const { return "get_user_var"; }
 
1310
  bool const_item() const;
 
1311
  table_map used_tables() const
 
1312
  { return const_item() ? 0 : RAND_TABLE_BIT; }
 
1313
  bool eq(const Item *item, bool binary_cmp) const;
 
1314
};
 
1315
 
 
1316
 
 
1317
/*
 
1318
  This item represents user variable used as out parameter (e.g in LOAD DATA),
 
1319
  and it is supposed to be used only for this purprose. So it is simplified
 
1320
  a lot. Actually you should never obtain its value.
 
1321
 
 
1322
  The only two reasons for this thing being an Item is possibility to store it
 
1323
  in List<Item> and desire to place this code somewhere near other functions
 
1324
  working with user variables.
 
1325
*/
 
1326
class Item_user_var_as_out_param :public Item
 
1327
{
 
1328
  LEX_STRING name;
 
1329
  user_var_entry *entry;
 
1330
public:
 
1331
  Item_user_var_as_out_param(LEX_STRING a) : name(a) {}
 
1332
  /* We should return something different from FIELD_ITEM here */
 
1333
  enum Type type() const { return STRING_ITEM;}
 
1334
  double val_real();
 
1335
  longlong val_int();
 
1336
  String *val_str(String *str);
 
1337
  my_decimal *val_decimal(my_decimal *decimal_buffer);
 
1338
  /* fix_fields() binds variable name with its entry structure */
 
1339
  bool fix_fields(THD *thd, Item **ref);
 
1340
  virtual void print(String *str, enum_query_type query_type);
 
1341
  void set_null_value(CHARSET_INFO* cs);
 
1342
  void set_value(const char *str, uint length, CHARSET_INFO* cs);
 
1343
};
 
1344
 
 
1345
 
 
1346
/* A system variable */
 
1347
 
 
1348
class Item_func_get_system_var :public Item_func
 
1349
{
 
1350
  sys_var *var;
 
1351
  enum_var_type var_type;
 
1352
  LEX_STRING component;
 
1353
public:
 
1354
  Item_func_get_system_var(sys_var *var_arg, enum_var_type var_type_arg,
 
1355
                           LEX_STRING *component_arg, const char *name_arg,
 
1356
                           size_t name_len_arg);
 
1357
  bool fix_fields(THD *thd, Item **ref);
 
1358
  /*
 
1359
    Stubs for pure virtual methods. Should never be called: this
 
1360
    item is always substituted with a constant in fix_fields().
 
1361
  */
 
1362
  double val_real()         { DBUG_ASSERT(0); return 0.0; }
 
1363
  longlong val_int()        { DBUG_ASSERT(0); return 0; }
 
1364
  String* val_str(String*)  { DBUG_ASSERT(0); return 0; }
 
1365
  void fix_length_and_dec() { DBUG_ASSERT(0); }
 
1366
  /* TODO: fix to support views */
 
1367
  const char *func_name() const { return "get_system_var"; }
 
1368
  /**
 
1369
    Indicates whether this system variable is written to the binlog or not.
 
1370
 
 
1371
    Variables are written to the binlog as part of "status_vars" in
 
1372
    Query_log_event, as an Intvar_log_event, or a Rand_log_event.
 
1373
 
 
1374
    @return true if the variable is written to the binlog, false otherwise.
 
1375
  */
 
1376
  bool is_written_to_binlog();
 
1377
};
 
1378
 
 
1379
class Item_func_bit_xor : public Item_func_bit
 
1380
{
 
1381
public:
 
1382
  Item_func_bit_xor(Item *a, Item *b) :Item_func_bit(a, b) {}
 
1383
  longlong val_int();
 
1384
  const char *func_name() const { return "^"; }
 
1385
};
 
1386
 
 
1387
class Item_func_is_free_lock :public Item_int_func
 
1388
{
 
1389
  String value;
 
1390
public:
 
1391
  Item_func_is_free_lock(Item *a) :Item_int_func(a) {}
 
1392
  longlong val_int();
 
1393
  const char *func_name() const { return "is_free_lock"; }
 
1394
  void fix_length_and_dec() { decimals=0; max_length=1; maybe_null=1;}
 
1395
};
 
1396
 
 
1397
class Item_func_is_used_lock :public Item_int_func
 
1398
{
 
1399
  String value;
 
1400
public:
 
1401
  Item_func_is_used_lock(Item *a) :Item_int_func(a) {}
 
1402
  longlong val_int();
 
1403
  const char *func_name() const { return "is_used_lock"; }
 
1404
  void fix_length_and_dec() { decimals=0; max_length=10; maybe_null=1;}
 
1405
};
 
1406
 
 
1407
/* For type casts */
 
1408
 
 
1409
enum Cast_target
 
1410
{
 
1411
  ITEM_CAST_BINARY, ITEM_CAST_SIGNED_INT, ITEM_CAST_UNSIGNED_INT,
 
1412
  ITEM_CAST_DATE, ITEM_CAST_TIME, ITEM_CAST_DATETIME, ITEM_CAST_CHAR,
 
1413
  ITEM_CAST_DECIMAL
 
1414
};
 
1415
 
 
1416
 
 
1417
class Item_func_row_count :public Item_int_func
 
1418
{
 
1419
public:
 
1420
  Item_func_row_count() :Item_int_func() {}
 
1421
  longlong val_int();
 
1422
  const char *func_name() const { return "row_count"; }
 
1423
  void fix_length_and_dec() { decimals= 0; maybe_null=0; }
 
1424
};
 
1425
 
 
1426
 
 
1427
/*
 
1428
 *
 
1429
 * Stored FUNCTIONs
 
1430
 *
 
1431
 */
 
1432
 
 
1433
struct st_sp_security_context;
 
1434
 
 
1435
class Item_func_found_rows :public Item_int_func
 
1436
{
 
1437
public:
 
1438
  Item_func_found_rows() :Item_int_func() {}
 
1439
  longlong val_int();
 
1440
  const char *func_name() const { return "found_rows"; }
 
1441
  void fix_length_and_dec() { decimals= 0; maybe_null=0; }
 
1442
};
 
1443
 
 
1444
 
 
1445
void uuid_short_init();
 
1446
 
 
1447
class Item_func_uuid_short :public Item_int_func
 
1448
{
 
1449
public:
 
1450
  Item_func_uuid_short() :Item_int_func() {}
 
1451
  const char *func_name() const { return "uuid_short"; }
 
1452
  longlong val_int();
 
1453
  void fix_length_and_dec()
 
1454
  { max_length= 21; unsigned_flag=1; }
 
1455
};
 
1456