item_func.h 41.3 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2006 MySQL AB
2

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

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

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


/* Function items used by mysql */

19
#ifdef USE_PRAGMA_INTERFACE
unknown's avatar
unknown committed
20 21 22 23 24 25 26 27 28 29 30 31 32
#pragma interface			/* gcc class implementation */
#endif

#ifdef HAVE_IEEEFP_H
extern "C"				/* Bug in BSDI include file */
{
#include <ieeefp.h>
}
#endif

class Item_func :public Item_result_field
{
protected:
33
  Item **args, *tmp_arg[2];
34 35 36 37
  /*
    Allowed numbers of columns in result (usually 1, which means scalar value)
    0 means get this number from first argument
  */
unknown's avatar
unknown committed
38
  uint allowed_arg_cols;
unknown's avatar
unknown committed
39 40
public:
  uint arg_count;
41
  table_map used_tables_cache, not_null_tables_cache;
unknown's avatar
unknown committed
42 43 44
  bool const_item_cache;
  enum Functype { UNKNOWN_FUNC,EQ_FUNC,EQUAL_FUNC,NE_FUNC,LT_FUNC,LE_FUNC,
		  GE_FUNC,GT_FUNC,FT_FUNC,
45
		  LIKE_FUNC,ISNULL_FUNC,ISNOTNULL_FUNC,
46 47
		  COND_AND_FUNC, COND_OR_FUNC, COND_XOR_FUNC,
                  BETWEEN, IN_FUNC, MULT_EQUAL_FUNC,
48
		  INTERVAL_FUNC, ISNOTNULLTEST_FUNC,
unknown's avatar
unknown committed
49 50 51 52
		  SP_EQUALS_FUNC, SP_DISJOINT_FUNC,SP_INTERSECTS_FUNC,
		  SP_TOUCHES_FUNC,SP_CROSSES_FUNC,SP_WITHIN_FUNC,
		  SP_CONTAINS_FUNC,SP_OVERLAPS_FUNC,
		  SP_STARTPOINT,SP_ENDPOINT,SP_EXTERIORRING,
53
		  SP_POINTN,SP_GEOMETRYN,SP_INTERIORRINGN,
unknown's avatar
unknown committed
54 55
                  NOT_FUNC, NOT_ALL_FUNC,
                  NOW_FUNC, TRIG_COND_FUNC,
56
                  SUSERVAR_FUNC, GUSERVAR_FUNC, COLLATE_FUNC,
57
                  EXTRACT_FUNC, CHAR_TYPECAST_FUNC, FUNC_SP, UDF_FUNC };
58 59
  enum optimize_type { OPTIMIZE_NONE,OPTIMIZE_KEY,OPTIMIZE_OP, OPTIMIZE_NULL,
                       OPTIMIZE_EQUAL };
unknown's avatar
unknown committed
60 61
  enum Type type() const { return FUNC_ITEM; }
  virtual enum Functype functype() const   { return UNKNOWN_FUNC; }
unknown's avatar
unknown committed
62 63
  Item_func(void):
    allowed_arg_cols(1), arg_count(0)
unknown's avatar
unknown committed
64
  {
65
    with_sum_func= 0;
unknown's avatar
unknown committed
66
  }
unknown's avatar
unknown committed
67 68
  Item_func(Item *a):
    allowed_arg_cols(1), arg_count(1)
unknown's avatar
unknown committed
69
  {
70
    args= tmp_arg;
71 72
    args[0]= a;
    with_sum_func= a->with_sum_func;
unknown's avatar
unknown committed
73
  }
unknown's avatar
unknown committed
74 75
  Item_func(Item *a,Item *b):
    allowed_arg_cols(1), arg_count(2)
unknown's avatar
unknown committed
76
  {
77
    args= tmp_arg;
78 79
    args[0]= a; args[1]= b;
    with_sum_func= a->with_sum_func || b->with_sum_func;
unknown's avatar
unknown committed
80
  }
unknown's avatar
unknown committed
81 82
  Item_func(Item *a,Item *b,Item *c):
    allowed_arg_cols(1)
unknown's avatar
unknown committed
83
  {
84 85
    arg_count= 0;
    if ((args= (Item**) sql_alloc(sizeof(Item*)*3)))
unknown's avatar
unknown committed
86
    {
87 88 89
      arg_count= 3;
      args[0]= a; args[1]= b; args[2]= c;
      with_sum_func= a->with_sum_func || b->with_sum_func || c->with_sum_func;
unknown's avatar
unknown committed
90 91
    }
  }
unknown's avatar
unknown committed
92 93
  Item_func(Item *a,Item *b,Item *c,Item *d):
    allowed_arg_cols(1)
unknown's avatar
unknown committed
94
  {
95 96
    arg_count= 0;
    if ((args= (Item**) sql_alloc(sizeof(Item*)*4)))
unknown's avatar
unknown committed
97
    {
98 99 100 101
      arg_count= 4;
      args[0]= a; args[1]= b; args[2]= c; args[3]= d;
      with_sum_func= a->with_sum_func || b->with_sum_func ||
	c->with_sum_func || d->with_sum_func;
unknown's avatar
unknown committed
102 103
    }
  }
unknown's avatar
unknown committed
104 105
  Item_func(Item *a,Item *b,Item *c,Item *d,Item* e):
    allowed_arg_cols(1)
unknown's avatar
unknown committed
106
  {
107 108
    arg_count= 5;
    if ((args= (Item**) sql_alloc(sizeof(Item*)*5)))
unknown's avatar
unknown committed
109
    {
110 111 112
      args[0]= a; args[1]= b; args[2]= c; args[3]= d; args[4]= e;
      with_sum_func= a->with_sum_func || b->with_sum_func ||
	c->with_sum_func || d->with_sum_func || e->with_sum_func ;
unknown's avatar
unknown committed
113 114 115
    }
  }
  Item_func(List<Item> &list);
116
  // Constructor used for Item_cond_and/or (see Item comment)
117
  Item_func(THD *thd, Item_func *item);
118
  bool fix_fields(THD *, Item **ref);
unknown's avatar
unknown committed
119
  table_map used_tables() const;
120
  table_map not_null_tables() const;
unknown's avatar
unknown committed
121
  void update_used_tables();
122
  bool eq(const Item *item, bool binary_cmp) const;
unknown's avatar
unknown committed
123 124 125
  virtual optimize_type select_optimize() const { return OPTIMIZE_NONE; }
  virtual bool have_rev_func() const { return 0; }
  virtual Item *key_item() const { return args[0]; }
126 127 128 129 130 131 132 133 134 135 136
  /*
    This method is used for debug purposes to print the name of an
    item to the debug log. The second use of this method is as
    a helper function of print(), where it is applicable.
    To suit both goals it should return a meaningful,
    distinguishable and sintactically correct string.  This method
    should not be used for runtime type identification, use enum
    {Sum}Functype and Item_func::functype()/Item_sum::sum_func()
    instead.
  */
  virtual const char *func_name() const= 0;
unknown's avatar
unknown committed
137 138
  virtual bool const_item() const { return const_item_cache; }
  inline Item **arguments() const { return args; }
139
  void set_arguments(List<Item> &list);
unknown's avatar
unknown committed
140 141
  inline uint argument_count() const { return arg_count; }
  inline void remove_arguments() { arg_count=0; }
142
  void split_sum_func(THD *thd, Item **ref_pointer_array, List<Item> &fields);
unknown's avatar
unknown committed
143 144
  void print(String *str);
  void print_op(String *str);
unknown's avatar
unknown committed
145
  void print_args(String *str, uint from);
unknown's avatar
unknown committed
146 147 148 149
  virtual void fix_num_length_and_dec();
  void count_only_length();
  void count_real_length();
  void count_decimal_length();
150
  inline bool get_arg0_date(MYSQL_TIME *ltime, uint fuzzy_date)
unknown's avatar
unknown committed
151
  {
152
    return (null_value=args[0]->get_date(ltime, fuzzy_date));
unknown's avatar
unknown committed
153
  }
154
  inline bool get_arg0_time(MYSQL_TIME *ltime)
unknown's avatar
unknown committed
155 156 157
  {
    return (null_value=args[0]->get_time(ltime));
  }
158
  bool is_null() { 
159
    update_null_value();
160 161
    return null_value; 
  }
unknown's avatar
unknown committed
162
  void signal_divide_by_null();
unknown's avatar
unknown committed
163
  friend class udf_handler;
164
  Field *tmp_table_field() { return result_field; }
165
  Field *tmp_table_field(TABLE *t_arg);
166
  Item *get_tmp_table_item(THD *thd);
unknown's avatar
unknown committed
167 168 169

  my_decimal *val_decimal(my_decimal *);

170
  bool agg_arg_collations(DTCollation &c, Item **items, uint nitems,
171
                          uint flags)
172
  {
173
    return agg_item_collations(c, func_name(), items, nitems, flags, 1);
174
  }
175 176
  bool agg_arg_collations_for_comparison(DTCollation &c,
                                         Item **items, uint nitems,
177
                                         uint flags)
178 179 180 181
  {
    return agg_item_collations_for_comparison(c, func_name(),
                                              items, nitems, flags);
  }
unknown's avatar
unknown committed
182
  bool agg_arg_charsets(DTCollation &c, Item **items, uint nitems,
183
                        uint flags, int item_sep)
184
  {
185
    return agg_item_charsets(c, func_name(), items, nitems, flags, item_sep);
186
  }
unknown's avatar
unknown committed
187
  bool walk(Item_processor processor, byte *arg);
unknown's avatar
unknown committed
188
  Item *transform(Item_transformer transformer, byte *arg);
189 190
  Item* compile(Item_analyzer analyzer, byte **arg_p,
                Item_transformer transformer, byte *arg_t);
191 192
  void traverse_cond(Cond_traverser traverser,
                     void * arg, traverse_order order);
193 194
  bool is_expensive_processor(byte *arg);
  virtual bool is_expensive() { return 0; }
unknown's avatar
unknown committed
195 196 197 198 199 200 201 202 203 204 205
};


class Item_real_func :public Item_func
{
public:
  Item_real_func() :Item_func() {}
  Item_real_func(Item *a) :Item_func(a) {}
  Item_real_func(Item *a,Item *b) :Item_func(a,b) {}
  Item_real_func(List<Item> &list) :Item_func(list) {}
  String *val_str(String*str);
206
  my_decimal *val_decimal(my_decimal *decimal_value);
207
  longlong val_int()
208
    { DBUG_ASSERT(fixed == 1); return (longlong) rint(val_real()); }
unknown's avatar
unknown committed
209
  enum Item_result result_type () const { return REAL_RESULT; }
unknown's avatar
unknown committed
210 211
  void fix_length_and_dec()
  { decimals= NOT_FIXED_DEC; max_length= float_length(decimals); }
unknown's avatar
unknown committed
212 213
};

214

unknown's avatar
unknown committed
215
class Item_func_numhybrid: public Item_func
unknown's avatar
unknown committed
216
{
unknown's avatar
unknown committed
217
protected:
unknown's avatar
unknown committed
218 219
  Item_result hybrid_type;
public:
unknown's avatar
unknown committed
220
  Item_func_numhybrid(Item *a) :Item_func(a), hybrid_type(REAL_RESULT)
unknown's avatar
unknown committed
221 222
  {}
  Item_func_numhybrid(Item *a,Item *b)
unknown's avatar
unknown committed
223
    :Item_func(a,b), hybrid_type(REAL_RESULT)
unknown's avatar
unknown committed
224
  {}
unknown's avatar
unknown committed
225
  Item_func_numhybrid(List<Item> &list)
unknown's avatar
unknown committed
226
    :Item_func(list), hybrid_type(REAL_RESULT)
unknown's avatar
unknown committed
227
  {}
unknown's avatar
unknown committed
228

unknown's avatar
unknown committed
229
  enum Item_result result_type () const { return hybrid_type; }
unknown's avatar
unknown committed
230 231 232 233 234 235 236 237 238 239 240 241
  void fix_length_and_dec();
  void fix_num_length_and_dec();
  virtual void find_num_type()= 0; /* To be called from fix_length_and_dec */

  double val_real();
  longlong val_int();
  my_decimal *val_decimal(my_decimal *);
  String *val_str(String*str);

  virtual longlong int_op()= 0;
  virtual double real_op()= 0;
  virtual my_decimal *decimal_op(my_decimal *)= 0;
unknown's avatar
unknown committed
242
  virtual String *str_op(String *)= 0;
243
  bool is_null() { update_null_value(); return null_value; }
unknown's avatar
unknown committed
244 245
};

unknown's avatar
unknown committed
246 247 248 249 250 251
/* function where type of result detected by first argument */
class Item_func_num1: public Item_func_numhybrid
{
public:
  Item_func_num1(Item *a) :Item_func_numhybrid(a) {}
  Item_func_num1(Item *a, Item *b) :Item_func_numhybrid(a, b) {}
unknown's avatar
unknown committed
252

unknown's avatar
unknown committed
253 254
  void fix_num_length_and_dec();
  void find_num_type();
unknown's avatar
unknown committed
255
  String *str_op(String *str) { DBUG_ASSERT(0); return 0; }
unknown's avatar
unknown committed
256
};
unknown's avatar
unknown committed
257

unknown's avatar
unknown committed
258 259 260

/* Base class for operations like '+', '-', '*' */
class Item_num_op :public Item_func_numhybrid
unknown's avatar
unknown committed
261 262
{
 public:
unknown's avatar
unknown committed
263 264
  Item_num_op(Item *a,Item *b) :Item_func_numhybrid(a, b) {}
  virtual void result_precision()= 0;
unknown's avatar
unknown committed
265
  void print(String *str) { print_op(str); }
unknown's avatar
unknown committed
266
  void find_num_type();
unknown's avatar
unknown committed
267
  String *str_op(String *str) { DBUG_ASSERT(0); return 0; }
unknown's avatar
unknown committed
268 269 270 271 272 273
};


class Item_int_func :public Item_func
{
public:
unknown's avatar
unknown committed
274 275 276 277 278 279
  Item_int_func() :Item_func() { max_length= 21; }
  Item_int_func(Item *a) :Item_func(a) { max_length= 21; }
  Item_int_func(Item *a,Item *b) :Item_func(a,b) { max_length= 21; }
  Item_int_func(Item *a,Item *b,Item *c) :Item_func(a,b,c)
  { max_length= 21; }
  Item_int_func(List<Item> &list) :Item_func(list) { max_length= 21; }
280
  Item_int_func(THD *thd, Item_int_func *item) :Item_func(thd, item) {}
281
  double val_real();
unknown's avatar
unknown committed
282 283
  String *val_str(String*str);
  enum Item_result result_type () const { return INT_RESULT; }
unknown's avatar
unknown committed
284
  void fix_length_and_dec() {}
unknown's avatar
unknown committed
285 286
};

287

288 289 290 291 292
class Item_func_connection_id :public Item_int_func
{
  longlong value;

public:
293
  Item_func_connection_id() {}
294 295 296 297 298 299 300
  const char *func_name() const { return "connection_id"; }
  void fix_length_and_dec();
  bool fix_fields(THD *thd, Item **ref);
  longlong val_int() { DBUG_ASSERT(fixed == 1); return value; }
};


301 302 303 304
class Item_func_signed :public Item_int_func
{
public:
  Item_func_signed(Item *a) :Item_int_func(a) {}
305
  const char *func_name() const { return "cast_as_signed"; }
306 307
  longlong val_int();
  longlong val_int_from_str(int *error);
308
  void fix_length_and_dec()
unknown's avatar
unknown committed
309
  { max_length=args[0]->max_length; unsigned_flag=0; }
310
  void print(String *str);
unknown's avatar
unknown committed
311 312
  uint decimal_precision() const { return args[0]->decimal_precision(); }

313 314
};

315

unknown's avatar
unknown committed
316
class Item_func_unsigned :public Item_func_signed
317 318
{
public:
unknown's avatar
unknown committed
319
  Item_func_unsigned(Item *a) :Item_func_signed(a) {}
320
  const char *func_name() const { return "cast_as_unsigned"; }
321
  void fix_length_and_dec()
unknown's avatar
unknown committed
322
  { max_length=args[0]->max_length; unsigned_flag=1; }
323
  longlong val_int();
324
  void print(String *str);
325 326 327
};


unknown's avatar
unknown committed
328
class Item_decimal_typecast :public Item_func
unknown's avatar
unknown committed
329
{
unknown's avatar
unknown committed
330
  my_decimal decimal_value;
unknown's avatar
unknown committed
331
public:
unknown's avatar
unknown committed
332 333 334
  Item_decimal_typecast(Item *a, int len, int dec) :Item_func(a)
  {
    decimals= dec;
335
    max_length= my_decimal_precision_to_length(len, dec, unsigned_flag);
unknown's avatar
unknown committed
336 337
  }
  String *val_str(String *str);
338
  double val_real();
unknown's avatar
unknown committed
339
  longlong val_int();
unknown's avatar
unknown committed
340 341
  my_decimal *val_decimal(my_decimal*);
  enum Item_result result_type () const { return DECIMAL_RESULT; }
unknown's avatar
unknown committed
342
  enum_field_types field_type() const { return MYSQL_TYPE_NEWDECIMAL; }
unknown's avatar
unknown committed
343
  void fix_length_and_dec() {};
344 345
  const char *func_name() const { return "decimal_typecast"; }
  void print(String *);
unknown's avatar
unknown committed
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
};


class Item_func_additive_op :public Item_num_op
{
public:
  Item_func_additive_op(Item *a,Item *b) :Item_num_op(a,b) {}
  void result_precision();
};


class Item_func_plus :public Item_func_additive_op
{
public:
  Item_func_plus(Item *a,Item *b) :Item_func_additive_op(a,b) {}
  const char *func_name() const { return "+"; }
  longlong int_op();
  double real_op();
  my_decimal *decimal_op(my_decimal *);
unknown's avatar
unknown committed
365 366
};

unknown's avatar
unknown committed
367
class Item_func_minus :public Item_func_additive_op
unknown's avatar
unknown committed
368 369
{
public:
unknown's avatar
unknown committed
370
  Item_func_minus(Item *a,Item *b) :Item_func_additive_op(a,b) {}
unknown's avatar
unknown committed
371
  const char *func_name() const { return "-"; }
unknown's avatar
unknown committed
372 373 374
  longlong int_op();
  double real_op();
  my_decimal *decimal_op(my_decimal *);
375
  void fix_length_and_dec();
unknown's avatar
unknown committed
376 377
};

378

unknown's avatar
unknown committed
379 380 381 382 383
class Item_func_mul :public Item_num_op
{
public:
  Item_func_mul(Item *a,Item *b) :Item_num_op(a,b) {}
  const char *func_name() const { return "*"; }
unknown's avatar
unknown committed
384 385 386 387
  longlong int_op();
  double real_op();
  my_decimal *decimal_op(my_decimal *);
  void result_precision();
unknown's avatar
unknown committed
388 389 390 391 392 393
};


class Item_func_div :public Item_num_op
{
public:
unknown's avatar
unknown committed
394
  uint prec_increment;
unknown's avatar
unknown committed
395
  Item_func_div(Item *a,Item *b) :Item_num_op(a,b) {}
396
  longlong int_op() { DBUG_ASSERT(0); return 0; }
unknown's avatar
unknown committed
397 398
  double real_op();
  my_decimal *decimal_op(my_decimal *);
unknown's avatar
unknown committed
399 400
  const char *func_name() const { return "/"; }
  void fix_length_and_dec();
unknown's avatar
unknown committed
401
  void result_precision();
unknown's avatar
unknown committed
402 403 404
};


405
class Item_func_int_div :public Item_int_func
406 407
{
public:
408
  Item_func_int_div(Item *a,Item *b) :Item_int_func(a,b)
unknown's avatar
unknown committed
409
  {}
410 411 412
  longlong val_int();
  const char *func_name() const { return "DIV"; }
  void fix_length_and_dec();
unknown's avatar
unknown committed
413
  void print(String *str) { print_op(str); }
414 415 416
};


unknown's avatar
unknown committed
417 418 419 420
class Item_func_mod :public Item_num_op
{
public:
  Item_func_mod(Item *a,Item *b) :Item_num_op(a,b) {}
unknown's avatar
unknown committed
421 422 423
  longlong int_op();
  double real_op();
  my_decimal *decimal_op(my_decimal *);
unknown's avatar
unknown committed
424
  const char *func_name() const { return "%"; }
unknown's avatar
unknown committed
425
  void result_precision();
unknown's avatar
unknown committed
426
  void fix_length_and_dec();
unknown's avatar
unknown committed
427 428 429
};


430
class Item_func_neg :public Item_func_num1
unknown's avatar
unknown committed
431 432
{
public:
433
  Item_func_neg(Item *a) :Item_func_num1(a) {}
unknown's avatar
unknown committed
434 435 436
  double real_op();
  longlong int_op();
  my_decimal *decimal_op(my_decimal *);
unknown's avatar
unknown committed
437
  const char *func_name() const { return "-"; }
438
  void fix_length_and_dec();
unknown's avatar
unknown committed
439
  void fix_num_length_and_dec();
unknown's avatar
unknown committed
440
  uint decimal_precision() const { return args[0]->decimal_precision(); }
unknown's avatar
unknown committed
441 442 443
};


unknown's avatar
unknown committed
444
class Item_func_abs :public Item_func_num1
unknown's avatar
unknown committed
445 446
{
public:
unknown's avatar
unknown committed
447 448 449 450
  Item_func_abs(Item *a) :Item_func_num1(a) {}
  double real_op();
  longlong int_op();
  my_decimal *decimal_op(my_decimal *);
unknown's avatar
unknown committed
451 452 453 454
  const char *func_name() const { return "abs"; }
  void fix_length_and_dec();
};

unknown's avatar
unknown committed
455
// A class to handle logarithmic and trigonometric functions
unknown's avatar
unknown committed
456 457 458 459 460 461 462 463

class Item_dec_func :public Item_real_func
{
 public:
  Item_dec_func(Item *a) :Item_real_func(a) {}
  Item_dec_func(Item *a,Item *b) :Item_real_func(a,b) {}
  void fix_length_and_dec()
  {
464
    decimals=NOT_FIXED_DEC; max_length=float_length(decimals);
unknown's avatar
unknown committed
465 466 467 468 469 470 471
    maybe_null=1;
  }
  inline double fix_result(double value)
  {
#ifndef HAVE_FINITE
    return value;
#else
472
    /* The following should be safe, even if we compare doubles */
unknown's avatar
unknown committed
473 474 475 476 477 478 479 480 481 482 483 484
    if (finite(value) && value != POSTFIX_ERROR)
      return value;
    null_value=1;
    return 0.0;
#endif
  }
};

class Item_func_exp :public Item_dec_func
{
public:
  Item_func_exp(Item *a) :Item_dec_func(a) {}
485
  double val_real();
unknown's avatar
unknown committed
486 487 488
  const char *func_name() const { return "exp"; }
};

489 490 491 492 493

class Item_func_ln :public Item_dec_func
{
public:
  Item_func_ln(Item *a) :Item_dec_func(a) {}
494
  double val_real();
495 496 497 498
  const char *func_name() const { return "ln"; }
};


unknown's avatar
unknown committed
499 500 501 502
class Item_func_log :public Item_dec_func
{
public:
  Item_func_log(Item *a) :Item_dec_func(a) {}
503
  Item_func_log(Item *a,Item *b) :Item_dec_func(a,b) {}
504
  double val_real();
unknown's avatar
unknown committed
505 506 507 508
  const char *func_name() const { return "log"; }
};


509 510 511 512
class Item_func_log2 :public Item_dec_func
{
public:
  Item_func_log2(Item *a) :Item_dec_func(a) {}
513
  double val_real();
514 515 516 517
  const char *func_name() const { return "log2"; }
};


unknown's avatar
unknown committed
518 519 520 521
class Item_func_log10 :public Item_dec_func
{
public:
  Item_func_log10(Item *a) :Item_dec_func(a) {}
522
  double val_real();
unknown's avatar
unknown committed
523 524 525 526 527 528 529 530
  const char *func_name() const { return "log10"; }
};


class Item_func_sqrt :public Item_dec_func
{
public:
  Item_func_sqrt(Item *a) :Item_dec_func(a) {}
531
  double val_real();
unknown's avatar
unknown committed
532 533 534 535 536 537 538 539
  const char *func_name() const { return "sqrt"; }
};


class Item_func_pow :public Item_dec_func
{
public:
  Item_func_pow(Item *a,Item *b) :Item_dec_func(a,b) {}
540
  double val_real();
unknown's avatar
unknown committed
541 542 543 544 545 546
  const char *func_name() const { return "pow"; }
};


class Item_func_acos :public Item_dec_func
{
547
public:
unknown's avatar
unknown committed
548
  Item_func_acos(Item *a) :Item_dec_func(a) {}
549
  double val_real();
unknown's avatar
unknown committed
550 551 552 553 554
  const char *func_name() const { return "acos"; }
};

class Item_func_asin :public Item_dec_func
{
555
public:
unknown's avatar
unknown committed
556
  Item_func_asin(Item *a) :Item_dec_func(a) {}
557
  double val_real();
unknown's avatar
unknown committed
558 559 560 561 562
  const char *func_name() const { return "asin"; }
};

class Item_func_atan :public Item_dec_func
{
563
public:
unknown's avatar
unknown committed
564 565
  Item_func_atan(Item *a) :Item_dec_func(a) {}
  Item_func_atan(Item *a,Item *b) :Item_dec_func(a,b) {}
566
  double val_real();
unknown's avatar
unknown committed
567 568 569 570 571
  const char *func_name() const { return "atan"; }
};

class Item_func_cos :public Item_dec_func
{
572
public:
unknown's avatar
unknown committed
573
  Item_func_cos(Item *a) :Item_dec_func(a) {}
574
  double val_real();
unknown's avatar
unknown committed
575 576 577 578 579
  const char *func_name() const { return "cos"; }
};

class Item_func_sin :public Item_dec_func
{
580
public:
unknown's avatar
unknown committed
581
  Item_func_sin(Item *a) :Item_dec_func(a) {}
582
  double val_real();
unknown's avatar
unknown committed
583 584 585 586 587
  const char *func_name() const { return "sin"; }
};

class Item_func_tan :public Item_dec_func
{
588
public:
unknown's avatar
unknown committed
589
  Item_func_tan(Item *a) :Item_dec_func(a) {}
590
  double val_real();
unknown's avatar
unknown committed
591 592 593 594 595 596 597 598 599 600 601
  const char *func_name() const { return "tan"; }
};

class Item_func_integer :public Item_int_func
{
public:
  inline Item_func_integer(Item *a) :Item_int_func(a) {}
  void fix_length_and_dec();
};


unknown's avatar
unknown committed
602 603 604 605 606 607 608 609 610 611
class Item_func_int_val :public Item_func_num1
{
public:
  Item_func_int_val(Item *a) :Item_func_num1(a) {}
  void fix_num_length_and_dec();
  void find_num_type();
};


class Item_func_ceiling :public Item_func_int_val
unknown's avatar
unknown committed
612 613
{
public:
unknown's avatar
unknown committed
614
  Item_func_ceiling(Item *a) :Item_func_int_val(a) {}
unknown's avatar
unknown committed
615
  const char *func_name() const { return "ceiling"; }
unknown's avatar
unknown committed
616 617 618
  longlong int_op();
  double real_op();
  my_decimal *decimal_op(my_decimal *);
unknown's avatar
unknown committed
619 620
};

unknown's avatar
unknown committed
621 622

class Item_func_floor :public Item_func_int_val
unknown's avatar
unknown committed
623 624
{
public:
unknown's avatar
unknown committed
625
  Item_func_floor(Item *a) :Item_func_int_val(a) {}
unknown's avatar
unknown committed
626
  const char *func_name() const { return "floor"; }
unknown's avatar
unknown committed
627 628 629
  longlong int_op();
  double real_op();
  my_decimal *decimal_op(my_decimal *);
unknown's avatar
unknown committed
630 631 632 633
};

/* This handles round and truncate */

unknown's avatar
unknown committed
634
class Item_func_round :public Item_func_num1
unknown's avatar
unknown committed
635 636 637
{
  bool truncate;
public:
unknown's avatar
unknown committed
638 639
  Item_func_round(Item *a, Item *b, bool trunc_arg)
    :Item_func_num1(a,b), truncate(trunc_arg) {}
unknown's avatar
unknown committed
640
  const char *func_name() const { return truncate ? "truncate" : "round"; }
unknown's avatar
unknown committed
641 642 643
  double real_op();
  longlong int_op();
  my_decimal *decimal_op(my_decimal *);
unknown's avatar
unknown committed
644
  void fix_length_and_dec();
unknown's avatar
unknown committed
645 646 647 648 649
};


class Item_func_rand :public Item_real_func
{
650
  struct rand_struct *rand;
unknown's avatar
unknown committed
651
public:
652 653
  Item_func_rand(Item *a) :Item_real_func(a), rand(0) {}
  Item_func_rand()	  :Item_real_func() {}
654
  double val_real();
unknown's avatar
unknown committed
655 656
  const char *func_name() const { return "rand"; }
  bool const_item() const { return 0; }
unknown's avatar
unknown committed
657
  void update_used_tables();
658
  bool fix_fields(THD *thd, Item **ref);
unknown's avatar
unknown committed
659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
};


class Item_func_sign :public Item_int_func
{
public:
  Item_func_sign(Item *a) :Item_int_func(a) {}
  const char *func_name() const { return "sign"; }
  longlong val_int();
};


class Item_func_units :public Item_real_func
{
  char *name;
  double mul,add;
675
public:
unknown's avatar
unknown committed
676 677
  Item_func_units(char *name_arg,Item *a,double mul_arg,double add_arg)
    :Item_real_func(a),name(name_arg),mul(mul_arg),add(add_arg) {}
678
  double val_real();
unknown's avatar
unknown committed
679
  const char *func_name() const { return name; }
unknown's avatar
unknown committed
680 681
  void fix_length_and_dec()
  { decimals= NOT_FIXED_DEC; max_length= float_length(decimals); }
unknown's avatar
unknown committed
682 683 684 685 686 687 688 689
};


class Item_func_min_max :public Item_func
{
  Item_result cmp_type;
  String tmp_value;
  int cmp_sign;
690 691 692 693 694 695
  /* TRUE <=> arguments should be compared in the DATETIME context. */
  bool compare_as_dates;
  /* An item used for issuing warnings while string to DATETIME conversion. */
  Item *datetime_item;
  THD *thd;

unknown's avatar
unknown committed
696 697
public:
  Item_func_min_max(List<Item> &list,int cmp_sign_arg) :Item_func(list),
698 699
    cmp_type(INT_RESULT), cmp_sign(cmp_sign_arg), compare_as_dates(FALSE),
    datetime_item(0) {}
700
  double val_real();
unknown's avatar
unknown committed
701 702
  longlong val_int();
  String *val_str(String *);
unknown's avatar
unknown committed
703
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
704 705
  void fix_length_and_dec();
  enum Item_result result_type () const { return cmp_type; }
706
  bool result_as_longlong() { return compare_as_dates; };
707
  uint cmp_datetimes(ulonglong *value);
unknown's avatar
unknown committed
708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723
};

class Item_func_min :public Item_func_min_max
{
public:
  Item_func_min(List<Item> &list) :Item_func_min_max(list,1) {}
  const char *func_name() const { return "least"; }
};

class Item_func_max :public Item_func_min_max
{
public:
  Item_func_max(List<Item> &list) :Item_func_min_max(list,-1) {}
  const char *func_name() const { return "greatest"; }
};

unknown's avatar
unknown committed
724

725 726 727 728 729 730 731 732 733
/* 
  Objects of this class are used for ROLLUP queries to wrap up 
  each constant item referred to in GROUP BY list. 
*/

class Item_func_rollup_const :public Item_func
{
public:
  Item_func_rollup_const(Item *a) :Item_func(a)
unknown's avatar
unknown committed
734 735 736 737 738
  {
    name= a->name;
    name_length= a->name_length;
  }
  double val_real() { return args[0]->val_real(); }
739 740
  longlong val_int() { return args[0]->val_int(); }
  String *val_str(String *str) { return args[0]->val_str(str); }
unknown's avatar
unknown committed
741
  my_decimal *val_decimal(my_decimal *dec) { return args[0]->val_decimal(dec); }
742 743 744 745 746 747 748 749 750 751 752 753
  const char *func_name() const { return "rollup_const"; }
  bool const_item() const { return 0; }
  Item_result result_type() const { return args[0]->result_type(); }
  void fix_length_and_dec()
  {
    collation= args[0]->collation;
    max_length= args[0]->max_length;
    decimals=args[0]->decimals; 
  }
};


unknown's avatar
unknown committed
754 755 756 757 758 759 760 761 762 763
class Item_func_length :public Item_int_func
{
  String value;
public:
  Item_func_length(Item *a) :Item_int_func(a) {}
  longlong val_int();
  const char *func_name() const { return "length"; }
  void fix_length_and_dec() { max_length=10; }
};

unknown's avatar
unknown committed
764 765 766 767
class Item_func_bit_length :public Item_func_length
{
public:
  Item_func_bit_length(Item *a) :Item_func_length(a) {}
768 769
  longlong val_int()
    { DBUG_ASSERT(fixed == 1); return Item_func_length::val_int()*8; }
unknown's avatar
unknown committed
770 771 772
  const char *func_name() const { return "bit_length"; }
};

unknown's avatar
unknown committed
773 774 775 776 777 778 779 780 781 782
class Item_func_char_length :public Item_int_func
{
  String value;
public:
  Item_func_char_length(Item *a) :Item_int_func(a) {}
  longlong val_int();
  const char *func_name() const { return "char_length"; }
  void fix_length_and_dec() { max_length=10; }
};

unknown's avatar
unknown committed
783 784 785 786 787 788
class Item_func_coercibility :public Item_int_func
{
public:
  Item_func_coercibility(Item *a) :Item_int_func(a) {}
  longlong val_int();
  const char *func_name() const { return "coercibility"; }
789 790
  void fix_length_and_dec() { max_length=10; maybe_null= 0; }
  table_map not_null_tables() const { return 0; }
unknown's avatar
unknown committed
791 792
};

unknown's avatar
unknown committed
793 794 795
class Item_func_locate :public Item_int_func
{
  String value1,value2;
796
  DTCollation cmp_collation;
unknown's avatar
unknown committed
797 798 799 800 801
public:
  Item_func_locate(Item *a,Item *b) :Item_int_func(a,b) {}
  Item_func_locate(Item *a,Item *b,Item *c) :Item_int_func(a,b,c) {}
  const char *func_name() const { return "locate"; }
  longlong val_int();
802
  void fix_length_and_dec();
803
  void print(String *str);
unknown's avatar
unknown committed
804 805 806 807 808 809
};


class Item_func_field :public Item_int_func
{
  String value,tmp;
810 811
  Item_result cmp_type;
  DTCollation cmp_collation;
unknown's avatar
unknown committed
812
public:
813
  Item_func_field(List<Item> &list) :Item_int_func(list) {}
unknown's avatar
unknown committed
814 815
  longlong val_int();
  const char *func_name() const { return "field"; }
816
  void fix_length_and_dec();
unknown's avatar
unknown committed
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
};


class Item_func_ascii :public Item_int_func
{
  String value;
public:
  Item_func_ascii(Item *a) :Item_int_func(a) {}
  longlong val_int();
  const char *func_name() const { return "ascii"; }
  void fix_length_and_dec() { max_length=3; }
};

class Item_func_ord :public Item_int_func
{
  String value;
public:
  Item_func_ord(Item *a) :Item_int_func(a) {}
  longlong val_int();
  const char *func_name() const { return "ord"; }
};

class Item_func_find_in_set :public Item_int_func
{
  String value,value2;
  uint enum_value;
  ulonglong enum_bit;
844
  DTCollation cmp_collation;
unknown's avatar
unknown committed
845 846 847 848 849 850 851
public:
  Item_func_find_in_set(Item *a,Item *b) :Item_int_func(a,b),enum_value(0) {}
  longlong val_int();
  const char *func_name() const { return "find_in_set"; }
  void fix_length_and_dec();
};

852
/* Base class for all bit functions: '~', '|', '^', '&', '>>', '<<' */
unknown's avatar
unknown committed
853

854
class Item_func_bit: public Item_int_func
unknown's avatar
unknown committed
855 856
{
public:
857 858 859
  Item_func_bit(Item *a, Item *b) :Item_int_func(a, b) {}
  Item_func_bit(Item *a) :Item_int_func(a) {}
  void fix_length_and_dec() { unsigned_flag= 1; }
unknown's avatar
unknown committed
860
  void print(String *str) { print_op(str); }
861 862 863 864 865 866
};

class Item_func_bit_or :public Item_func_bit
{
public:
  Item_func_bit_or(Item *a, Item *b) :Item_func_bit(a, b) {}
unknown's avatar
unknown committed
867 868 869 870
  longlong val_int();
  const char *func_name() const { return "|"; }
};

871
class Item_func_bit_and :public Item_func_bit
unknown's avatar
unknown committed
872 873
{
public:
874
  Item_func_bit_and(Item *a, Item *b) :Item_func_bit(a, b) {}
unknown's avatar
unknown committed
875 876 877 878 879 880 881 882 883 884
  longlong val_int();
  const char *func_name() const { return "&"; }
};

class Item_func_bit_count :public Item_int_func
{
public:
  Item_func_bit_count(Item *a) :Item_int_func(a) {}
  longlong val_int();
  const char *func_name() const { return "bit_count"; }
unknown's avatar
unknown committed
885
  void fix_length_and_dec() { max_length=2; }
unknown's avatar
unknown committed
886 887
};

888
class Item_func_shift_left :public Item_func_bit
unknown's avatar
unknown committed
889 890
{
public:
891
  Item_func_shift_left(Item *a, Item *b) :Item_func_bit(a, b) {}
unknown's avatar
unknown committed
892 893 894 895
  longlong val_int();
  const char *func_name() const { return "<<"; }
};

896
class Item_func_shift_right :public Item_func_bit
unknown's avatar
unknown committed
897 898
{
public:
899
  Item_func_shift_right(Item *a, Item *b) :Item_func_bit(a, b) {}
unknown's avatar
unknown committed
900 901 902 903
  longlong val_int();
  const char *func_name() const { return ">>"; }
};

904
class Item_func_bit_neg :public Item_func_bit
unknown's avatar
unknown committed
905 906
{
public:
907
  Item_func_bit_neg(Item *a) :Item_func_bit(a) {}
unknown's avatar
unknown committed
908 909
  longlong val_int();
  const char *func_name() const { return "~"; }
unknown's avatar
unknown committed
910
  void print(String *str) { Item_func::print(str); }
unknown's avatar
unknown committed
911 912
};

unknown's avatar
unknown committed
913

914
class Item_func_last_insert_id :public Item_int_func
unknown's avatar
unknown committed
915 916
{
public:
917 918
  Item_func_last_insert_id() :Item_int_func() {}
  Item_func_last_insert_id(Item *a) :Item_int_func(a) {}
unknown's avatar
unknown committed
919 920
  longlong val_int();
  const char *func_name() const { return "last_insert_id"; }
unknown's avatar
unknown committed
921 922 923 924 925
  void fix_length_and_dec()
  {
    if (arg_count)
      max_length= args[0]->max_length;
  }
926
  bool fix_fields(THD *thd, Item **ref);
unknown's avatar
unknown committed
927 928
};

929

unknown's avatar
unknown committed
930 931 932
class Item_func_benchmark :public Item_int_func
{
  ulong loop_count;
933
public:
unknown's avatar
unknown committed
934 935 936 937 938
  Item_func_benchmark(ulong loop_count_arg,Item *expr)
    :Item_int_func(expr), loop_count(loop_count_arg)
  {}
  longlong val_int();
  const char *func_name() const { return "benchmark"; }
unknown's avatar
unknown committed
939
  void fix_length_and_dec() { max_length=1; maybe_null=0; }
940
  void print(String *str);
unknown's avatar
unknown committed
941 942 943
};


944 945 946 947
class Item_func_sleep :public Item_int_func
{
public:
  Item_func_sleep(Item *a) :Item_int_func(a) {}
948
  bool const_item() const { return 0; }
949
  const char *func_name() const { return "sleep"; }
950 951 952 953 954
  void update_used_tables()
  {
    Item_int_func::update_used_tables();
    used_tables_cache|= RAND_TABLE_BIT;
  }
955 956 957 958 959
  longlong val_int();
};



unknown's avatar
unknown committed
960 961 962 963
#ifdef HAVE_DLOPEN

class Item_udf_func :public Item_func
{
964
protected:
unknown's avatar
unknown committed
965 966 967
  udf_handler udf;

public:
968 969
  Item_udf_func(udf_func *udf_arg)
    :Item_func(), udf(udf_arg) {}
unknown's avatar
unknown committed
970 971 972
  Item_udf_func(udf_func *udf_arg, List<Item> &list)
    :Item_func(list), udf(udf_arg) {}
  const char *func_name() const { return udf.name(); }
973
  enum Functype functype() const   { return UDF_FUNC; }
974
  bool fix_fields(THD *thd, Item **ref)
unknown's avatar
unknown committed
975
  {
976
    DBUG_ASSERT(fixed == 0);
977
    bool res= udf.fix_fields(thd, this, arg_count, args);
unknown's avatar
unknown committed
978 979
    used_tables_cache= udf.used_tables_cache;
    const_item_cache= udf.const_item_cache;
980
    fixed= 1;
unknown's avatar
unknown committed
981 982
    return res;
  }
983
  void cleanup();
unknown's avatar
unknown committed
984
  Item_result result_type () const { return udf.result_type(); }
985
  table_map not_null_tables() const { return 0; }
986
  bool is_expensive() { return 1; }
987
  void print(String *str);
unknown's avatar
unknown committed
988 989 990 991 992 993
};


class Item_func_udf_float :public Item_udf_func
{
 public:
994 995 996 997 998
  Item_func_udf_float(udf_func *udf_arg)
    :Item_udf_func(udf_arg) {}
  Item_func_udf_float(udf_func *udf_arg,
                      List<Item> &list)
    :Item_udf_func(udf_arg, list) {}
999
  longlong val_int()
1000 1001
  {
    DBUG_ASSERT(fixed == 1);
1002
    return (longlong) rint(Item_func_udf_float::val_real());
1003
  }
unknown's avatar
unknown committed
1004 1005 1006 1007 1008 1009 1010 1011
  my_decimal *val_decimal(my_decimal *dec_buf)
  {
    double res=val_real();
    if (null_value)
      return NULL;
    double2my_decimal(E_DEC_FATAL_ERROR, res, dec_buf);
    return dec_buf;
  }
1012
  double val_real();
unknown's avatar
unknown committed
1013 1014 1015 1016 1017 1018 1019 1020
  String *val_str(String *str);
  void fix_length_and_dec() { fix_num_length_and_dec(); }
};


class Item_func_udf_int :public Item_udf_func
{
public:
1021 1022 1023 1024 1025
  Item_func_udf_int(udf_func *udf_arg)
    :Item_udf_func(udf_arg) {}
  Item_func_udf_int(udf_func *udf_arg,
                    List<Item> &list)
    :Item_udf_func(udf_arg, list) {}
unknown's avatar
unknown committed
1026
  longlong val_int();
1027
  double val_real() { return (double) Item_func_udf_int::val_int(); }
unknown's avatar
unknown committed
1028 1029
  String *val_str(String *str);
  enum Item_result result_type () const { return INT_RESULT; }
unknown's avatar
unknown committed
1030 1031 1032 1033 1034 1035 1036
  void fix_length_and_dec() { decimals= 0; max_length= 21; }
};


class Item_func_udf_decimal :public Item_udf_func
{
public:
1037 1038
  Item_func_udf_decimal(udf_func *udf_arg)
    :Item_udf_func(udf_arg) {}
unknown's avatar
unknown committed
1039
  Item_func_udf_decimal(udf_func *udf_arg, List<Item> &list)
1040
    :Item_udf_func(udf_arg, list) {}
unknown's avatar
unknown committed
1041 1042 1043 1044 1045 1046
  longlong val_int();
  double val_real();
  my_decimal *val_decimal(my_decimal *);
  String *val_str(String *str);
  enum Item_result result_type () const { return DECIMAL_RESULT; }
  void fix_length_and_dec();
unknown's avatar
unknown committed
1047 1048 1049 1050 1051 1052
};


class Item_func_udf_str :public Item_udf_func
{
public:
1053 1054
  Item_func_udf_str(udf_func *udf_arg)
    :Item_udf_func(udf_arg) {}
unknown's avatar
unknown committed
1055
  Item_func_udf_str(udf_func *udf_arg, List<Item> &list)
1056
    :Item_udf_func(udf_arg, list) {}
unknown's avatar
unknown committed
1057
  String *val_str(String *);
1058
  double val_real()
unknown's avatar
unknown committed
1059
  {
unknown's avatar
unknown committed
1060 1061 1062 1063 1064 1065
    int err_not_used;
    char *end_not_used;
    String *res;
    res= val_str(&str_value);
    return res ? my_strntod(res->charset(),(char*) res->ptr(), 
                            res->length(), &end_not_used, &err_not_used) : 0.0;
unknown's avatar
unknown committed
1066 1067 1068
  }
  longlong val_int()
  {
unknown's avatar
unknown committed
1069
    int err_not_used;
unknown's avatar
unknown committed
1070
    String *res;  res=val_str(&str_value);
unknown's avatar
unknown committed
1071 1072
    return res ? my_strntoll(res->charset(),res->ptr(),res->length(),10,
                             (char**) 0, &err_not_used) : (longlong) 0;
unknown's avatar
unknown committed
1073
  }
unknown's avatar
unknown committed
1074 1075 1076 1077 1078 1079 1080 1081
  my_decimal *val_decimal(my_decimal *dec_buf)
  {
    String *res=val_str(&str_value);
    if (!res)
      return NULL;
    string2my_decimal(E_DEC_FATAL_ERROR, res, dec_buf);
    return dec_buf;
  }
unknown's avatar
unknown committed
1082 1083 1084 1085 1086 1087 1088 1089 1090
  enum Item_result result_type () const { return STRING_RESULT; }
  void fix_length_and_dec();
};

#else /* Dummy functions to get sql_yacc.cc compiled */

class Item_func_udf_float :public Item_real_func
{
 public:
1091 1092 1093 1094
  Item_func_udf_float(udf_func *udf_arg)
    :Item_real_func() {}
  Item_func_udf_float(udf_func *udf_arg, List<Item> &list)
    :Item_real_func(list) {}
1095
  double val_real() { DBUG_ASSERT(fixed == 1); return 0.0; }
unknown's avatar
unknown committed
1096 1097 1098 1099 1100 1101
};


class Item_func_udf_int :public Item_int_func
{
public:
1102 1103 1104 1105
  Item_func_udf_int(udf_func *udf_arg)
    :Item_int_func() {}
  Item_func_udf_int(udf_func *udf_arg, List<Item> &list)
    :Item_int_func(list) {}
1106
  longlong val_int() { DBUG_ASSERT(fixed == 1); return 0; }
unknown's avatar
unknown committed
1107 1108 1109
};


unknown's avatar
unknown committed
1110 1111 1112
class Item_func_udf_decimal :public Item_int_func
{
public:
1113 1114 1115 1116
  Item_func_udf_decimal(udf_func *udf_arg)
    :Item_int_func() {}
  Item_func_udf_decimal(udf_func *udf_arg, List<Item> &list)
    :Item_int_func(list) {}
unknown's avatar
unknown committed
1117 1118 1119 1120
  my_decimal *val_decimal(my_decimal *) { DBUG_ASSERT(fixed == 1); return 0; }
};


unknown's avatar
unknown committed
1121 1122 1123
class Item_func_udf_str :public Item_func
{
public:
1124 1125 1126 1127
  Item_func_udf_str(udf_func *udf_arg)
    :Item_func() {}
  Item_func_udf_str(udf_func *udf_arg, List<Item> &list)
    :Item_func(list) {}
1128 1129
  String *val_str(String *)
    { DBUG_ASSERT(fixed == 1); null_value=1; return 0; }
1130
  double val_real() { DBUG_ASSERT(fixed == 1); null_value= 1; return 0.0; }
1131
  longlong val_int() { DBUG_ASSERT(fixed == 1); null_value=1; return 0; }
unknown's avatar
unknown committed
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
  enum Item_result result_type () const { return STRING_RESULT; }
  void fix_length_and_dec() { maybe_null=1; max_length=0; }
};

#endif /* HAVE_DLOPEN */

/*
** User level locks
*/

1142
class User_level_lock;
unknown's avatar
unknown committed
1143
void item_user_lock_init(void);
1144
void item_user_lock_release(User_level_lock *ull);
unknown's avatar
unknown committed
1145 1146 1147 1148 1149 1150 1151 1152 1153
void item_user_lock_free(void);

class Item_func_get_lock :public Item_int_func
{
  String value;
 public:
  Item_func_get_lock(Item *a,Item *b) :Item_int_func(a,b) {}
  longlong val_int();
  const char *func_name() const { return "get_lock"; }
unknown's avatar
unknown committed
1154
  void fix_length_and_dec() { max_length=1; maybe_null=1;}
unknown's avatar
unknown committed
1155 1156 1157 1158 1159
};

class Item_func_release_lock :public Item_int_func
{
  String value;
1160
public:
unknown's avatar
unknown committed
1161 1162 1163
  Item_func_release_lock(Item *a) :Item_int_func(a) {}
  longlong val_int();
  const char *func_name() const { return "release_lock"; }
unknown's avatar
unknown committed
1164
  void fix_length_and_dec() { max_length=1; maybe_null=1;}
unknown's avatar
unknown committed
1165 1166
};

unknown's avatar
unknown committed
1167 1168 1169 1170 1171
/* replication functions */

class Item_master_pos_wait :public Item_int_func
{
  String value;
1172
public:
unknown's avatar
unknown committed
1173
  Item_master_pos_wait(Item *a,Item *b) :Item_int_func(a,b) {}
1174
  Item_master_pos_wait(Item *a,Item *b,Item *c) :Item_int_func(a,b,c) {}
unknown's avatar
unknown committed
1175 1176
  longlong val_int();
  const char *func_name() const { return "master_pos_wait"; }
1177
  void fix_length_and_dec() { max_length=21; maybe_null=1;}
unknown's avatar
unknown committed
1178 1179
};

unknown's avatar
unknown committed
1180

unknown's avatar
unknown committed
1181
/* Handling of user definable variables */
unknown's avatar
unknown committed
1182 1183 1184 1185 1186 1187 1188

class user_var_entry;

class Item_func_set_user_var :public Item_func
{
  enum Item_result cached_result_type;
  user_var_entry *entry;
1189 1190
  char buffer[MAX_FIELD_WIDTH];
  String value;
unknown's avatar
unknown committed
1191
  my_decimal decimal_buff;
1192
  bool null_item;
1193 1194 1195 1196 1197
  union
  {
    longlong vint;
    double vreal;
    String *vstr;
unknown's avatar
unknown committed
1198
    my_decimal *vdec;
1199
  } save_result;
unknown's avatar
unknown committed
1200 1201

public:
1202
  LEX_STRING name; // keep it public
1203 1204 1205
  Item_func_set_user_var(LEX_STRING a,Item *b)
    :Item_func(b), cached_result_type(INT_RESULT), name(a)
  {}
1206
  enum Functype functype() const { return SUSERVAR_FUNC; }
1207
  double val_real();
unknown's avatar
unknown committed
1208 1209
  longlong val_int();
  String *val_str(String *str);
unknown's avatar
unknown committed
1210
  my_decimal *val_decimal(my_decimal *);
1211 1212 1213 1214
  double val_real_result();
  longlong val_int_result();
  String *val_str_result(String *str);
  my_decimal *val_decimal_result(my_decimal *);
1215
  bool update_hash(void *ptr, uint length, enum Item_result type,
unknown's avatar
unknown committed
1216
  		   CHARSET_INFO *cs, Derivation dv, bool unsigned_arg);
1217
  bool send(Protocol *protocol, String *str_arg);
unknown's avatar
unknown committed
1218
  void make_field(Send_field *tmp_field);
1219
  bool check(bool use_result_field);
unknown's avatar
unknown committed
1220 1221
  bool update();
  enum Item_result result_type () const { return cached_result_type; }
1222
  bool fix_fields(THD *thd, Item **ref);
unknown's avatar
unknown committed
1223
  void fix_length_and_dec();
unknown's avatar
unknown committed
1224
  void print(String *str);
1225
  void print_as_stmt(String *str);
unknown's avatar
unknown committed
1226
  const char *func_name() const { return "set_user_var"; }
1227 1228 1229 1230 1231 1232 1233
  int save_in_field(Field *field, bool no_conversions,
                    bool can_use_result_field);
  int save_in_field(Field *field, bool no_conversions)
  {
    return save_in_field(field, no_conversions, 1);
  }
  void save_org_in_field(Field *field) { (void)save_in_field(field, 1, 0); }
unknown's avatar
unknown committed
1234 1235 1236
};


1237 1238
class Item_func_get_user_var :public Item_func,
                              private Settable_routine_parameter
unknown's avatar
unknown committed
1239
{
1240
  user_var_entry *var_entry;
unknown's avatar
unknown committed
1241 1242

public:
1243
  LEX_STRING name; // keep it public
1244
  Item_func_get_user_var(LEX_STRING a):
1245
    Item_func(), name(a) {}
1246 1247
  enum Functype functype() const { return GUSERVAR_FUNC; }
  LEX_STRING get_name() { return name; }
1248
  double val_real();
unknown's avatar
unknown committed
1249
  longlong val_int();
unknown's avatar
unknown committed
1250
  my_decimal *val_decimal(my_decimal*);
unknown's avatar
unknown committed
1251 1252
  String *val_str(String* str);
  void fix_length_and_dec();
unknown's avatar
unknown committed
1253
  void print(String *str);
unknown's avatar
unknown committed
1254
  enum Item_result result_type() const;
1255 1256 1257 1258
  /*
    We must always return variables as strings to guard against selects of type
    select @t1:=1,@t1,@t:="hello",@t from foo where (@t1:= t2.b)
  */
1259
  enum_field_types field_type() const  { return MYSQL_TYPE_VARCHAR; }
unknown's avatar
unknown committed
1260
  const char *func_name() const { return "get_user_var"; }
1261
  bool const_item() const;
1262
  table_map used_tables() const
1263
  { return const_item() ? 0 : RAND_TABLE_BIT; }
1264
  bool eq(const Item *item, bool binary_cmp) const;
1265 1266

private:
1267
  bool set_value(THD *thd, sp_rcontext *ctx, Item **it);
1268 1269 1270 1271 1272 1273

public:
  Settable_routine_parameter *get_settable_routine_parameter()
  {
    return this;
  }
1274
};
unknown's avatar
unknown committed
1275

unknown's avatar
unknown committed
1276

unknown's avatar
unknown committed
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
/*
  This item represents user variable used as out parameter (e.g in LOAD DATA),
  and it is supposed to be used only for this purprose. So it is simplified
  a lot. Actually you should never obtain its value.

  The only two reasons for this thing being an Item is possibility to store it
  in List<Item> and desire to place this code somewhere near other functions
  working with user variables.
*/
class Item_user_var_as_out_param :public Item
{
  LEX_STRING name;
  user_var_entry *entry;
public:
  Item_user_var_as_out_param(LEX_STRING a) : name(a) {}
  /* We should return something different from FIELD_ITEM here */
  enum Type type() const { return STRING_ITEM;}
  double val_real();
  longlong val_int();
  String *val_str(String *str);
  my_decimal *val_decimal(my_decimal *decimal_buffer);
  /* fix_fields() binds variable name with its entry structure */
1299
  bool fix_fields(THD *thd, Item **ref);
unknown's avatar
unknown committed
1300 1301 1302 1303 1304 1305
  void print(String *str);
  void set_null_value(CHARSET_INFO* cs);
  void set_value(const char *str, uint length, CHARSET_INFO* cs);
};


1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
/* A system variable */

class Item_func_get_system_var :public Item_func
{
  sys_var *var;
  enum_var_type var_type;
  LEX_STRING component;
public:
  Item_func_get_system_var(sys_var *var_arg, enum_var_type var_type_arg,
                           LEX_STRING *component_arg, const char *name_arg,
                           size_t name_len_arg);
unknown's avatar
unknown committed
1317
  bool fix_fields(THD *thd, Item **ref);
1318 1319 1320 1321
  /*
    Stubs for pure virtual methods. Should never be called: this
    item is always substituted with a constant in fix_fields().
  */
unknown's avatar
unknown committed
1322
  double val_real()         { DBUG_ASSERT(0); return 0.0; }
1323 1324 1325
  longlong val_int()        { DBUG_ASSERT(0); return 0; }
  String* val_str(String*)  { DBUG_ASSERT(0); return 0; }
  void fix_length_and_dec() { DBUG_ASSERT(0); }
unknown's avatar
unknown committed
1326 1327
  /* TODO: fix to support views */
  const char *func_name() const { return "get_system_var"; }
1328 1329 1330
};


unknown's avatar
unknown committed
1331 1332 1333 1334 1335 1336
class Item_func_inet_aton : public Item_int_func
{
public:
   Item_func_inet_aton(Item *a) :Item_int_func(a) {}
   longlong val_int();
   const char *func_name() const { return "inet_aton"; }
1337
   void fix_length_and_dec() { decimals = 0; max_length = 21; maybe_null=1;unsigned_flag=1;}
unknown's avatar
unknown committed
1338 1339 1340
};


1341
/* for fulltext search */
1342
#include <ft_global.h>
unknown's avatar
unknown committed
1343 1344 1345 1346

class Item_func_match :public Item_real_func
{
public:
1347
  uint key, flags;
unknown's avatar
unknown committed
1348
  bool join_key;
1349 1350 1351 1352
  DTCollation cmp_collation;
  FT_INFO *ft_handler;
  TABLE *table;
  Item_func_match *master;   // for master-slave optimization
1353 1354
  Item *concat_ws;           // Item_func_concat_ws
  String value;              // value of concat_ws
1355
  String search_value;       // key_item()'s value converted to cmp_collation
unknown's avatar
unknown committed
1356

unknown's avatar
unknown committed
1357
  Item_func_match(List<Item> &a, uint b): Item_real_func(a), key(0), flags(b),
1358
       join_key(0), ft_handler(0), table(0), master(0), concat_ws(0) { }
unknown's avatar
unknown committed
1359
  void cleanup()
1360
  {
unknown's avatar
unknown committed
1361
    DBUG_ENTER("Item_func_match");
1362
    Item_real_func::cleanup();
1363
    if (!master && ft_handler)
unknown's avatar
unknown committed
1364
      ft_handler->please->close_search(ft_handler);
1365
    ft_handler= 0;
1366
    concat_ws= 0;
unknown's avatar
unknown committed
1367
    DBUG_VOID_RETURN;
1368
  }
unknown's avatar
unknown committed
1369
  enum Functype functype() const { return FT_FUNC; }
1370
  const char *func_name() const { return "match"; }
unknown's avatar
unknown committed
1371
  void update_used_tables() {}
1372
  table_map not_null_tables() const { return 0; }
1373
  bool fix_fields(THD *thd, Item **ref);
1374
  bool eq(const Item *, bool binary_cmp) const;
1375
  /* The following should be safe, even if we compare doubles */
1376 1377
  longlong val_int() { DBUG_ASSERT(fixed == 1); return val_real() != 0.0; }
  double val_real();
1378
  void print(String *str);
1379 1380

  bool fix_index();
1381
  void init_search(bool no_order);
1382
};
unknown's avatar
unknown committed
1383

unknown's avatar
unknown committed
1384

1385
class Item_func_bit_xor : public Item_func_bit
unknown's avatar
unknown committed
1386 1387
{
public:
1388
  Item_func_bit_xor(Item *a, Item *b) :Item_func_bit(a, b) {}
unknown's avatar
unknown committed
1389 1390 1391 1392
  longlong val_int();
  const char *func_name() const { return "^"; }
};

1393
class Item_func_is_free_lock :public Item_int_func
unknown's avatar
unknown committed
1394 1395 1396
{
  String value;
public:
1397
  Item_func_is_free_lock(Item *a) :Item_int_func(a) {}
unknown's avatar
unknown committed
1398
  longlong val_int();
1399
  const char *func_name() const { return "is_free_lock"; }
unknown's avatar
unknown committed
1400
  void fix_length_and_dec() { decimals=0; max_length=1; maybe_null=1;}
unknown's avatar
unknown committed
1401 1402
};

unknown's avatar
SCRUM  
unknown committed
1403 1404 1405 1406 1407 1408 1409 1410 1411 1412
class Item_func_is_used_lock :public Item_int_func
{
  String value;
public:
  Item_func_is_used_lock(Item *a) :Item_int_func(a) {}
  longlong val_int();
  const char *func_name() const { return "is_used_lock"; }
  void fix_length_and_dec() { decimals=0; max_length=10; maybe_null=1;}
};

unknown's avatar
unknown committed
1413 1414
/* For type casts */

1415
enum Cast_target
unknown's avatar
unknown committed
1416 1417
{
  ITEM_CAST_BINARY, ITEM_CAST_SIGNED_INT, ITEM_CAST_UNSIGNED_INT,
unknown's avatar
unknown committed
1418 1419
  ITEM_CAST_DATE, ITEM_CAST_TIME, ITEM_CAST_DATETIME, ITEM_CAST_CHAR,
  ITEM_CAST_DECIMAL
unknown's avatar
unknown committed
1420
};
1421 1422


1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
class Item_func_row_count :public Item_int_func
{
public:
  Item_func_row_count() :Item_int_func() {}
  longlong val_int();
  const char *func_name() const { return "row_count"; }
  void fix_length_and_dec() { decimals= 0; maybe_null=0; }
};


1433 1434 1435 1436 1437 1438 1439
/*
 *
 * Stored FUNCTIONs
 *
 */

class sp_head;
1440
class sp_name;
1441
struct st_sp_security_context;
1442 1443 1444 1445

class Item_func_sp :public Item_func
{
private:
1446
  Name_resolution_context *context;
1447
  sp_name *m_name;
1448
  mutable sp_head *m_sp;
unknown's avatar
unknown committed
1449
  TABLE *dummy_table;
1450
  char result_buf[64];
1451 1452 1453 1454
  /*
     The result field of the concrete stored function.
  */
  Field *sp_result_field;
1455

1456 1457 1458
  bool execute();
  bool execute_impl(THD *thd);
  bool init_result_field(THD *thd);
1459
  
1460 1461
public:

1462
  Item_func_sp(Name_resolution_context *context_arg, sp_name *name);
1463

1464 1465
  Item_func_sp(Name_resolution_context *context_arg,
               sp_name *name, List<Item> &list);
1466 1467 1468 1469

  virtual ~Item_func_sp()
  {}

1470 1471
  table_map used_tables() const { return RAND_TABLE_BIT; }

1472
  void cleanup();
1473

1474
  const char *func_name() const;
1475

1476 1477
  enum enum_field_types field_type() const;

unknown's avatar
unknown committed
1478 1479 1480 1481
  Field *tmp_table_field(TABLE *t_arg);

  void make_field(Send_field *tmp_field);

1482 1483 1484 1485
  Item_result result_type() const;

  longlong val_int()
  {
1486
    if (execute())
unknown's avatar
unknown committed
1487
      return (longlong) 0;
1488
    return sp_result_field->val_int();
1489 1490
  }

1491
  double val_real()
1492
  {
1493
    if (execute())
1494
      return 0.0;
1495
    return sp_result_field->val_real();
1496 1497
  }

unknown's avatar
unknown committed
1498 1499
  my_decimal *val_decimal(my_decimal *dec_buf)
  {
1500
    if (execute())
unknown's avatar
unknown committed
1501
      return NULL;
1502
    return sp_result_field->val_decimal(dec_buf);
unknown's avatar
unknown committed
1503 1504
  }

1505 1506
  String *val_str(String *str)
  {
1507 1508 1509 1510
    String buf;
    char buff[20];
    buf.set(buff, 20, str->charset());
    buf.length(0);
1511
    if (execute())
1512
      return NULL;
1513 1514 1515 1516 1517 1518
    /*
      result_field will set buf pointing to internal buffer
      of the resul_field. Due to this it will change any time
      when SP is executed. In order to prevent occasional
      corruption of returned value, we make here a copy.
    */
1519
    sp_result_field->val_str(&buf);
1520 1521
    str->copy(buf);
    return str;
1522 1523
  }

1524 1525 1526
  virtual bool change_context_processor(byte *cntx)
    { context= (Name_resolution_context *)cntx; return FALSE; }

1527
  bool sp_check_access(THD * thd);
1528
  virtual enum Functype functype() const { return FUNC_SP; }
1529

1530
  bool fix_fields(THD *thd, Item **ref);
1531
  void fix_length_and_dec(void);
1532
  bool is_expensive() { return 1; }
1533
};
unknown's avatar
unknown committed
1534 1535


1536 1537 1538 1539 1540 1541 1542 1543
class Item_func_found_rows :public Item_int_func
{
public:
  Item_func_found_rows() :Item_int_func() {}
  longlong val_int();
  const char *func_name() const { return "found_rows"; }
  void fix_length_and_dec() { decimals= 0; maybe_null=0; }
};