#ifndef ITEM_FUNC_INCLUDED
#define ITEM_FUNC_INCLUDED

/* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.

 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; version 2 of the License.

 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.

 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */


/* Function items used by mysql */

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

class Item_func :public Item_result_field
{
protected:
 Item **args, *tmp_arg[2];
 /// Value used in calculation of result of const_item()
 bool const_item_cache;
 /*
 Allowed numbers of columns in result (usually 1, which means scalar value)
 0 means get this number from first argument
 */
 uint allowed_arg_cols;
 /// Value used in calculation of result of used_tables()
 table_map used_tables_cache;
 /// Value used in calculation of result of not_null_tables()
 table_map not_null_tables_cache;
public:
 uint arg_count;
 //bool const_item_cache;
 enum Functype { UNKNOWN_FUNC,EQ_FUNC,EQUAL_FUNC,NE_FUNC,LT_FUNC,LE_FUNC,
		 GE_FUNC,GT_FUNC,FT_FUNC,
		 LIKE_FUNC,ISNULL_FUNC,ISNOTNULL_FUNC,
		 COND_AND_FUNC, COND_OR_FUNC, XOR_FUNC,
 BETWEEN, IN_FUNC, MULT_EQUAL_FUNC,
		 INTERVAL_FUNC, ISNOTNULLTEST_FUNC,
		 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,
		 SP_POINTN,SP_GEOMETRYN,SP_INTERIORRINGN,
 NOT_FUNC, NOT_ALL_FUNC,
 NOW_FUNC, TRIG_COND_FUNC,
 SUSERVAR_FUNC, GUSERVAR_FUNC, COLLATE_FUNC,
 EXTRACT_FUNC, CHAR_TYPECAST_FUNC, FUNC_SP, UDF_FUNC,
 NEG_FUNC, GSYSVAR_FUNC };
 enum optimize_type { OPTIMIZE_NONE,OPTIMIZE_KEY,OPTIMIZE_OP, OPTIMIZE_NULL,
 OPTIMIZE_EQUAL };
 enum Type type() const { return FUNC_ITEM; }
 virtual enum Functype functype() const { return UNKNOWN_FUNC; }
 Item_func(void):
 allowed_arg_cols(1), arg_count(0)
 {
 with_sum_func= 0;
 }
 Item_func(Item *a):
 allowed_arg_cols(1), arg_count(1)
 {
 args= tmp_arg;
 args[0]= a;
 with_sum_func= a->with_sum_func;
 }
 Item_func(Item *a,Item *b):
 allowed_arg_cols(1), arg_count(2)
 {
 args= tmp_arg;
 args[0]= a; args[1]= b;
 with_sum_func= a->with_sum_func || b->with_sum_func;
 }
 Item_func(Item *a,Item *b,Item *c):
 allowed_arg_cols(1)
 {
 arg_count= 0;
 if ((args= (Item**) sql_alloc(sizeof(Item*)*3)))
 {
 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;
 }
 }
 Item_func(Item *a,Item *b,Item *c,Item *d):
 allowed_arg_cols(1)
 {
 arg_count= 0;
 if ((args= (Item**) sql_alloc(sizeof(Item*)*4)))
 {
 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;
 }
 }
 Item_func(Item *a,Item *b,Item *c,Item *d,Item* e):
 allowed_arg_cols(1)
 {
 arg_count= 5;
 if ((args= (Item**) sql_alloc(sizeof(Item*)*5)))
 {
 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 ;
 }
 }
 Item_func(List<Item> &list);
 // Constructor used for Item_cond_and/or (see Item comment)
 Item_func(THD *thd, Item_func *item);
 table_map used_tables() const;
 /**
 Returns the pseudo tables depended upon in order to evaluate this
 function expression. The default implementation returns the empty
 set.
 */
 virtual table_map get_initial_pseudo_tables() const { return 0; }
 table_map not_null_tables() const;
 void set_used_tables(table_map map) { used_tables_cache= map; }
 void set_not_null_tables(table_map map) { not_null_tables_cache= map; }
 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]; }
 virtual bool const_item() const { return const_item_cache; }
 inline Item **arguments() const
 { DBUG_ASSERT(argument_count() > 0); return args; }
 void set_arguments(List<Item> &list);
 inline uint argument_count() const { return arg_count; }
 inline void remove_arguments() { arg_count=0; }
 virtual void print(String *str, enum_query_type query_type);
 void print_op(String *str, enum_query_type query_type);
 void print_args(String *str, uint from, enum_query_type query_type);
 bool is_null() {
 return null_value; 
 }
 void signal_divide_by_null();
 friend class udf_handler;

 my_decimal *val_decimal(my_decimal *);
 bool walk(Item_processor processor, bool walk_subquery, uchar *arg);
 inline double fix_result(double value)
 {
 if (my_isfinite(value))
 return value;
 null_value=1;
 return 0.0;
 }
 inline void raise_numeric_overflow(const char *type_name)
 {
 char buf[256];
 String str(buf, sizeof(buf), system_charset_info);
 str.length(0);
 print(&str, QT_ORDINARY);
 my_error(ER_DATA_OUT_OF_RANGE, MYF(0), type_name, str.c_ptr_safe());
 }
 inline double raise_float_overflow()
 {
 raise_numeric_overflow("DOUBLE");
 return 0.0;
 }
 inline longlong raise_integer_overflow()
 {
 raise_numeric_overflow(unsigned_flag ? "BIGINT UNSIGNED": "BIGINT");
 return 0;
 }
 inline int raise_decimal_overflow()
 {
 raise_numeric_overflow("DECIMAL");
 return E_DEC_OVERFLOW;
 }
 /**
 Throw an error if the input double number is not finite, i.e. is either
 +/-INF or NAN.
 */
 inline double check_float_overflow(double value)
 {
 return my_isfinite(value) ? value : raise_float_overflow();
 }
 /**
 Throw an error if the input BIGINT value represented by the
 (longlong value, bool unsigned flag) pair cannot be returned by the
 function, i.e. is not compatible with this Item's unsigned_flag.
 */
 inline longlong check_integer_overflow(longlong value, bool val_unsigned)
 {
 if ((unsigned_flag && !val_unsigned && value < 0) ||
 (!unsigned_flag && val_unsigned &&
 (ulonglong) value > (ulonglong) LONGLONG_MAX))
 return raise_integer_overflow();
 return value;
 }
 /**
 Throw an error if the error code of a DECIMAL operation is E_DEC_OVERFLOW.
 */
 inline int check_decimal_overflow(int error)
 {
 return (error == E_DEC_OVERFLOW) ? raise_decimal_overflow() : error;
 }

 bool has_timestamp_args()
 {
 DBUG_ASSERT(fixed == TRUE);
 for (uint i= 0; i < arg_count; i++)
 {
 if (args[i]->type() == Item::FIELD_ITEM &&
 args[i]->field_type() == MYSQL_TYPE_TIMESTAMP)
 return TRUE;
 }
 return FALSE;
 }

 bool has_date_args()
 {
 DBUG_ASSERT(fixed == TRUE);
 for (uint i= 0; i < arg_count; i++)
 {
 if (args[i]->type() == Item::FIELD_ITEM &&
 (args[i]->field_type() == MYSQL_TYPE_DATE ||
 args[i]->field_type() == MYSQL_TYPE_DATETIME))
 return TRUE;
 }
 return FALSE;
 }

 bool has_time_args()
 {
 DBUG_ASSERT(fixed == TRUE);
 for (uint i= 0; i < arg_count; i++)
 {
 if (args[i]->type() == Item::FIELD_ITEM &&
 (args[i]->field_type() == MYSQL_TYPE_TIME ||
 args[i]->field_type() == MYSQL_TYPE_DATETIME))
 return TRUE;
 }
 return FALSE;
 }

 bool has_datetime_args()
 {
 DBUG_ASSERT(fixed == TRUE);
 for (uint i= 0; i < arg_count; i++)
 {
 if (args[i]->type() == Item::FIELD_ITEM &&
 args[i]->field_type() == MYSQL_TYPE_DATETIME)
 return TRUE;
 }
 return FALSE;
 }

 /*
 We assume the result of any function that has a TIMESTAMP argument to be
 timezone-dependent, since a TIMESTAMP value in both numeric and string
 contexts is interpreted according to the current timezone.
 The only exception is UNIX_TIMESTAMP() which returns the internal
 representation of a TIMESTAMP argument verbatim, and thus does not depend on
 the timezone.
 */
 virtual bool check_valid_arguments_processor(uchar *bool_arg)
 {
 return has_timestamp_args();
 }

 virtual bool find_function_processor (uchar *arg)
 {
 return functype() == *(Functype *) arg;
 }
};


class Item_real_func :public Item_func
{
public:
 Item_real_func() :Item_func() { collation.set_numeric(); }
 Item_real_func(Item *a) :Item_func(a) { collation.set_numeric(); }
 Item_real_func(Item *a,Item *b) :Item_func(a,b) { collation.set_numeric(); }
 Item_real_func(List<Item> &list) :Item_func(list) { collation.set_numeric(); }
 String *val_str(String*str);
 my_decimal *val_decimal(my_decimal *decimal_value);
 longlong val_int()
 { DBUG_ASSERT(fixed == 1); return (longlong) rint(val_real()); }
 enum Item_result result_type () const { return REAL_RESULT; }
};


class Item_func_numhybrid: public Item_func
{
protected:
 Item_result hybrid_type;
public:
 Item_func_numhybrid(Item *a) :Item_func(a), hybrid_type(REAL_RESULT)
 { collation.set_numeric(); }
 Item_func_numhybrid(Item *a,Item *b)
 :Item_func(a,b), hybrid_type(REAL_RESULT)
 { collation.set_numeric(); }
 Item_func_numhybrid(List<Item> &list)
 :Item_func(list), hybrid_type(REAL_RESULT)
 { collation.set_numeric(); }

 enum Item_result result_type () const { return hybrid_type; }

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

/* 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) {}
};


/* Base class for operations like '+', '-', '*' */
class Item_num_op :public Item_func_numhybrid
{
 public:
 Item_num_op(Item *a,Item *b) :Item_func_numhybrid(a, b) {}

 virtual inline void print(String *str, enum_query_type query_type)
 {
 print_op(str, query_type);
 }
};


class Item_int_func :public Item_func
{
public:
 Item_int_func() :Item_func()
 { collation.set_numeric(); fix_char_length(21); }
 Item_int_func(Item *a) :Item_func(a)
 { collation.set_numeric(); fix_char_length(21); }
 Item_int_func(Item *a,Item *b) :Item_func(a,b)
 { collation.set_numeric(); fix_char_length(21); }
 Item_int_func(Item *a,Item *b,Item *c) :Item_func(a,b,c)
 { collation.set_numeric(); fix_char_length(21); }
 Item_int_func(List<Item> &list) :Item_func(list)
 { collation.set_numeric(); fix_char_length(21); }
 Item_int_func(THD *thd, Item_int_func *item) :Item_func(thd, item)
 { collation.set_numeric(); }
 double val_real();
 String *val_str(String*str);
 enum Item_result result_type () const { return INT_RESULT; }
};


class Item_func_connection_id :public Item_int_func
{
 longlong value;

public:
 Item_func_connection_id() {}
 const char *func_name() const { return "connection_id"; }
 longlong val_int() { DBUG_ASSERT(fixed == 1); return value; }
};


class Item_func_signed :public Item_int_func
{
public:
 Item_func_signed(Item *a) :Item_int_func(a) 
 {
 unsigned_flag= 0;
 }
 const char *func_name() const { return "cast_as_signed"; }
 longlong val_int();

 virtual void print(String *str, enum_query_type query_type);
 uint decimal_precision() const { return args[0]->decimal_precision(); }
};


class Item_func_unsigned :public Item_func_signed
{
public:
 Item_func_unsigned(Item *a) :Item_func_signed(a)
 {
 unsigned_flag= 1;
 }
 const char *func_name() const { return "cast_as_unsigned"; }
 longlong val_int();
 virtual void print(String *str, enum_query_type query_type);
};


class Item_decimal_typecast :public Item_func
{
 my_decimal decimal_value;
public:
 Item_decimal_typecast(Item *a, int len, int dec) :Item_func(a)
 {
 decimals= dec;
 collation.set_numeric();
 fix_char_length(my_decimal_precision_to_length_no_truncation(len, dec,
 unsigned_flag));
 }
 String *val_str(String *str);
 double val_real();
 longlong val_int();
 my_decimal *val_decimal(my_decimal*);
 enum Item_result result_type () const { return DECIMAL_RESULT; }
 enum_field_types field_type() const { return MYSQL_TYPE_NEWDECIMAL; }
 const char *func_name() const { return "decimal_typecast"; }
 virtual void print(String *str, enum_query_type query_type);
};


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();
 bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
};


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 "+"; }
};

class Item_func_minus :public Item_func_additive_op
{
public:
 Item_func_minus(Item *a,Item *b) :Item_func_additive_op(a,b) {}
 const char *func_name() const { return "-"; }
};


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 "*"; }
 bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
};


class Item_func_div :public Item_num_op
{
public:
 uint prec_increment;
 Item_func_div(Item *a,Item *b) :Item_num_op(a,b) {}
 longlong int_op() { DBUG_ASSERT(0); return 0; }
 const char *func_name() const { return "/"; }
};


class Item_func_int_div :public Item_int_func
{
public:
 Item_func_int_div(Item *a,Item *b) :Item_int_func(a,b)
 {}
 longlong val_int();
 const char *func_name() const { return "DIV"; }

 virtual inline void print(String *str, enum_query_type query_type)
 {
 print_op(str, query_type);
 }

 bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
};


class Item_func_mod :public Item_num_op
{
public:
 Item_func_mod(Item *a,Item *b) :Item_num_op(a,b) {}
 const char *func_name() const { return "%"; }
 bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
};


class Item_func_neg :public Item_func_num1
{
public:
 Item_func_neg(Item *a) :Item_func_num1(a) {}
 const char *func_name() const { return "-"; }
 enum Functype functype() const { return NEG_FUNC; }
 uint decimal_precision() const { return args[0]->decimal_precision(); }
 bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
};


class Item_func_abs :public Item_func_num1
{
public:
 Item_func_abs(Item *a) :Item_func_num1(a) {}
 const char *func_name() const { return "abs"; }
 bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
};

// A class to handle logarithmic and trigonometric functions

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) {}
};

class Item_func_exp :public Item_dec_func
{
public:
 Item_func_exp(Item *a) :Item_dec_func(a) {}
 double val_real();
 const char *func_name() const { return "exp"; }
};


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


class Item_func_log :public Item_dec_func
{
public:
 Item_func_log(Item *a) :Item_dec_func(a) {}
 Item_func_log(Item *a,Item *b) :Item_dec_func(a,b) {}
 double val_real();
 const char *func_name() const { return "log"; }
};


class Item_func_log2 :public Item_dec_func
{
public:
 Item_func_log2(Item *a) :Item_dec_func(a) {}
 double val_real();
 const char *func_name() const { return "log2"; }
};


class Item_func_log10 :public Item_dec_func
{
public:
 Item_func_log10(Item *a) :Item_dec_func(a) {}
 double val_real();
 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) {}
 double val_real();
 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) {}
 double val_real();
 const char *func_name() const { return "pow"; }
};


class Item_func_acos :public Item_dec_func
{
public:
 Item_func_acos(Item *a) :Item_dec_func(a) {}
 double val_real();
 const char *func_name() const { return "acos"; }
};

class Item_func_asin :public Item_dec_func
{
public:
 Item_func_asin(Item *a) :Item_dec_func(a) {}
 double val_real();
 const char *func_name() const { return "asin"; }
};

class Item_func_atan :public Item_dec_func
{
public:
 Item_func_atan(Item *a) :Item_dec_func(a) {}
 Item_func_atan(Item *a,Item *b) :Item_dec_func(a,b) {}
 double val_real();
 const char *func_name() const { return "atan"; }
};

class Item_func_cos :public Item_dec_func
{
public:
 Item_func_cos(Item *a) :Item_dec_func(a) {}
 double val_real();
 const char *func_name() const { return "cos"; }
};

class Item_func_sin :public Item_dec_func
{
public:
 Item_func_sin(Item *a) :Item_dec_func(a) {}
 double val_real();
 const char *func_name() const { return "sin"; }
};

class Item_func_tan :public Item_dec_func
{
public:
 Item_func_tan(Item *a) :Item_dec_func(a) {}
 double val_real();
 const char *func_name() const { return "tan"; }
};

class Item_func_cot :public Item_dec_func
{
public:
 Item_func_cot(Item *a) :Item_dec_func(a) {}
 double val_real();
 const char *func_name() const { return "cot"; }
};

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


class Item_func_int_val :public Item_func_num1
{
public:
 Item_func_int_val(Item *a) :Item_func_num1(a) {}
};


class Item_func_ceiling :public Item_func_int_val
{
public:
 Item_func_ceiling(Item *a) :Item_func_int_val(a) {}
 const char *func_name() const { return "ceiling"; }
 bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
};


class Item_func_floor :public Item_func_int_val
{
public:
 Item_func_floor(Item *a) :Item_func_int_val(a) {}
 const char *func_name() const { return "floor"; }
 bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
};

/* This handles round and truncate */

class Item_func_round :public Item_func_num1
{
 bool truncate;
public:
 Item_func_round(Item *a, Item *b, bool trunc_arg)
 :Item_func_num1(a,b), truncate(trunc_arg) {}
 const char *func_name() const { return truncate ? "truncate" : "round"; }
};


class Item_func_rand :public Item_real_func
{
 struct rand_struct *rand;
 bool first_eval; // TRUE if val_real() is called 1st time
public:
 Item_func_rand(Item *a) :Item_real_func(a), rand(0), first_eval(TRUE) {}
 Item_func_rand()	 :Item_real_func() {}
 double val_real() {return 0.0;}
 const char *func_name() const { return "rand"; }
 bool const_item() const { return 0; }
 /**
 This function is non-deterministic and hence depends on the
 'RAND' pseudo-table.

 @retval RAND_TABLE_BIT
 */
 table_map get_initial_pseudo_tables() const { return RAND_TABLE_BIT; }
private:
 void seed_random (Item * val);
};


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() {return 0;}
};


class Item_func_units :public Item_real_func
{
 char *name;
 double mul,add;
public:
 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) {}
 double val_real() {return 0.0;}
 const char *func_name() const { return name; }
};


class Item_func_min_max :public Item_func
{
 Item_result cmp_type;
 String tmp_value;
 int cmp_sign;
 /* 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;
protected:
 enum_field_types cached_field_type;
public:
 Item_func_min_max(List<Item> &list,int cmp_sign_arg) :Item_func(list),
 cmp_type(INT_RESULT), cmp_sign(cmp_sign_arg), compare_as_dates(FALSE),
 datetime_item(0) {}
 double val_real() {return 0.0;}
 longlong val_int() {return 0;}
 String *val_str(String *) {return NULL;}
 my_decimal *val_decimal(my_decimal *) {return NULL;}
 enum Item_result result_type () const
 {
 /*
 If we compare as dates, then:
 - field_type is MYSQL_TYPE_VARSTRING, MYSQL_TYPE_DATETIME
 or MYSQL_TYPE_DATE.
 - cmp_type is INT_RESULT or DECIMAL_RESULT,
 depending on the amount of fractional digits.
 We need to return STRING_RESULT in this case instead of cmp_type.
 */
 return compare_as_dates ? STRING_RESULT : cmp_type;
 }
 enum Item_result cast_to_int_type () const
 {
 /*
 make CAST(LEAST_OR_GREATEST(datetime_expr, varchar_expr))
 return a number in format "YYYMMDDhhmmss".
 */
 return compare_as_dates ? INT_RESULT : result_type();
 }
 enum_field_types field_type() const { return cached_field_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"; }
};


/* 
 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)
 {
 item_name= a->item_name;
 }
 double val_real() { return args[0]->val_real(); }
 longlong val_int() { return args[0]->val_int(); }
 String *val_str(String *str) { return args[0]->val_str(str); }
 my_decimal *val_decimal(my_decimal *dec) { return args[0]->val_decimal(dec); }

 const char *func_name() const { return "rollup_const"; }
 bool const_item() const { return 0; }
 Item_result result_type() const { return args[0]->result_type(); }
 enum_field_types field_type() const { return args[0]->field_type(); }
};


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

class Item_func_bit_length :public Item_func_length
{
public:
 Item_func_bit_length(Item *a) :Item_func_length(a) {}
 longlong val_int()
 { DBUG_ASSERT(fixed == 1); return Item_func_length::val_int()*8; }
 const char *func_name() const { return "bit_length"; }
};

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() {return 0;}
 const char *func_name() const { return "char_length"; }
};

class Item_func_coercibility :public Item_int_func
{
public:
 Item_func_coercibility(Item *a) :Item_int_func(a) {}
 longlong val_int() {return 0;}
 const char *func_name() const { return "coercibility"; }
 table_map not_null_tables() const { return 0; }
};

class Item_func_locate :public Item_int_func
{
 String value1,value2;
 DTCollation cmp_collation;
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() {return 0;}
 virtual void print(String *str, enum_query_type query_type);
};


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


class Item_func_field :public Item_int_func
{
 String value,tmp;
 Item_result cmp_type;
 DTCollation cmp_collation;
public:
 Item_func_field(List<Item> &list) :Item_int_func(list) {}
 longlong val_int() {return 0;}
 const char *func_name() const { return "field"; }
};


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

class Item_func_ord :public Item_int_func
{
 String value;
public:
 Item_func_ord(Item *a) :Item_int_func(a) {}
 longlong val_int() {return 0;}
 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;
 DTCollation cmp_collation;
public:
 Item_func_find_in_set(Item *a,Item *b) :Item_int_func(a,b),enum_value(0) {}
 longlong val_int() {return 0;}
 const char *func_name() const { return "find_in_set"; }
};

/* Base class for all bit functions: '~', '|', '^', '&', '>>', '<<' */

class Item_func_bit: public Item_int_func
{
public:
 Item_func_bit(Item *a, Item *b) :Item_int_func(a, b) {}
 Item_func_bit(Item *a) :Item_int_func(a) {}

 virtual longlong val_int() {return 0;}

 virtual inline void print(String *str, enum_query_type query_type)
 {
 print_op(str, query_type);
 }
};

class Item_func_bit_or :public Item_func_bit
{
public:
 Item_func_bit_or(Item *a, Item *b) :Item_func_bit(a, b) {}
 const char *func_name() const { return "|"; }
};

class Item_func_bit_and :public Item_func_bit
{
public:
 Item_func_bit_and(Item *a, Item *b) :Item_func_bit(a, b) {}
 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() {return 0;}
 const char *func_name() const { return "bit_count"; }
};

class Item_func_shift_left :public Item_func_bit
{
public:
 Item_func_shift_left(Item *a, Item *b) :Item_func_bit(a, b) {}
 longlong val_int();
 const char *func_name() const { return "<<"; }
};

class Item_func_shift_right :public Item_func_bit
{
public:
 Item_func_shift_right(Item *a, Item *b) :Item_func_bit(a, b) {}
 longlong val_int();
 const char *func_name() const { return ">>"; }
};

class Item_func_bit_neg :public Item_func_bit
{
public:
 Item_func_bit_neg(Item *a) :Item_func_bit(a) {}
 longlong val_int();
 const char *func_name() const { return "~"; }

 virtual inline void print(String *str, enum_query_type query_type)
 {
 Item_func::print(str, query_type);
 }
};


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


class Item_func_benchmark :public Item_int_func
{
public:
 Item_func_benchmark(Item *count_expr, Item *expr)
 :Item_int_func(count_expr, expr)
 {}
 longlong val_int();
 const char *func_name() const { return "benchmark"; }
 virtual void print(String *str, enum_query_type query_type);
};


void item_func_sleep_init(void);
void item_func_sleep_free(void);

class Item_func_sleep :public Item_int_func
{
public:
 Item_func_sleep(Item *a) :Item_int_func(a) {}
 bool const_item() const { return 0; }
 const char *func_name() const { return "sleep"; }
 /**
 This function is non-deterministic and hence depends on the
 'RAND' pseudo-table.

 @retval RAND_TABLE_BIT
 */
 table_map get_initial_pseudo_tables() const { return RAND_TABLE_BIT; }
 longlong val_int();
};



#ifdef HAVE_DLOPEN

class Item_udf_func :public Item_func
{
protected:
 udf_handler udf;
 bool is_expensive_processor(uchar *arg) { return TRUE; }

public:
 Item_udf_func(udf_func *udf_arg)
 :Item_func(), udf(udf_arg) {}
 Item_udf_func(udf_func *udf_arg, List<Item> &list)
 :Item_func(list), udf(udf_arg) {}
 const char *func_name() const { return udf.name(); }
 enum Functype functype() const { return UDF_FUNC; }
 Item_result result_type () const { return udf.result_type(); }
 table_map not_null_tables() const { return 0; }
 bool is_expensive() { return 1; }
 virtual void print(String *str, enum_query_type query_type);
};


class Item_func_udf_float :public Item_udf_func
{
 public:
 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) {}
 longlong val_int()
 {
 DBUG_ASSERT(fixed == 1);
 return (longlong) rint(Item_func_udf_float::val_real());
 }
 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;
 }
 double val_real();
 String *val_str(String *str);
};


class Item_func_udf_int :public Item_udf_func
{
public:
 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) {}
 longlong val_int();
 double val_real() { return (double) Item_func_udf_int::val_int(); }
 String *val_str(String *str);
 enum Item_result result_type () const { return INT_RESULT; }
};


class Item_func_udf_decimal :public Item_udf_func
{
public:
 Item_func_udf_decimal(udf_func *udf_arg)
 :Item_udf_func(udf_arg) {}
 Item_func_udf_decimal(udf_func *udf_arg, List<Item> &list)
 :Item_udf_func(udf_arg, list) {}
 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; }
};


class Item_func_udf_str :public Item_udf_func
{
public:
 Item_func_udf_str(udf_func *udf_arg)
 :Item_udf_func(udf_arg) {}
 Item_func_udf_str(udf_func *udf_arg, List<Item> &list)
 :Item_udf_func(udf_arg, list) {}
 String *val_str(String *) {return NULL;}
 double val_real()
 {
 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;
 }
 longlong val_int()
 {
 int err_not_used;
 String *res; res=val_str(&str_value);
 return res ? my_strntoll(res->charset(),res->ptr(),res->length(),10,
 (char**) 0, &err_not_used) : (longlong) 0;
 }
 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;
 }
 enum Item_result result_type () const { return STRING_RESULT; }
};

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


class Item_func_udf_float :public Item_real_func
{
 public:
 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) {}
 double val_real() { DBUG_ASSERT(fixed == 1); return 0.0; }
};


class Item_func_udf_int :public Item_int_func
{
public:
 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) {}
 longlong val_int() { DBUG_ASSERT(fixed == 1); return 0; }
};


class Item_func_udf_decimal :public Item_int_func
{
public:
 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) {}
 my_decimal *val_decimal(my_decimal *) { DBUG_ASSERT(fixed == 1); return 0; }
};


class Item_func_udf_str :public Item_func
{
public:
 Item_func_udf_str(udf_func *udf_arg)
 :Item_func() {}
 Item_func_udf_str(udf_func *udf_arg, List<Item> &list)
 :Item_func(list) {}
 String *val_str(String *)
 { DBUG_ASSERT(fixed == 1); null_value=1; return 0; }
 double val_real() { DBUG_ASSERT(fixed == 1); null_value= 1; return 0.0; }
 longlong val_int() { DBUG_ASSERT(fixed == 1); null_value=1; return 0; }
 enum Item_result result_type () const { return STRING_RESULT; }
 void fix_length_and_dec() { maybe_null=1; max_length=0; }
};

#endif /* HAVE_DLOPEN */

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"; }
};

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

/* replication functions */

class Item_master_pos_wait :public Item_int_func
{
 String value;
public:
 Item_master_pos_wait(Item *a,Item *b) :Item_int_func(a,b) {}
 Item_master_pos_wait(Item *a,Item *b,Item *c) :Item_int_func(a,b,c) {}
 longlong val_int();
 const char *func_name() const { return "master_pos_wait"; }
};

class Item_master_gtid_set_wait :public Item_int_func
{
 String value;
public:
 Item_master_gtid_set_wait(Item *a) :Item_int_func(a) {}
 Item_master_gtid_set_wait(Item *a, Item *b) :Item_int_func(a,b) {}
 longlong val_int();
 const char *func_name() const { return "wait_until_sql_thread_after_gtids"; }
};

class Item_func_gtid_subset : public Item_int_func
{
 String buf1;
 String buf2;
public:
 Item_func_gtid_subset(Item *a, Item *b) : Item_int_func(a, b) {}
 longlong val_int();
 const char *func_name() const { return "gtid_subset"; }
};


/**
 Common class for:
 Item_func_get_system_var
 Item_func_get_user_var
 Item_func_set_user_var
*/
class Item_var_func :public Item_func
{
public:
 Item_var_func() :Item_func() { }
 Item_var_func(THD *thd, Item_var_func *item) :Item_func(thd, item) { }
 Item_var_func(Item *a) :Item_func(a) { }
};


/* Handling of user definable variables */

class user_var_entry;

class Item_func_set_user_var :public Item_var_func
{
 enum Item_result cached_result_type;
 user_var_entry *entry;
 /*
 The entry_thread_id variable is used:
 1) to skip unnecessary updates of the entry field (see above);
 2) to reset the entry field that was initialized in the other thread
 (for example, an item tree of a trigger that updates user variables
 may be shared between several connections, and the entry_thread_id field
 prevents updates of one connection user variables from a concurrent
 connection calling the same trigger that initially updated some
 user variable it the first connection context).
 */
 my_thread_id entry_thread_id;
 /**
 Delayed setting of non-constness.

 Normally, Item_func_get_user_var objects are tagged as not const
 when Item_func_set_user_var::fix_fields() is called for the same
 variable in the same query. If delayed_non_constness is set, the
 tagging is delayed until the variable is actually set. This means
 that Item_func_get_user_var objects will still be treated as a
 constant by the optimizer and executor until the variable is
 actually changed.

 @see select_dumpvar::send_data().
 */
 bool delayed_non_constness;
 char buffer[MAX_FIELD_WIDTH];
 String value;
 my_decimal decimal_buff;
 bool null_item;
 union
 {
 longlong vint;
 double vreal;
 String *vstr;
 my_decimal *vdec;
 } save_result;

public:
 Name_string name; // keep it public
 Item_func_set_user_var(Name_string a, Item *b, bool delayed)
 :Item_var_func(b), cached_result_type(INT_RESULT),
 entry(NULL), entry_thread_id(0), delayed_non_constness(delayed), name(a)
 {}
 Item_func_set_user_var(THD *thd, Item_func_set_user_var *item)
 :Item_var_func(thd, item), cached_result_type(item->cached_result_type),
 entry(item->entry), entry_thread_id(item->entry_thread_id),
 delayed_non_constness(item->delayed_non_constness), value(item->value),
 decimal_buff(item->decimal_buff), null_item(item->null_item),
 save_result(item->save_result), name(item->name)
 {}
 enum Functype functype() const { return SUSERVAR_FUNC; }
 double val_real() {return 0.0;}
 longlong val_int() {return 0;}
 String *val_str(String *str) {return NULL;}
 my_decimal *val_decimal(my_decimal *) {return NULL;}
 enum Item_result result_type () const { return cached_result_type; }
 virtual void print(String *str, enum_query_type query_type);
 void print_assignment(String *str, enum_query_type query_type);
 const char *func_name() const { return "set_user_var"; }
};


class Item_func_get_user_var :public Item_var_func,
 private Settable_routine_parameter
{
 user_var_entry *var_entry;
 Item_result m_cached_result_type;

public:
 Name_string name; // keep it public
 Item_func_get_user_var(Name_string a):
 Item_var_func(), m_cached_result_type(STRING_RESULT), name(a) {}
 enum Functype functype() const { return GUSERVAR_FUNC; }
 double val_real();
 longlong val_int();
 my_decimal *val_decimal(my_decimal*);
 String *val_str(String* str);
 virtual void print(String *str, enum_query_type query_type);
 enum Item_result result_type() const;
 /*
 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)
 */
 const char *func_name() const { return "get_user_var"; }
 bool const_item() const;
 table_map used_tables() const
 { return const_item() ? 0 : RAND_TABLE_BIT; }
private:
 bool set_value(THD *thd, sp_rcontext *ctx, Item **it);

public:
 Settable_routine_parameter *get_settable_routine_parameter()
 {
 return this;
 }
};


/*
 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
{
 Name_string name;
 user_var_entry *entry;
public:
 Item_user_var_as_out_param(Name_string a) :name(a)
 { item_name.copy(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);

 virtual void print(String *str, enum_query_type query_type);
 void set_null_value(const CHARSET_INFO* cs);
 void set_value(const char *str, uint length, const CHARSET_INFO* cs);
};


/* A system variable */

#define GET_SYS_VAR_CACHE_LONG 1
#define GET_SYS_VAR_CACHE_DOUBLE 2
#define GET_SYS_VAR_CACHE_STRING 4

class Item_func_get_system_var :public Item_var_func
{
 sys_var *var;
 enum_var_type var_type, orig_var_type;
 LEX_STRING component;
 longlong cached_llval;
 double cached_dval;
 String cached_strval;
 my_bool cached_null_value;
 query_id_t used_query_id;
 uchar cache_present;

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);
 enum Functype functype() const { return GSYSVAR_FUNC; }
 void print(String *str, enum_query_type query_type);
 bool const_item() const { return true; }
 table_map used_tables() const { return 0; }
 enum Item_result result_type() const;
 enum_field_types field_type() const;
 double val_real();
 longlong val_int();
 String* val_str(String*);
 my_decimal *val_decimal(my_decimal *dec_buf)
 { return val_decimal_from_real(dec_buf); }
 /* TODO: fix to support views */
 const char *func_name() const { return "get_system_var"; }
};


/* for fulltext search */
#include <ft_global.h>

class Item_func_match :public Item_real_func
{
public:
 uint key, flags;
 bool join_key;
 DTCollation cmp_collation;
 FT_INFO *ft_handler;
 Item_func_match *master; // for master-slave optimization
 Item *concat_ws; // Item_func_concat_ws
 String value; // value of concat_ws
 String search_value; // key_item()'s value converted to cmp_collation

 Item_func_match(List<Item> &a, uint b): Item_real_func(a), key(0), flags(b),
 join_key(0), ft_handler(0), master(0), concat_ws(0) { }
 enum Functype functype() const { return FT_FUNC; }
 const char *func_name() const { return "match"; }
 table_map not_null_tables() const { return 0; }
 /* The following should be safe, even if we compare doubles */
 longlong val_int() { DBUG_ASSERT(fixed == 1); return val_real() != 0.0; }
 double val_real();
 virtual void print(String *str, enum_query_type query_type);

 bool fix_index();
 void init_search(bool no_order);

};

/**
 Item_func class used to fetch document ID from FTS result. This
 class is used to replace Item_field objects in order to fetch
 document ID from FTS result instead of table.
 */
class Item_func_docid : public Item_int_func
{
 FT_INFO_EXT *ft_handler;
public:
 Item_func_docid(FT_INFO_EXT *handler) : ft_handler(handler) 
 { 
 max_length= 21;
 maybe_null= false; 
 unsigned_flag= true;
 } 

 const char *func_name() const { return "docid"; }

 longlong val_int() 
 { 
 DBUG_ASSERT(ft_handler);
 return ft_handler->could_you->get_docid(ft_handler);
 }
};

class Item_func_bit_xor : public Item_func_bit
{
public:
 Item_func_bit_xor(Item *a, Item *b) :Item_func_bit(a, b) {}
 longlong val_int();
 const char *func_name() const { return "^"; }
};

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

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"; }
};

/* For type casts */

enum Cast_target
{
 ITEM_CAST_BINARY, ITEM_CAST_SIGNED_INT, ITEM_CAST_UNSIGNED_INT,
 ITEM_CAST_DATE, ITEM_CAST_TIME, ITEM_CAST_DATETIME, ITEM_CAST_CHAR,
 ITEM_CAST_DECIMAL
};


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"; }
};


/*
 *
 * Stored FUNCTIONs
 *
 */

class sp_head;
class sp_name;
struct st_sp_security_context;

class Item_func_sp :public Item_func
{
private:
 Name_resolution_context *context;
 sp_name *m_name;
 mutable sp_head *m_sp;
 uchar result_buf[64];
 
protected:
 bool is_expensive_processor(uchar *arg) { return TRUE; }

public:

 Item_func_sp(Name_resolution_context *context_arg, sp_name *name);

 Item_func_sp(Name_resolution_context *context_arg,
 sp_name *name, List<Item> &list);

 virtual ~Item_func_sp()
 {}

 /**
 Must not be called before the procedure is resolved,
 i.e. ::init_result_field().
 */
 table_map get_initial_pseudo_tables() const;

 const char *func_name() const;

 enum enum_field_types field_type() const {return MYSQL_TYPE_NULL;}

 Item_result result_type() const {return INT_RESULT;}

 longlong val_int()
 {
 return (longlong) 0;
 }

 double val_real()
 {
 return 0.0;
 }

 my_decimal *val_decimal(my_decimal *dec_buf)
 {
 return NULL;
 }

 String *val_str(String *str)
 {
 return NULL;
 } virtual bool change_context_processor(uchar *cntx)
 { context= (Name_resolution_context *)cntx; return FALSE; }

 virtual enum Functype functype() const { return FUNC_SP; }

 bool is_expensive() { return 1; }
};


class Item_func_found_rows :public Item_int_func
{
public:
 Item_func_found_rows() :Item_int_func() {}
 longlong val_int() {return 0;}
 const char *func_name() const { return "found_rows"; }
};


void uuid_short_init();

class Item_func_uuid_short :public Item_int_func
{
public:
 Item_func_uuid_short() :Item_int_func() {}
 const char *func_name() const { return "uuid_short"; }
 longlong val_int();
 bool check_partition_func_processor(uchar *int_arg) {return FALSE;}
};

Item *get_system_var(THD *thd, enum_var_type var_type, LEX_STRING name,
 LEX_STRING component);
extern bool check_reserved_words(LEX_STRING *name);
extern enum_field_types agg_field_type(Item **items, uint nitems);
double my_double_round(double value, longlong dec, bool dec_unsigned,
 bool truncate);
bool eval_const_cond(Item *cond);

extern bool volatile mqh_used;

#endif /* ITEM_FUNC_INCLUDED */