item_func.h 39.1 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
2

unknown's avatar
unknown committed
3 4 5 6
   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
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
7

unknown's avatar
unknown committed
8 9 10 11
   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.
12

unknown's avatar
unknown committed
13 14 15 16 17 18 19
   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 */

20
#ifdef USE_PRAGMA_INTERFACE
unknown's avatar
unknown committed
21 22 23 24 25 26 27 28 29 30 31 32 33
#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:
34
  Item **args, *tmp_arg[2];
35 36 37 38
  /*
    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
39
  uint allowed_arg_cols;
unknown's avatar
unknown committed
40 41
public:
  uint arg_count;
42
  table_map used_tables_cache, not_null_tables_cache;
unknown's avatar
unknown committed
43 44 45
  bool const_item_cache;
  enum Functype { UNKNOWN_FUNC,EQ_FUNC,EQUAL_FUNC,NE_FUNC,LT_FUNC,LE_FUNC,
		  GE_FUNC,GT_FUNC,FT_FUNC,
46
		  LIKE_FUNC,ISNULL_FUNC,ISNOTNULL_FUNC,
47 48
		  COND_AND_FUNC, COND_OR_FUNC, COND_XOR_FUNC,
                  BETWEEN, IN_FUNC, MULT_EQUAL_FUNC,
49
		  INTERVAL_FUNC, ISNOTNULLTEST_FUNC,
unknown's avatar
unknown committed
50 51 52 53
		  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,
54
		  SP_POINTN,SP_GEOMETRYN,SP_INTERIORRINGN,
unknown's avatar
unknown committed
55 56
                  NOT_FUNC, NOT_ALL_FUNC,
                  NOW_FUNC, TRIG_COND_FUNC,
57
                  GUSERVAR_FUNC, COLLATE_FUNC,
58
                  EXTRACT_FUNC, CHAR_TYPECAST_FUNC, FUNC_SP };
59 60
  enum optimize_type { OPTIMIZE_NONE,OPTIMIZE_KEY,OPTIMIZE_OP, OPTIMIZE_NULL,
                       OPTIMIZE_EQUAL };
unknown's avatar
unknown committed
61 62
  enum Type type() const { return FUNC_ITEM; }
  virtual enum Functype functype() const   { return UNKNOWN_FUNC; }
unknown's avatar
unknown committed
63 64
  Item_func(void):
    allowed_arg_cols(1), arg_count(0)
unknown's avatar
unknown committed
65
  {
66
    with_sum_func= 0;
unknown's avatar
unknown committed
67
  }
unknown's avatar
unknown committed
68 69
  Item_func(Item *a):
    allowed_arg_cols(1), arg_count(1)
unknown's avatar
unknown committed
70
  {
71
    args= tmp_arg;
72 73
    args[0]= a;
    with_sum_func= a->with_sum_func;
unknown's avatar
unknown committed
74
  }
unknown's avatar
unknown committed
75 76
  Item_func(Item *a,Item *b):
    allowed_arg_cols(1), arg_count(2)
unknown's avatar
unknown committed
77
  {
78
    args= tmp_arg;
79 80
    args[0]= a; args[1]= b;
    with_sum_func= a->with_sum_func || b->with_sum_func;
unknown's avatar
unknown committed
81
  }
unknown's avatar
unknown committed
82 83
  Item_func(Item *a,Item *b,Item *c):
    allowed_arg_cols(1)
unknown's avatar
unknown committed
84
  {
85 86
    arg_count= 0;
    if ((args= (Item**) sql_alloc(sizeof(Item*)*3)))
unknown's avatar
unknown committed
87
    {
88 89 90
      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
91 92
    }
  }
unknown's avatar
unknown committed
93 94
  Item_func(Item *a,Item *b,Item *c,Item *d):
    allowed_arg_cols(1)
unknown's avatar
unknown committed
95
  {
96 97
    arg_count= 0;
    if ((args= (Item**) sql_alloc(sizeof(Item*)*4)))
unknown's avatar
unknown committed
98
    {
99 100 101 102
      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
103 104
    }
  }
unknown's avatar
unknown committed
105 106
  Item_func(Item *a,Item *b,Item *c,Item *d,Item* e):
    allowed_arg_cols(1)
unknown's avatar
unknown committed
107
  {
108 109
    arg_count= 5;
    if ((args= (Item**) sql_alloc(sizeof(Item*)*5)))
unknown's avatar
unknown committed
110
    {
111 112 113
      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
114 115 116
    }
  }
  Item_func(List<Item> &list);
117
  // Constructor used for Item_cond_and/or (see Item comment)
118
  Item_func(THD *thd, Item_func *item);
119
  bool fix_fields(THD *, Item **ref);
unknown's avatar
unknown committed
120
  table_map used_tables() const;
121
  table_map not_null_tables() const;
unknown's avatar
unknown committed
122
  void update_used_tables();
123
  bool eq(const Item *item, bool binary_cmp) const;
unknown's avatar
unknown committed
124 125 126
  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]; }
127 128 129 130 131 132 133 134 135 136 137
  /*
    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
138 139
  virtual bool const_item() const { return const_item_cache; }
  inline Item **arguments() const { return args; }
140
  void set_arguments(List<Item> &list);
unknown's avatar
unknown committed
141 142
  inline uint argument_count() const { return arg_count; }
  inline void remove_arguments() { arg_count=0; }
143
  void split_sum_func(THD *thd, Item **ref_pointer_array, List<Item> &fields);
unknown's avatar
unknown committed
144 145
  void print(String *str);
  void print_op(String *str);
unknown's avatar
unknown committed
146
  void print_args(String *str, uint from);
unknown's avatar
unknown committed
147 148 149 150
  virtual void fix_num_length_and_dec();
  void count_only_length();
  void count_real_length();
  void count_decimal_length();
151
  inline bool get_arg0_date(TIME *ltime, uint fuzzy_date)
unknown's avatar
unknown committed
152
  {
153
    return (null_value=args[0]->get_date(ltime, fuzzy_date));
unknown's avatar
unknown committed
154 155 156 157 158
  }
  inline bool get_arg0_time(TIME *ltime)
  {
    return (null_value=args[0]->get_time(ltime));
  }
unknown's avatar
unknown committed
159
  bool is_null() { (void) val_int(); return null_value; }
unknown's avatar
unknown committed
160
  void signal_divide_by_null();
unknown's avatar
unknown committed
161
  friend class udf_handler;
162
  Field *tmp_table_field() { return result_field; }
163
  Field *tmp_table_field(TABLE *t_arg);
164
  Item *get_tmp_table_item(THD *thd);
unknown's avatar
unknown committed
165 166 167

  my_decimal *val_decimal(my_decimal *);

168
  bool agg_arg_collations(DTCollation &c, Item **items, uint nitems,
169 170 171 172
                          uint flags= 0)
  {
    return agg_item_collations(c, func_name(), items, nitems, flags);
  }
173 174
  bool agg_arg_collations_for_comparison(DTCollation &c,
                                         Item **items, uint nitems,
175 176 177 178 179
                                         uint flags= 0)
  {
    return agg_item_collations_for_comparison(c, func_name(),
                                              items, nitems, flags);
  }
unknown's avatar
unknown committed
180
  bool agg_arg_charsets(DTCollation &c, Item **items, uint nitems,
181 182 183 184
                        uint flags= 0)
  {
    return agg_item_charsets(c, func_name(), items, nitems, flags);
  }
unknown's avatar
unknown committed
185
  bool walk(Item_processor processor, byte *arg);
unknown's avatar
unknown committed
186
  Item *transform(Item_transformer transformer, byte *arg);
187 188
  void traverse_cond(Cond_traverser traverser,
                     void * arg, traverse_order order);
unknown's avatar
unknown committed
189 190 191 192 193 194 195 196 197 198 199
};


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);
200
  my_decimal *val_decimal(my_decimal *decimal_value);
201
  longlong val_int()
202
    { DBUG_ASSERT(fixed == 1); return (longlong) rint(val_real()); }
unknown's avatar
unknown committed
203
  enum Item_result result_type () const { return REAL_RESULT; }
unknown's avatar
unknown committed
204 205
  void fix_length_and_dec()
  { decimals= NOT_FIXED_DEC; max_length= float_length(decimals); }
unknown's avatar
unknown committed
206 207
};

208

unknown's avatar
unknown committed
209
class Item_func_numhybrid: public Item_func
unknown's avatar
unknown committed
210
{
unknown's avatar
unknown committed
211
protected:
unknown's avatar
unknown committed
212 213
  Item_result hybrid_type;
public:
unknown's avatar
unknown committed
214
  Item_func_numhybrid(Item *a) :Item_func(a), hybrid_type(REAL_RESULT)
unknown's avatar
unknown committed
215 216
  {}
  Item_func_numhybrid(Item *a,Item *b)
unknown's avatar
unknown committed
217
    :Item_func(a,b), hybrid_type(REAL_RESULT)
unknown's avatar
unknown committed
218
  {}
unknown's avatar
unknown committed
219
  Item_func_numhybrid(List<Item> &list)
unknown's avatar
unknown committed
220
    :Item_func(list), hybrid_type(REAL_RESULT)
unknown's avatar
unknown committed
221
  {}
unknown's avatar
unknown committed
222

unknown's avatar
unknown committed
223
  enum Item_result result_type () const { return hybrid_type; }
unknown's avatar
unknown committed
224 225 226 227 228 229 230 231 232 233 234 235
  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
236
  virtual String *str_op(String *)= 0;
237
  bool is_null() { (void) val_real(); return null_value; }
unknown's avatar
unknown committed
238 239
};

unknown's avatar
unknown committed
240 241 242 243 244 245
/* 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
246

unknown's avatar
unknown committed
247 248
  void fix_num_length_and_dec();
  void find_num_type();
unknown's avatar
unknown committed
249
  String *str_op(String *str) { DBUG_ASSERT(0); return 0; }
unknown's avatar
unknown committed
250
};
unknown's avatar
unknown committed
251

unknown's avatar
unknown committed
252 253 254

/* Base class for operations like '+', '-', '*' */
class Item_num_op :public Item_func_numhybrid
unknown's avatar
unknown committed
255 256
{
 public:
unknown's avatar
unknown committed
257 258
  Item_num_op(Item *a,Item *b) :Item_func_numhybrid(a, b) {}
  virtual void result_precision()= 0;
unknown's avatar
unknown committed
259
  void print(String *str) { print_op(str); }
unknown's avatar
unknown committed
260
  void find_num_type();
unknown's avatar
unknown committed
261
  String *str_op(String *str) { DBUG_ASSERT(0); return 0; }
unknown's avatar
unknown committed
262 263 264 265 266 267
};


class Item_int_func :public Item_func
{
public:
unknown's avatar
unknown committed
268 269 270 271 272 273
  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; }
274
  Item_int_func(THD *thd, Item_int_func *item) :Item_func(thd, item) {}
275
  double val_real() { DBUG_ASSERT(fixed == 1); return (double) val_int(); }
unknown's avatar
unknown committed
276 277
  String *val_str(String*str);
  enum Item_result result_type () const { return INT_RESULT; }
unknown's avatar
unknown committed
278
  void fix_length_and_dec() {}
unknown's avatar
unknown committed
279 280
};

281

282 283 284 285 286
class Item_func_connection_id :public Item_int_func
{
  longlong value;

public:
287
  Item_func_connection_id() {}
288 289 290 291 292 293 294
  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; }
};


295 296 297 298
class Item_func_signed :public Item_int_func
{
public:
  Item_func_signed(Item *a) :Item_int_func(a) {}
299
  const char *func_name() const { return "cast_as_signed"; }
300
  double val_real()
unknown's avatar
unknown committed
301
  {
302
    double tmp= args[0]->val_real();
unknown's avatar
unknown committed
303 304 305
    null_value= args[0]->null_value;
    return tmp;
  }
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 335 336 337
  Item_decimal_typecast(Item *a, int len, int dec) :Item_func(a)
  {
    max_length= len + 2;
    decimals= dec;
  }
  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 426 427 428
  void result_precision();
};


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


unknown's avatar
unknown committed
443
class Item_func_abs :public Item_func_num1
unknown's avatar
unknown committed
444 445
{
public:
unknown's avatar
unknown committed
446 447 448 449
  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
450 451 452 453
  const char *func_name() const { return "abs"; }
  void fix_length_and_dec();
};

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

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()
  {
463
    decimals=NOT_FIXED_DEC; max_length=float_length(decimals);
unknown's avatar
unknown committed
464 465 466 467 468 469 470
    maybe_null=1;
  }
  inline double fix_result(double value)
  {
#ifndef HAVE_FINITE
    return value;
#else
471
    /* The following should be safe, even if we compare doubles */
unknown's avatar
unknown committed
472 473 474 475 476 477 478 479 480 481 482 483
    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) {}
484
  double val_real();
unknown's avatar
unknown committed
485 486 487
  const char *func_name() const { return "exp"; }
};

488 489 490 491 492

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


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


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


unknown's avatar
unknown committed
517 518 519 520
class Item_func_log10 :public Item_dec_func
{
public:
  Item_func_log10(Item *a) :Item_dec_func(a) {}
521
  double val_real();
unknown's avatar
unknown committed
522 523 524 525 526 527 528 529
  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) {}
530
  double val_real();
unknown's avatar
unknown committed
531 532 533 534 535 536 537 538
  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) {}
539
  double val_real();
unknown's avatar
unknown committed
540 541 542 543 544 545
  const char *func_name() const { return "pow"; }
};


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

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

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

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

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

class Item_func_tan :public Item_dec_func
{
587
public:
unknown's avatar
unknown committed
588
  Item_func_tan(Item *a) :Item_dec_func(a) {}
589
  double val_real();
unknown's avatar
unknown committed
590 591 592 593 594 595 596 597 598 599 600
  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
601 602 603 604 605 606 607 608 609 610
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
611 612
{
public:
unknown's avatar
unknown committed
613
  Item_func_ceiling(Item *a) :Item_func_int_val(a) {}
unknown's avatar
unknown committed
614
  const char *func_name() const { return "ceiling"; }
unknown's avatar
unknown committed
615 616 617
  longlong int_op();
  double real_op();
  my_decimal *decimal_op(my_decimal *);
unknown's avatar
unknown committed
618 619
};

unknown's avatar
unknown committed
620 621

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

/* This handles round and truncate */

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


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


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;
674
public:
unknown's avatar
unknown committed
675 676
  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) {}
677
  double val_real();
unknown's avatar
unknown committed
678
  const char *func_name() const { return name; }
unknown's avatar
unknown committed
679 680
  void fix_length_and_dec()
  { decimals= NOT_FIXED_DEC; max_length= float_length(decimals); }
unknown's avatar
unknown committed
681 682 683 684 685 686 687 688 689 690
};


class Item_func_min_max :public Item_func
{
  Item_result cmp_type;
  String tmp_value;
  int cmp_sign;
public:
  Item_func_min_max(List<Item> &list,int cmp_sign_arg) :Item_func(list),
691
    cmp_type(INT_RESULT), cmp_sign(cmp_sign_arg) {}
692
  double val_real();
unknown's avatar
unknown committed
693 694
  longlong val_int();
  String *val_str(String *);
unknown's avatar
unknown committed
695
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
  void fix_length_and_dec();
  enum Item_result result_type () const { return cmp_type; }
};

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
714

unknown's avatar
unknown committed
715 716 717 718 719 720 721 722 723 724
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
725 726 727 728
class Item_func_bit_length :public Item_func_length
{
public:
  Item_func_bit_length(Item *a) :Item_func_length(a) {}
729 730
  longlong val_int()
    { DBUG_ASSERT(fixed == 1); return Item_func_length::val_int()*8; }
unknown's avatar
unknown committed
731 732 733
  const char *func_name() const { return "bit_length"; }
};

unknown's avatar
unknown committed
734 735 736 737 738 739 740 741 742 743
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
744 745 746 747 748 749
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"; }
750 751
  void fix_length_and_dec() { max_length=10; maybe_null= 0; }
  table_map not_null_tables() const { return 0; }
unknown's avatar
unknown committed
752 753
};

unknown's avatar
unknown committed
754 755 756
class Item_func_locate :public Item_int_func
{
  String value1,value2;
757
  DTCollation cmp_collation;
unknown's avatar
unknown committed
758 759 760 761 762
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();
763
  void fix_length_and_dec();
764
  void print(String *str);
unknown's avatar
unknown committed
765 766 767 768 769 770
};


class Item_func_field :public Item_int_func
{
  String value,tmp;
771 772
  Item_result cmp_type;
  DTCollation cmp_collation;
unknown's avatar
unknown committed
773
public:
774
  Item_func_field(List<Item> &list) :Item_int_func(list) {}
unknown's avatar
unknown committed
775 776
  longlong val_int();
  const char *func_name() const { return "field"; }
777
  void fix_length_and_dec();
unknown's avatar
unknown committed
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804
};


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;
805
  DTCollation cmp_collation;
unknown's avatar
unknown committed
806 807 808 809 810 811 812
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();
};

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

815
class Item_func_bit: public Item_int_func
unknown's avatar
unknown committed
816 817
{
public:
818 819 820
  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
821
  void print(String *str) { print_op(str); }
822 823 824 825 826 827
};

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
828 829 830 831
  longlong val_int();
  const char *func_name() const { return "|"; }
};

832
class Item_func_bit_and :public Item_func_bit
unknown's avatar
unknown committed
833 834
{
public:
835
  Item_func_bit_and(Item *a, Item *b) :Item_func_bit(a, b) {}
unknown's avatar
unknown committed
836 837 838 839 840 841 842 843 844 845
  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
846
  void fix_length_and_dec() { max_length=2; }
unknown's avatar
unknown committed
847 848
};

849
class Item_func_shift_left :public Item_func_bit
unknown's avatar
unknown committed
850 851
{
public:
852
  Item_func_shift_left(Item *a, Item *b) :Item_func_bit(a, b) {}
unknown's avatar
unknown committed
853 854 855 856
  longlong val_int();
  const char *func_name() const { return "<<"; }
};

857
class Item_func_shift_right :public Item_func_bit
unknown's avatar
unknown committed
858 859
{
public:
860
  Item_func_shift_right(Item *a, Item *b) :Item_func_bit(a, b) {}
unknown's avatar
unknown committed
861 862 863 864
  longlong val_int();
  const char *func_name() const { return ">>"; }
};

865
class Item_func_bit_neg :public Item_func_bit
unknown's avatar
unknown committed
866 867
{
public:
868
  Item_func_bit_neg(Item *a) :Item_func_bit(a) {}
unknown's avatar
unknown committed
869 870
  longlong val_int();
  const char *func_name() const { return "~"; }
unknown's avatar
unknown committed
871
  void print(String *str) { Item_func::print(str); }
unknown's avatar
unknown committed
872 873
};

unknown's avatar
unknown committed
874

875
class Item_func_last_insert_id :public Item_int_func
unknown's avatar
unknown committed
876 877
{
public:
878 879
  Item_func_last_insert_id() :Item_int_func() {}
  Item_func_last_insert_id(Item *a) :Item_int_func(a) {}
unknown's avatar
unknown committed
880 881
  longlong val_int();
  const char *func_name() const { return "last_insert_id"; }
unknown's avatar
unknown committed
882 883 884 885 886
  void fix_length_and_dec()
  {
    if (arg_count)
      max_length= args[0]->max_length;
  }
unknown's avatar
unknown committed
887 888
};

889

unknown's avatar
unknown committed
890 891 892
class Item_func_benchmark :public Item_int_func
{
  ulong loop_count;
893
public:
unknown's avatar
unknown committed
894 895 896 897 898
  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
899
  void fix_length_and_dec() { max_length=1; maybe_null=0; }
900
  void print(String *str);
unknown's avatar
unknown committed
901 902 903
};


904 905 906 907
class Item_func_sleep :public Item_int_func
{
public:
  Item_func_sleep(Item *a) :Item_int_func(a) {}
908
  bool const_item() const { return 0; }
909
  const char *func_name() const { return "sleep"; }
910 911 912 913 914
  void update_used_tables()
  {
    Item_int_func::update_used_tables();
    used_tables_cache|= RAND_TABLE_BIT;
  }
915 916 917 918 919
  longlong val_int();
};



unknown's avatar
unknown committed
920 921 922 923
#ifdef HAVE_DLOPEN

class Item_udf_func :public Item_func
{
924
protected:
unknown's avatar
unknown committed
925 926 927
  udf_handler udf;

public:
928 929
  Item_udf_func(udf_func *udf_arg)
    :Item_func(), udf(udf_arg) {}
unknown's avatar
unknown committed
930 931 932
  Item_udf_func(udf_func *udf_arg, List<Item> &list)
    :Item_func(list), udf(udf_arg) {}
  const char *func_name() const { return udf.name(); }
933
  bool fix_fields(THD *thd, Item **ref)
unknown's avatar
unknown committed
934
  {
935
    DBUG_ASSERT(fixed == 0);
936
    bool res= udf.fix_fields(thd, this, arg_count, args);
unknown's avatar
unknown committed
937 938
    used_tables_cache= udf.used_tables_cache;
    const_item_cache= udf.const_item_cache;
939
    fixed= 1;
unknown's avatar
unknown committed
940 941
    return res;
  }
942
  void cleanup();
unknown's avatar
unknown committed
943
  Item_result result_type () const { return udf.result_type(); }
944
  table_map not_null_tables() const { return 0; }
unknown's avatar
unknown committed
945 946 947 948 949 950
};


class Item_func_udf_float :public Item_udf_func
{
 public:
951 952 953 954 955
  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) {}
956
  longlong val_int()
957 958
  {
    DBUG_ASSERT(fixed == 1);
959
    return (longlong) rint(Item_func_udf_float::val_real());
960
  }
unknown's avatar
unknown committed
961 962 963 964 965 966 967 968
  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;
  }
969
  double val_real();
unknown's avatar
unknown committed
970 971 972 973 974 975 976 977
  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:
978 979 980 981 982
  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
983
  longlong val_int();
984
  double val_real() { return (double) Item_func_udf_int::val_int(); }
unknown's avatar
unknown committed
985 986
  String *val_str(String *str);
  enum Item_result result_type () const { return INT_RESULT; }
unknown's avatar
unknown committed
987 988 989 990 991 992 993
  void fix_length_and_dec() { decimals= 0; max_length= 21; }
};


class Item_func_udf_decimal :public Item_udf_func
{
public:
994 995
  Item_func_udf_decimal(udf_func *udf_arg)
    :Item_udf_func(udf_arg) {}
unknown's avatar
unknown committed
996
  Item_func_udf_decimal(udf_func *udf_arg, List<Item> &list)
997
    :Item_udf_func(udf_arg, list) {}
unknown's avatar
unknown committed
998 999 1000 1001 1002 1003
  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
1004 1005 1006 1007 1008 1009
};


class Item_func_udf_str :public Item_udf_func
{
public:
1010 1011
  Item_func_udf_str(udf_func *udf_arg)
    :Item_udf_func(udf_arg) {}
unknown's avatar
unknown committed
1012
  Item_func_udf_str(udf_func *udf_arg, List<Item> &list)
1013
    :Item_udf_func(udf_arg, list) {}
unknown's avatar
unknown committed
1014
  String *val_str(String *);
1015
  double val_real()
unknown's avatar
unknown committed
1016
  {
unknown's avatar
unknown committed
1017 1018 1019 1020 1021 1022
    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
1023 1024 1025
  }
  longlong val_int()
  {
unknown's avatar
unknown committed
1026
    int err_not_used;
unknown's avatar
unknown committed
1027
    String *res;  res=val_str(&str_value);
unknown's avatar
unknown committed
1028 1029
    return res ? my_strntoll(res->charset(),res->ptr(),res->length(),10,
                             (char**) 0, &err_not_used) : (longlong) 0;
unknown's avatar
unknown committed
1030
  }
unknown's avatar
unknown committed
1031 1032 1033 1034 1035 1036 1037 1038
  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
1039 1040 1041 1042 1043 1044 1045 1046 1047
  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:
1048 1049 1050 1051
  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) {}
1052
  double val_real() { DBUG_ASSERT(fixed == 1); return 0.0; }
unknown's avatar
unknown committed
1053 1054 1055 1056 1057 1058
};


class Item_func_udf_int :public Item_int_func
{
public:
1059 1060 1061 1062
  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) {}
1063
  longlong val_int() { DBUG_ASSERT(fixed == 1); return 0; }
unknown's avatar
unknown committed
1064 1065 1066
};


unknown's avatar
unknown committed
1067 1068 1069
class Item_func_udf_decimal :public Item_int_func
{
public:
1070 1071 1072 1073
  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
1074 1075 1076 1077
  my_decimal *val_decimal(my_decimal *) { DBUG_ASSERT(fixed == 1); return 0; }
};


unknown's avatar
unknown committed
1078 1079 1080
class Item_func_udf_str :public Item_func
{
public:
1081 1082 1083 1084
  Item_func_udf_str(udf_func *udf_arg)
    :Item_func() {}
  Item_func_udf_str(udf_func *udf_arg, List<Item> &list)
    :Item_func(list) {}
1085 1086
  String *val_str(String *)
    { DBUG_ASSERT(fixed == 1); null_value=1; return 0; }
1087
  double val_real() { DBUG_ASSERT(fixed == 1); null_value= 1; return 0.0; }
1088
  longlong val_int() { DBUG_ASSERT(fixed == 1); null_value=1; return 0; }
unknown's avatar
unknown committed
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
  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
*/

1099
class User_level_lock;
unknown's avatar
unknown committed
1100
void item_user_lock_init(void);
1101
void item_user_lock_release(User_level_lock *ull);
unknown's avatar
unknown committed
1102 1103 1104 1105 1106 1107 1108 1109 1110
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
1111
  void fix_length_and_dec() { max_length=1; maybe_null=1;}
unknown's avatar
unknown committed
1112 1113 1114 1115 1116
};

class Item_func_release_lock :public Item_int_func
{
  String value;
1117
public:
unknown's avatar
unknown committed
1118 1119 1120
  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
1121
  void fix_length_and_dec() { max_length=1; maybe_null=1;}
unknown's avatar
unknown committed
1122 1123
};

unknown's avatar
unknown committed
1124 1125 1126 1127 1128
/* replication functions */

class Item_master_pos_wait :public Item_int_func
{
  String value;
1129
public:
unknown's avatar
unknown committed
1130
  Item_master_pos_wait(Item *a,Item *b) :Item_int_func(a,b) {}
1131
  Item_master_pos_wait(Item *a,Item *b,Item *c) :Item_int_func(a,b,c) {}
unknown's avatar
unknown committed
1132 1133
  longlong val_int();
  const char *func_name() const { return "master_pos_wait"; }
1134
  void fix_length_and_dec() { max_length=21; maybe_null=1;}
unknown's avatar
unknown committed
1135 1136
};

unknown's avatar
unknown committed
1137

unknown's avatar
unknown committed
1138
/* Handling of user definable variables */
unknown's avatar
unknown committed
1139 1140 1141 1142 1143 1144 1145

class user_var_entry;

class Item_func_set_user_var :public Item_func
{
  enum Item_result cached_result_type;
  user_var_entry *entry;
1146 1147
  char buffer[MAX_FIELD_WIDTH];
  String value;
unknown's avatar
unknown committed
1148
  my_decimal decimal_buff;
1149
  bool null_item;
1150 1151 1152 1153 1154
  union
  {
    longlong vint;
    double vreal;
    String *vstr;
unknown's avatar
unknown committed
1155
    my_decimal *vdec;
1156 1157 1158
  } save_result;
  String save_buff;
  
unknown's avatar
unknown committed
1159 1160

public:
1161
  LEX_STRING name; // keep it public
1162 1163 1164
  Item_func_set_user_var(LEX_STRING a,Item *b)
    :Item_func(b), cached_result_type(INT_RESULT), name(a)
  {}
1165
  double val_real();
unknown's avatar
unknown committed
1166 1167
  longlong val_int();
  String *val_str(String *str);
unknown's avatar
unknown committed
1168
  my_decimal *val_decimal(my_decimal *);
unknown's avatar
unknown committed
1169
  bool update_hash(void *ptr, uint length, enum Item_result type, 
1170
  		   CHARSET_INFO *cs, Derivation dv);
1171
  bool check();
unknown's avatar
unknown committed
1172 1173
  bool update();
  enum Item_result result_type () const { return cached_result_type; }
1174
  bool fix_fields(THD *thd, Item **ref);
unknown's avatar
unknown committed
1175
  void fix_length_and_dec();
unknown's avatar
unknown committed
1176
  void print(String *str);
1177
  void print_as_stmt(String *str);
unknown's avatar
unknown committed
1178 1179 1180 1181 1182 1183
  const char *func_name() const { return "set_user_var"; }
};


class Item_func_get_user_var :public Item_func
{
1184
  user_var_entry *var_entry;
unknown's avatar
unknown committed
1185 1186

public:
1187
  LEX_STRING name; // keep it public
1188
  Item_func_get_user_var(LEX_STRING a):
1189
    Item_func(), name(a) {}
1190 1191
  enum Functype functype() const { return GUSERVAR_FUNC; }
  LEX_STRING get_name() { return name; }
1192
  double val_real();
unknown's avatar
unknown committed
1193
  longlong val_int();
unknown's avatar
unknown committed
1194
  my_decimal *val_decimal(my_decimal*);
unknown's avatar
unknown committed
1195 1196
  String *val_str(String* str);
  void fix_length_and_dec();
unknown's avatar
unknown committed
1197
  void print(String *str);
unknown's avatar
unknown committed
1198
  enum Item_result result_type() const;
1199 1200 1201 1202
  /*
    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)
  */
1203
  enum_field_types field_type() const  { return MYSQL_TYPE_VARCHAR; }
unknown's avatar
unknown committed
1204
  const char *func_name() const { return "get_user_var"; }
1205
  bool const_item() const;
1206
  table_map used_tables() const
1207
  { return const_item() ? 0 : RAND_TABLE_BIT; }
1208
  bool eq(const Item *item, bool binary_cmp) const;
1209
};
unknown's avatar
unknown committed
1210

unknown's avatar
unknown committed
1211

unknown's avatar
unknown committed
1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233
/*
  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 */
1234
  bool fix_fields(THD *thd, Item **ref);
unknown's avatar
unknown committed
1235 1236 1237 1238 1239 1240
  void print(String *str);
  void set_null_value(CHARSET_INFO* cs);
  void set_value(const char *str, uint length, CHARSET_INFO* cs);
};


1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
/* 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
1252
  bool fix_fields(THD *thd, Item **ref);
1253 1254 1255 1256
  /*
    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
1257
  double val_real()         { DBUG_ASSERT(0); return 0.0; }
1258 1259 1260
  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
1261 1262
  /* TODO: fix to support views */
  const char *func_name() const { return "get_system_var"; }
1263 1264 1265
};


unknown's avatar
unknown committed
1266 1267 1268 1269 1270 1271 1272 1273 1274 1275
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"; }
   void fix_length_and_dec() { decimals = 0; max_length = 21; maybe_null=1;}
};


1276
/* for fulltext search */
1277
#include <ft_global.h>
unknown's avatar
unknown committed
1278 1279 1280 1281

class Item_func_match :public Item_real_func
{
public:
1282
  uint key, flags;
unknown's avatar
unknown committed
1283
  bool join_key;
1284 1285 1286 1287 1288 1289 1290
  DTCollation cmp_collation;
  FT_INFO *ft_handler;
  TABLE *table;
  Item_func_match *master;   // for master-slave optimization
  Item *concat;              // Item_func_concat_ws
  String value;              // value of concat
  String search_value;       // key_item()'s value converted to cmp_collation
unknown's avatar
unknown committed
1291

unknown's avatar
unknown committed
1292 1293
  Item_func_match(List<Item> &a, uint b): Item_real_func(a), key(0), flags(b),
       join_key(0), ft_handler(0), table(0), master(0), concat(0) { }
unknown's avatar
unknown committed
1294
  void cleanup()
1295
  {
unknown's avatar
unknown committed
1296
    DBUG_ENTER("Item_func_match");
1297
    Item_real_func::cleanup();
1298
    if (!master && ft_handler)
unknown's avatar
unknown committed
1299
      ft_handler->please->close_search(ft_handler);
1300
    ft_handler= 0;
unknown's avatar
unknown committed
1301
    concat= 0;
unknown's avatar
unknown committed
1302
    DBUG_VOID_RETURN;
1303
  }
unknown's avatar
unknown committed
1304
  enum Functype functype() const { return FT_FUNC; }
1305
  const char *func_name() const { return "match"; }
unknown's avatar
unknown committed
1306
  void update_used_tables() {}
1307
  table_map not_null_tables() const { return 0; }
1308
  bool fix_fields(THD *thd, Item **ref);
1309
  bool eq(const Item *, bool binary_cmp) const;
1310
  /* The following should be safe, even if we compare doubles */
1311 1312
  longlong val_int() { DBUG_ASSERT(fixed == 1); return val_real() != 0.0; }
  double val_real();
1313
  void print(String *str);
1314 1315

  bool fix_index();
1316
  void init_search(bool no_order);
1317
};
unknown's avatar
unknown committed
1318

unknown's avatar
unknown committed
1319

1320
class Item_func_bit_xor : public Item_func_bit
unknown's avatar
unknown committed
1321 1322
{
public:
1323
  Item_func_bit_xor(Item *a, Item *b) :Item_func_bit(a, b) {}
unknown's avatar
unknown committed
1324 1325 1326 1327
  longlong val_int();
  const char *func_name() const { return "^"; }
};

1328
class Item_func_is_free_lock :public Item_int_func
unknown's avatar
unknown committed
1329 1330 1331
{
  String value;
public:
1332
  Item_func_is_free_lock(Item *a) :Item_int_func(a) {}
unknown's avatar
unknown committed
1333
  longlong val_int();
1334
  const char *func_name() const { return "is_free_lock"; }
unknown's avatar
unknown committed
1335
  void fix_length_and_dec() { decimals=0; max_length=1; maybe_null=1;}
unknown's avatar
unknown committed
1336 1337
};

unknown's avatar
SCRUM  
unknown committed
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
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
1348 1349
/* For type casts */

1350
enum Cast_target
unknown's avatar
unknown committed
1351 1352
{
  ITEM_CAST_BINARY, ITEM_CAST_SIGNED_INT, ITEM_CAST_UNSIGNED_INT,
unknown's avatar
unknown committed
1353 1354
  ITEM_CAST_DATE, ITEM_CAST_TIME, ITEM_CAST_DATETIME, ITEM_CAST_CHAR,
  ITEM_CAST_DECIMAL
unknown's avatar
unknown committed
1355
};
1356 1357


1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
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; }
};


1368 1369 1370 1371 1372 1373 1374
/*
 *
 * Stored FUNCTIONs
 *
 */

class sp_head;
1375
class sp_name;
1376
struct st_sp_security_context;
1377 1378 1379 1380

class Item_func_sp :public Item_func
{
private:
1381
  Name_resolution_context *context;
1382
  sp_name *m_name;
1383
  mutable sp_head *m_sp;
unknown's avatar
unknown committed
1384
  TABLE *dummy_table;
1385 1386
  Field *result_field;
  char result_buf[64];
1387

1388 1389
  bool execute(Field **flp);
  bool execute_impl(THD *thd, Field *return_value_fld);
unknown's avatar
unknown committed
1390
  Field *sp_result_field(void) const;
1391 1392 1393

public:

1394
  Item_func_sp(Name_resolution_context *context_arg, sp_name *name);
1395

1396 1397
  Item_func_sp(Name_resolution_context *context_arg,
               sp_name *name, List<Item> &list);
1398 1399 1400 1401

  virtual ~Item_func_sp()
  {}

1402
  void cleanup();
1403

1404
  const char *func_name() const;
1405

1406 1407
  enum enum_field_types field_type() const;

unknown's avatar
unknown committed
1408 1409 1410 1411
  Field *tmp_table_field(TABLE *t_arg);

  void make_field(Send_field *tmp_field);

1412 1413 1414 1415
  Item_result result_type() const;

  longlong val_int()
  {
1416
    if (execute(&result_field))
unknown's avatar
unknown committed
1417
      return (longlong) 0;
1418
    return result_field->val_int();
1419 1420
  }

1421
  double val_real()
1422
  {
1423
    if (execute(&result_field))
1424
      return 0.0;
1425
    return result_field->val_real();
1426 1427
  }

unknown's avatar
unknown committed
1428 1429
  my_decimal *val_decimal(my_decimal *dec_buf)
  {
1430
    if (execute(&result_field))
unknown's avatar
unknown committed
1431
      return NULL;
1432
    return result_field->val_decimal(dec_buf);
unknown's avatar
unknown committed
1433 1434
  }

1435 1436
  String *val_str(String *str)
  {
1437 1438 1439 1440
    String buf;
    char buff[20];
    buf.set(buff, 20, str->charset());
    buf.length(0);
1441
    if (execute(&result_field))
1442
      return NULL;
1443 1444 1445 1446 1447 1448 1449 1450 1451
    /*
      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.
    */
    result_field->val_str(&buf);
    str->copy(buf);
    return str;
1452 1453
  }

1454 1455 1456
  virtual bool change_context_processor(byte *cntx)
    { context= (Name_resolution_context *)cntx; return FALSE; }

1457
  void fix_length_and_dec();
unknown's avatar
unknown committed
1458 1459
  bool find_and_check_access(THD * thd, ulong want_access,
                             Security_context **backup);
1460
  virtual enum Functype functype() const { return FUNC_SP; }
1461

1462
  bool fix_fields(THD *thd, Item **ref);
1463
};
unknown's avatar
unknown committed
1464 1465


1466 1467 1468 1469 1470 1471 1472 1473
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; }
};