Adding upstream version 1:10.5.12.upstream/1%10.5.12upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3792 insertions, 0 deletions

diff --git a/sql/item_func.h b/sql/item_func.h
new file mode 100644
index 00000000..a7dbb9ab
--- /dev/null
+++ b/sql/item_func.h
@@ -0,0 +1,3792 @@
+#ifndef ITEM_FUNC_INCLUDED
+#define ITEM_FUNC_INCLUDED
+/* Copyright (c) 2000, 2016, Oracle and/or its affiliates.
+   Copyright (c) 2009, 2020, MariaDB
+
+   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 Street, Fifth Floor, Boston, MA  02110-1335  USA */
+
+
+/* Function items used by mysql */
+
+#ifdef USE_PRAGMA_INTERFACE
+#pragma interface			/* gcc class implementation */
+#endif
+
+#ifdef HAVE_IEEEFP_H
+extern "C"				/* Bug in BSDI include file */
+{
+#include <ieeefp.h>
+}
+#endif
+
+#include "sql_udf.h"    // udf_handler
+#include "my_decimal.h" // string2my_decimal
+#include <cmath>
+
+
+class Item_func :public Item_func_or_sum,
+                 protected With_sum_func_cache
+{
+  void sync_with_sum_func_and_with_field(List<Item> &list);
+protected:
+  virtual bool check_arguments() const
+  {
+    return check_argument_types_scalar(0, arg_count);
+  }
+  bool check_argument_types_like_args0() const;
+  bool check_argument_types_scalar(uint start, uint end) const;
+  bool check_argument_types_traditional_scalar(uint start, uint end) const;
+  bool check_argument_types_or_binary(const Type_handler *handler,
+                                      uint start, uint end) const;
+  bool check_argument_types_can_return_int(uint start, uint end) const;
+  bool check_argument_types_can_return_real(uint start, uint end) const;
+  bool check_argument_types_can_return_str(uint start, uint end) const;
+  bool check_argument_types_can_return_text(uint start, uint end) const;
+  bool check_argument_types_can_return_date(uint start, uint end) const;
+  bool check_argument_types_can_return_time(uint start, uint end) const;
+  void print_cast_temporal(String *str, enum_query_type query_type);
+public:
+
+  table_map not_null_tables_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, SP_RELATE_FUNC,
+                  NOT_FUNC, NOT_ALL_FUNC, TEMPTABLE_ROWID,
+                  NOW_FUNC, NOW_UTC_FUNC, SYSDATE_FUNC, TRIG_COND_FUNC,
+                  SUSERVAR_FUNC, GUSERVAR_FUNC, COLLATE_FUNC,
+                  EXTRACT_FUNC, CHAR_TYPECAST_FUNC, FUNC_SP, UDF_FUNC,
+                  NEG_FUNC, GSYSVAR_FUNC, IN_OPTIMIZER_FUNC, DYNCOL_FUNC,
+                  JSON_EXTRACT_FUNC, JSON_VALID_FUNC,
+                  CASE_SEARCHED_FUNC, // Used by ColumnStore/Spider
+                  CASE_SIMPLE_FUNC    // Used by ColumnStore/spider
+                };
+  static scalar_comparison_op functype_to_scalar_comparison_op(Functype type)
+  {
+    switch (type) {
+    case EQ_FUNC:    return SCALAR_CMP_EQ;
+    case EQUAL_FUNC: return SCALAR_CMP_EQUAL;
+    case LT_FUNC:    return SCALAR_CMP_LT;
+    case LE_FUNC:    return SCALAR_CMP_LE;
+    case GE_FUNC:    return SCALAR_CMP_GE;
+    case GT_FUNC:    return SCALAR_CMP_GT;
+    default: break;
+    }
+    DBUG_ASSERT(0);
+    return SCALAR_CMP_EQ;
+  }
+  enum Type type() const { return FUNC_ITEM; }
+  virtual enum Functype functype() const   { return UNKNOWN_FUNC; }
+  Item_func(THD *thd): Item_func_or_sum(thd)
+  {
+    with_field= 0;
+    with_param= 0;
+  }
+  Item_func(THD *thd, Item *a)
+   :Item_func_or_sum(thd, a), With_sum_func_cache(a)
+  {
+    with_param= a->with_param;
+    with_field= a->with_field;
+  }
+  Item_func(THD *thd, Item *a, Item *b)
+   :Item_func_or_sum(thd, a, b), With_sum_func_cache(a, b)
+  {
+    with_param= a->with_param || b->with_param;
+    with_field= a->with_field || b->with_field;
+  }
+  Item_func(THD *thd, Item *a, Item *b, Item *c)
+   :Item_func_or_sum(thd, a, b, c), With_sum_func_cache(a, b, c)
+  {
+    with_field= a->with_field || b->with_field || c->with_field;
+    with_param= a->with_param || b->with_param || c->with_param;
+  }
+  Item_func(THD *thd, Item *a, Item *b, Item *c, Item *d)
+   :Item_func_or_sum(thd, a, b, c, d), With_sum_func_cache(a, b, c, d)
+  {
+    with_field= a->with_field || b->with_field ||
+                c->with_field || d->with_field;
+    with_param= a->with_param || b->with_param ||
+                c->with_param || d->with_param;
+  }
+  Item_func(THD *thd, Item *a, Item *b, Item *c, Item *d, Item* e)
+   :Item_func_or_sum(thd, a, b, c, d, e), With_sum_func_cache(a, b, c, d, e)
+  {
+    with_field= a->with_field || b->with_field ||
+                c->with_field || d->with_field || e->with_field;
+    with_param= a->with_param || b->with_param ||
+                c->with_param || d->with_param || e->with_param;
+  }
+  Item_func(THD *thd, List<Item> &list):
+    Item_func_or_sum(thd, list)
+  {
+    set_arguments(thd, list);
+  }
+  // Constructor used for Item_cond_and/or (see Item comment)
+  Item_func(THD *thd, Item_func *item)
+   :Item_func_or_sum(thd, item), With_sum_func_cache(item),
+    not_null_tables_cache(item->not_null_tables_cache)
+  { }
+  bool fix_fields(THD *, Item **ref);
+  void cleanup()
+  {
+    Item_func_or_sum::cleanup();
+    used_tables_and_const_cache_init();
+  }
+  void fix_after_pullout(st_select_lex *new_parent, Item **ref, bool merge);
+  void quick_fix_field();
+  table_map not_null_tables() const;
+  void update_used_tables()
+  {
+    used_tables_and_const_cache_init();
+    used_tables_and_const_cache_update_and_join(arg_count, args);
+  }
+  COND *build_equal_items(THD *thd, COND_EQUAL *inherited,
+                          bool link_item_fields,
+                          COND_EQUAL **cond_equal_ref);
+  SEL_TREE *get_mm_tree(RANGE_OPT_PARAM *param, Item **cond_ptr)
+  {
+    DBUG_ENTER("Item_func::get_mm_tree");
+    DBUG_RETURN(const_item() ? get_mm_tree_for_const(param) : NULL);
+  }
+  bool eq(const Item *item, bool binary_cmp) const;
+  virtual Item *key_item() const { return args[0]; }
+  void set_arguments(THD *thd, List<Item> &list)
+  {
+    Item_args::set_arguments(thd, list);
+    sync_with_sum_func_and_with_field(list);
+    list.empty();                                     // Fields are used
+  }
+  void split_sum_func(THD *thd, Ref_ptr_array ref_pointer_array,
+                      List<Item> &fields, uint flags);
+  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() { 
+    update_null_value();
+    return null_value; 
+  }
+  String *val_str_from_val_str_ascii(String *str, String *str2);
+
+  void signal_divide_by_null();
+  friend class udf_handler;
+  Field *create_field_for_create_select(MEM_ROOT *root, TABLE *table)
+  { return tmp_table_field_from_field_type(root, table); }
+  Item *get_tmp_table_item(THD *thd);
+
+  void fix_char_length_ulonglong(ulonglong max_char_length_arg)
+  {
+    ulonglong max_result_length= max_char_length_arg *
+                                 collation.collation->mbmaxlen;
+    if (max_result_length >= MAX_BLOB_WIDTH)
+    {
+      max_length= MAX_BLOB_WIDTH;
+      maybe_null= 1;
+    }
+    else
+      max_length= (uint32) max_result_length;
+  }
+  Item *transform(THD *thd, Item_transformer transformer, uchar *arg);
+  Item* compile(THD *thd, Item_analyzer analyzer, uchar **arg_p,
+                Item_transformer transformer, uchar *arg_t);
+  void traverse_cond(Cond_traverser traverser,
+                     void * arg, traverse_order order);
+  bool eval_not_null_tables(void *opt_arg);
+  bool find_not_null_fields(table_map allowed);
+ // bool is_expensive_processor(void *arg);
+ // virtual bool is_expensive() { return 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_NO_DATA_EXPANSION);
+    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 std::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;
+  }
+
+  Item* propagate_equal_fields(THD *thd, const Context &ctx, COND_EQUAL *cond)
+  {
+    /*
+      By default only substitution for a field whose two different values
+      are never equal is allowed in the arguments of a function.
+      This is overruled for the direct arguments of comparison functions.
+    */
+    Item_args::propagate_equal_fields(thd, Context_identity(), cond);
+    return this;
+  }
+
+  bool has_rand_bit()
+  {
+    return used_tables() & RAND_TABLE_BIT;
+  }
+
+  bool excl_dep_on_table(table_map tab_map)
+  {
+    if (used_tables() & OUTER_REF_TABLE_BIT)
+      return false; 
+    return !(used_tables() & ~tab_map) || 
+           Item_args::excl_dep_on_table(tab_map);
+  }
+
+  bool excl_dep_on_grouping_fields(st_select_lex *sel)
+  {
+    if (has_rand_bit() || with_subquery())
+      return false;
+    return Item_args::excl_dep_on_grouping_fields(sel);
+  }
+
+  bool excl_dep_on_in_subq_left_part(Item_in_subselect *subq_pred)
+  {
+    return Item_args::excl_dep_on_in_subq_left_part(subq_pred);
+  }
+
+  /*
+    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(void *bool_arg)
+  {
+    return has_timestamp_args();
+  }
+
+  virtual bool find_function_processor (void *arg)
+  {
+    return functype() == *(Functype *) arg;
+  }
+
+  void no_rows_in_result()
+  {
+    for (uint i= 0; i < arg_count; i++)
+    {
+      args[i]->no_rows_in_result();
+    }
+  }
+  void restore_to_before_no_rows_in_result()
+  {
+    for (uint i= 0; i < arg_count; i++)
+    {
+      args[i]->no_rows_in_result();
+    }
+  }
+  void convert_const_compared_to_int_field(THD *thd);
+  /**
+    Prepare arguments and setup a comparator.
+    Used in Item_func_xxx with two arguments and a comparator,
+    e.g. Item_bool_func2 and Item_func_nullif.
+    args[0] or args[1] can be modified:
+    - converted to character set and collation of the operation
+    - or replaced to an Item_int_with_ref
+  */
+  bool setup_args_and_comparator(THD *thd, Arg_comparator *cmp);
+
+  bool with_sum_func() const { return m_with_sum_func; }
+  With_sum_func_cache* get_with_sum_func_cache() { return this; }
+  Item_func *get_item_func() { return this; }
+  bool is_simplified_cond_processor(void *arg)
+  { return const_item() && !val_int(); }
+};
+
+
+class Item_real_func :public Item_func
+{
+public:
+  Item_real_func(THD *thd): Item_func(thd) { collation= DTCollation_numeric(); }
+  Item_real_func(THD *thd, Item *a): Item_func(thd, a)
+  { collation= DTCollation_numeric(); }
+  Item_real_func(THD *thd, Item *a, Item *b): Item_func(thd, a, b)
+  { collation= DTCollation_numeric(); }
+  Item_real_func(THD *thd, List<Item> &list): Item_func(thd, list)
+  { collation= DTCollation_numeric(); }
+  String *val_str(String*str);
+  my_decimal *val_decimal(my_decimal *decimal_value);
+  longlong val_int()
+  {
+    DBUG_ASSERT(fixed == 1);
+    return Converter_double_to_longlong(val_real(), unsigned_flag).result();
+  }
+  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+  { return get_date_from_real(thd, ltime, fuzzydate); }
+  const Type_handler *type_handler() const { return &type_handler_double; }
+  bool fix_length_and_dec()
+  {
+    decimals= NOT_FIXED_DEC;
+    max_length= float_length(decimals);
+    return FALSE;
+  }
+};
+
+
+/**
+  Functions whose returned field type is determined at fix_fields() time.
+*/
+class Item_hybrid_func: public Item_func,
+                        public Type_handler_hybrid_field_type
+{
+protected:
+  bool fix_attributes(Item **item, uint nitems);
+public:
+  Item_hybrid_func(THD *thd): Item_func(thd) { }
+  Item_hybrid_func(THD *thd, Item *a):  Item_func(thd, a) { }
+  Item_hybrid_func(THD *thd, Item *a, Item *b): Item_func(thd, a, b) { }
+  Item_hybrid_func(THD *thd, Item *a, Item *b, Item *c):
+    Item_func(thd, a, b, c) { }
+  Item_hybrid_func(THD *thd, List<Item> &list): Item_func(thd, list) { }
+  Item_hybrid_func(THD *thd, Item_hybrid_func *item)
+    :Item_func(thd, item), Type_handler_hybrid_field_type(item) { }
+  const Type_handler *type_handler() const
+  { return Type_handler_hybrid_field_type::type_handler(); }
+  void fix_length_and_dec_long_or_longlong(uint char_length, bool unsigned_arg)
+  {
+    collation= DTCollation_numeric();
+    unsigned_flag= unsigned_arg;
+    max_length= char_length;
+    set_handler(Type_handler::type_handler_long_or_longlong(char_length,
+                                                            unsigned_arg));
+  }
+  void fix_length_and_dec_ulong_or_ulonglong_by_nbits(uint nbits)
+  {
+    uint digits= Type_handler_bit::Bit_decimal_notation_int_digits_by_nbits(nbits);
+    collation= DTCollation_numeric();
+    unsigned_flag= true;
+    max_length= digits;
+    if (nbits > 32)
+      set_handler(&type_handler_ulonglong);
+    else
+      set_handler(&type_handler_ulong);
+  }
+};
+
+
+class Item_handled_func: public Item_func
+{
+public:
+  class Handler
+  {
+  public:
+    virtual ~Handler() { }
+    virtual String *val_str(Item_handled_func *, String *) const= 0;
+    virtual String *val_str_ascii(Item_handled_func *, String *) const= 0;
+    virtual double val_real(Item_handled_func *) const= 0;
+    virtual longlong val_int(Item_handled_func *) const= 0;
+    virtual my_decimal *val_decimal(Item_handled_func *, my_decimal *) const= 0;
+    virtual bool get_date(THD *thd, Item_handled_func *, MYSQL_TIME *, date_mode_t fuzzydate) const= 0;
+    virtual bool val_native(THD *thd, Item_handled_func *, Native *to) const
+    {
+      DBUG_ASSERT(0);
+      to->length(0);
+      return true;
+    }
+    virtual const Type_handler *
+      return_type_handler(const Item_handled_func *item) const= 0;
+    virtual const Type_handler *
+      type_handler_for_create_select(const Item_handled_func *item) const
+    {
+      return return_type_handler(item);
+    }
+    virtual bool fix_length_and_dec(Item_handled_func *) const= 0;
+  };
+
+  class Handler_str: public Handler
+  {
+  public:
+    String *val_str_ascii(Item_handled_func *item, String *str) const
+    {
+      return item->Item::val_str_ascii(str);
+    }
+    double val_real(Item_handled_func *item) const
+    {
+      DBUG_ASSERT(item->is_fixed());
+      StringBuffer<64> tmp;
+      String *res= item->val_str(&tmp);
+      return res ? item->double_from_string_with_check(res) : 0.0;
+    }
+    longlong val_int(Item_handled_func *item) const
+    {
+      DBUG_ASSERT(item->is_fixed());
+      StringBuffer<22> tmp;
+      String *res= item->val_str(&tmp);
+      return res ? item->longlong_from_string_with_check(res) : 0;
+    }
+    my_decimal *val_decimal(Item_handled_func *item, my_decimal *to) const
+    {
+      return item->val_decimal_from_string(to);
+    }
+    bool get_date(THD *thd, Item_handled_func *item, MYSQL_TIME *to,
+                  date_mode_t fuzzydate) const
+    {
+      return item->get_date_from_string(thd, to, fuzzydate);
+    }
+  };
+
+  /**
+    Abstract class for functions returning TIME, DATE, DATETIME or string values,
+    whose data type depends on parameters and is set at fix_fields time.
+  */
+  class Handler_temporal: public Handler
+  {
+  public:
+    String *val_str(Item_handled_func *item, String *to) const
+    {
+      StringBuffer<MAX_FIELD_WIDTH> ascii_buf;
+      return item->val_str_from_val_str_ascii(to, &ascii_buf);
+    }
+  };
+
+  /**
+    Abstract class for functions returning strings,
+    which are generated from get_date() results,
+    when get_date() can return different MYSQL_TIMESTAMP_XXX per row.
+  */
+  class Handler_temporal_string: public Handler_temporal
+  {
+  public:
+    const Type_handler *return_type_handler(const Item_handled_func *) const
+    {
+      return &type_handler_string;
+    }
+    const Type_handler *
+      type_handler_for_create_select(const Item_handled_func *item) const
+    {
+      return return_type_handler(item)->type_handler_for_tmp_table(item);
+    }
+    double val_real(Item_handled_func *item) const
+    {
+      return Temporal_hybrid(item).to_double();
+    }
+    longlong val_int(Item_handled_func *item) const
+    {
+      return Temporal_hybrid(item).to_longlong();
+    }
+    my_decimal *val_decimal(Item_handled_func *item, my_decimal *to) const
+    {
+      return Temporal_hybrid(item).to_decimal(to);
+    }
+    String *val_str_ascii(Item_handled_func *item, String *to) const
+    {
+      return Temporal_hybrid(item).to_string(to, item->decimals);
+    }
+  };
+
+
+  class Handler_date: public Handler_temporal
+  {
+  public:
+    const Type_handler *return_type_handler(const Item_handled_func *) const
+    {
+      return &type_handler_newdate;
+    }
+    bool fix_length_and_dec(Item_handled_func *item) const
+    {
+      item->fix_attributes_date();
+      return false;
+    }
+    double val_real(Item_handled_func *item) const
+    {
+      return Date(item).to_double();
+    }
+    longlong val_int(Item_handled_func *item) const
+    {
+      return Date(item).to_longlong();
+    }
+    my_decimal *val_decimal(Item_handled_func *item, my_decimal *to) const
+    {
+      return Date(item).to_decimal(to);
+    }
+    String *val_str_ascii(Item_handled_func *item, String *to) const
+    {
+      return Date(item).to_string(to);
+    }
+  };
+
+
+  class Handler_time: public Handler_temporal
+  {
+  public:
+    const Type_handler *return_type_handler(const Item_handled_func *) const
+    {
+      return &type_handler_time2;
+    }
+    double val_real(Item_handled_func *item) const
+    {
+      return Time(item).to_double();
+    }
+    longlong val_int(Item_handled_func *item) const
+    {
+      return Time(item).to_longlong();
+    }
+    my_decimal *val_decimal(Item_handled_func *item, my_decimal *to) const
+    {
+      return Time(item).to_decimal(to);
+    }
+    String *val_str_ascii(Item_handled_func *item, String *to) const
+    {
+      return Time(item).to_string(to, item->decimals);
+    }
+    bool val_native(THD *thd, Item_handled_func *item, Native *to) const
+    {
+      return Time(thd, item).to_native(to, item->decimals);
+    }
+  };
+
+
+  class Handler_datetime: public Handler_temporal
+  {
+  public:
+    const Type_handler *return_type_handler(const Item_handled_func *) const
+    {
+      return &type_handler_datetime2;
+    }
+    double val_real(Item_handled_func *item) const
+    {
+      return Datetime(item).to_double();
+    }
+    longlong val_int(Item_handled_func *item) const
+    {
+      return Datetime(item).to_longlong();
+    }
+    my_decimal *val_decimal(Item_handled_func *item, my_decimal *to) const
+    {
+      return Datetime(item).to_decimal(to);
+    }
+    String *val_str_ascii(Item_handled_func *item, String *to) const
+    {
+      return Datetime(item).to_string(to, item->decimals);
+    }
+  };
+
+
+  class Handler_int: public Handler
+  {
+  public:
+    String *val_str(Item_handled_func *item, String *to) const
+    {
+      longlong nr= val_int(item);
+      if (item->null_value)
+        return 0;
+      to->set_int(nr, item->unsigned_flag, item->collation.collation);
+      return to;
+    }
+    String *val_str_ascii(Item_handled_func *item, String *to) const
+    {
+      return item->Item::val_str_ascii(to);
+    }
+    double val_real(Item_handled_func *item) const
+    {
+      return item->unsigned_flag ? (double) ((ulonglong) val_int(item)) :
+                                   (double) val_int(item);
+    }
+    my_decimal *val_decimal(Item_handled_func *item, my_decimal *to) const
+    {
+      return item->val_decimal_from_int(to);
+    }
+    bool get_date(THD *thd, Item_handled_func *item,
+                  MYSQL_TIME *to, date_mode_t fuzzydate) const
+    {
+      return item->get_date_from_int(thd, to, fuzzydate);
+    }
+    longlong val_int(Item_handled_func *item) const
+    {
+      Longlong_null tmp= to_longlong_null(item);
+      item->null_value= tmp.is_null();
+      return tmp.value();
+    }
+    virtual Longlong_null to_longlong_null(Item_handled_func *item) const= 0;
+  };
+
+  class Handler_slong: public Handler_int
+  {
+  public:
+    const Type_handler *return_type_handler(const Item_handled_func *item) const
+    {
+      return &type_handler_slong;
+    }
+    bool fix_length_and_dec(Item_handled_func *item) const
+    {
+      item->unsigned_flag= false;
+      item->collation= DTCollation_numeric();
+      item->fix_char_length(11);
+      return false;
+    }
+  };
+
+  class Handler_slong2: public Handler_slong
+  {
+  public:
+    bool fix_length_and_dec(Item_handled_func *func) const
+    {
+      bool rc= Handler_slong::fix_length_and_dec(func);
+      func->max_length= 2;
+      return rc;
+    }
+  };
+
+  class Handler_ulonglong: public Handler_int
+  {
+  public:
+    const Type_handler *return_type_handler(const Item_handled_func *item) const
+    {
+      return &type_handler_ulonglong;
+    }
+    bool fix_length_and_dec(Item_handled_func *item) const
+    {
+      item->unsigned_flag= true;
+      item->collation= DTCollation_numeric();
+      item->fix_char_length(21);
+      return false;
+    }
+  };
+
+protected:
+  const Handler *m_func_handler;
+public:
+  Item_handled_func(THD *thd, Item *a)
+   :Item_func(thd, a), m_func_handler(NULL) { }
+  Item_handled_func(THD *thd, Item *a, Item *b)
+   :Item_func(thd, a, b), m_func_handler(NULL) { }
+  void set_func_handler(const Handler *handler)
+  {
+    m_func_handler= handler;
+  }
+  const Type_handler *type_handler() const
+  {
+    return m_func_handler->return_type_handler(this);
+  }
+  Field *create_field_for_create_select(MEM_ROOT *root, TABLE *table)
+  {
+    DBUG_ASSERT(fixed);
+    const Type_handler *h= m_func_handler->type_handler_for_create_select(this);
+    return h->make_and_init_table_field(root, &name,
+                                        Record_addr(maybe_null),
+                                        *this, table);
+  }
+  String *val_str(String *to)
+  {
+    return m_func_handler->val_str(this, to);
+  }
+  String *val_str_ascii(String *to)
+  {
+    return m_func_handler->val_str_ascii(this, to);
+  }
+  double val_real()
+  {
+    return m_func_handler->val_real(this);
+  }
+  longlong val_int()
+  {
+    return m_func_handler->val_int(this);
+  }
+  my_decimal *val_decimal(my_decimal *to)
+  {
+    return m_func_handler->val_decimal(this, to);
+  }
+  bool get_date(THD *thd, MYSQL_TIME *to, date_mode_t fuzzydate)
+  {
+    return m_func_handler->get_date(thd, this, to, fuzzydate);
+  }
+  bool val_native(THD *thd, Native *to)
+  {
+    return m_func_handler->val_native(thd, this, to);
+  }
+};
+
+
+/**
+  Functions that at fix_fields() time determine the returned field type,
+  trying to preserve the exact data type of the arguments.
+
+  The descendants have to implement "native" value methods,
+  i.e. str_op(), date_op(), int_op(), real_op(), decimal_op().
+  fix_fields() chooses which of the above value methods will be
+  used during execution time, according to the returned field type.
+
+  For example, if fix_fields() determines that the returned value type
+  is MYSQL_TYPE_LONG, then:
+  - int_op() is chosen as the execution time native method.
+  - val_int() returns the result of int_op() as is.
+  - all other methods, i.e. val_real(), val_decimal(), val_str(), get_date(),
+    call int_op() first, then convert the result to the requested data type.
+*/
+class Item_func_hybrid_field_type: public Item_hybrid_func
+{
+  /*
+    Helper methods to make sure that the result of
+    decimal_op(), str_op() and date_op() is properly synched with null_value.
+  */
+  bool date_op_with_null_check(THD *thd, MYSQL_TIME *ltime)
+  {
+     bool rc= date_op(thd, ltime, date_mode_t(0));
+     DBUG_ASSERT(!rc ^ null_value);
+     return rc;
+  }
+  bool time_op_with_null_check(THD *thd, MYSQL_TIME *ltime)
+  {
+     bool rc= time_op(thd, ltime);
+     DBUG_ASSERT(!rc ^ null_value);
+     DBUG_ASSERT(rc || ltime->time_type == MYSQL_TIMESTAMP_TIME);
+     return rc;
+  }
+  String *str_op_with_null_check(String *str)
+  {
+    String *res= str_op(str);
+    DBUG_ASSERT((res != NULL) ^ null_value);
+    return res;
+  }
+
+public:
+  // Value methods that involve no conversion
+  String *val_str_from_str_op(String *str)
+  {
+    return str_op_with_null_check(&str_value);
+  }
+  longlong val_int_from_int_op()
+  {
+    return int_op();
+  }
+  double val_real_from_real_op()
+  {
+    return real_op();
+  }
+
+  // Value methods that involve conversion
+  String *val_str_from_real_op(String *str);
+  String *val_str_from_int_op(String *str);
+  String *val_str_from_date_op(String *str);
+  String *val_str_from_time_op(String *str);
+
+  my_decimal *val_decimal_from_str_op(my_decimal *dec);
+  my_decimal *val_decimal_from_real_op(my_decimal *dec);
+  my_decimal *val_decimal_from_int_op(my_decimal *dec);
+  my_decimal *val_decimal_from_date_op(my_decimal *dec);
+  my_decimal *val_decimal_from_time_op(my_decimal *dec);
+
+  longlong val_int_from_str_op();
+  longlong val_int_from_real_op();
+  longlong val_int_from_date_op();
+  longlong val_int_from_time_op();
+
+  double val_real_from_str_op();
+  double val_real_from_date_op();
+  double val_real_from_time_op();
+  double val_real_from_int_op();
+
+public:
+  Item_func_hybrid_field_type(THD *thd):
+    Item_hybrid_func(thd)
+  { collation= DTCollation_numeric(); }
+  Item_func_hybrid_field_type(THD *thd, Item *a):
+    Item_hybrid_func(thd, a)
+  { collation= DTCollation_numeric(); }
+  Item_func_hybrid_field_type(THD *thd, Item *a, Item *b):
+    Item_hybrid_func(thd, a, b)
+  { collation= DTCollation_numeric(); }
+  Item_func_hybrid_field_type(THD *thd, Item *a, Item *b, Item *c):
+    Item_hybrid_func(thd, a, b, c)
+  { collation= DTCollation_numeric(); }
+  Item_func_hybrid_field_type(THD *thd, List<Item> &list):
+    Item_hybrid_func(thd, list)
+  { collation= DTCollation_numeric(); }
+
+  double val_real()
+  {
+    DBUG_ASSERT(fixed);
+    return Item_func_hybrid_field_type::type_handler()->
+           Item_func_hybrid_field_type_val_real(this);
+  }
+  longlong val_int()
+  {
+    DBUG_ASSERT(fixed);
+    return Item_func_hybrid_field_type::type_handler()->
+           Item_func_hybrid_field_type_val_int(this);
+  }
+  my_decimal *val_decimal(my_decimal *dec)
+  {
+    DBUG_ASSERT(fixed);
+    return Item_func_hybrid_field_type::type_handler()->
+           Item_func_hybrid_field_type_val_decimal(this, dec);
+  }
+  String *val_str(String*str)
+  {
+    DBUG_ASSERT(fixed);
+    String *res= Item_func_hybrid_field_type::type_handler()->
+                 Item_func_hybrid_field_type_val_str(this, str);
+    DBUG_ASSERT(null_value == (res == NULL));
+    return res;
+  }
+  bool get_date(THD *thd, MYSQL_TIME *to, date_mode_t mode)
+  {
+    DBUG_ASSERT(fixed);
+    return Item_func_hybrid_field_type::type_handler()->
+           Item_func_hybrid_field_type_get_date_with_warn(thd, this, to, mode);
+  }
+
+  bool val_native(THD *thd, Native *to)
+  {
+    DBUG_ASSERT(fixed);
+    return native_op(thd, to);
+  }
+
+  /**
+     @brief Performs the operation that this functions implements when the
+     result type is INT.
+
+     @return The result of the operation.
+  */
+  virtual longlong int_op()= 0;
+  Longlong_null to_longlong_null_op()
+  {
+    longlong nr= int_op();
+    /*
+      C++ does not guarantee the order of parameter evaluation,
+      so to make sure "null_value" is passed to the constructor
+      after the int_op() call, int_op() is caled on a separate line.
+    */
+    return Longlong_null(nr, null_value);
+  }
+  Longlong_hybrid_null to_longlong_hybrid_null_op()
+  {
+    return Longlong_hybrid_null(to_longlong_null_op(), unsigned_flag);
+  }
+
+  /**
+     @brief Performs the operation that this functions implements when the
+     result type is REAL.
+
+     @return The result of the operation.
+  */
+  virtual double real_op()= 0;
+  Double_null to_double_null_op()
+  {
+    // val_real() must be caleed on a separate line. See to_longlong_null()
+    double nr= real_op();
+    return Double_null(nr, null_value);
+  }
+
+  /**
+     @brief Performs the operation that this functions implements when the
+     result type is DECIMAL.
+
+     @param A pointer where the DECIMAL value will be allocated.
+     @return 
+       - 0 If the result is NULL
+       - The same pointer it was given, with the area initialized to the
+         result of the operation.
+  */
+  virtual my_decimal *decimal_op(my_decimal *)= 0;
+
+  /**
+     @brief Performs the operation that this functions implements when the
+     result type is a string type.
+
+     @return The result of the operation.
+  */
+  virtual String *str_op(String *)= 0;
+
+  /**
+     @brief Performs the operation that this functions implements when
+     field type is DATETIME or DATE.
+     @return The result of the operation.
+  */
+  virtual bool date_op(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate)= 0;
+
+  /**
+     @brief Performs the operation that this functions implements when
+     field type is TIME.
+     @return The result of the operation.
+  */
+  virtual bool time_op(THD *thd, MYSQL_TIME *res)= 0;
+
+  virtual bool native_op(THD *thd, Native *native)= 0;
+};
+
+
+/*
+  This class resembles SQL standard CASE-alike expressions:
+  CASE and its abbreviations COALESCE, NULLIF, IFNULL, IF.
+
+  <case expression> ::=   <case abbreviation>
+                        | <case specification>
+*/
+class Item_func_case_expression: public Item_func_hybrid_field_type
+{
+public:
+  Item_func_case_expression(THD *thd)
+   :Item_func_hybrid_field_type(thd)
+  { }
+  Item_func_case_expression(THD *thd, Item *a)
+   :Item_func_hybrid_field_type(thd, a)
+  { }
+  Item_func_case_expression(THD *thd, Item *a, Item *b)
+   :Item_func_hybrid_field_type(thd, a, b)
+  { }
+  Item_func_case_expression(THD *thd, Item *a, Item *b, Item *c)
+   :Item_func_hybrid_field_type(thd, a, b, c)
+  { }
+  Item_func_case_expression(THD *thd, List<Item> &list):
+    Item_func_hybrid_field_type(thd, list)
+  { }
+  bool find_not_null_fields(table_map allowed) { return false; }
+};
+
+
+class Item_func_numhybrid: public Item_func_hybrid_field_type
+{
+protected:
+
+  inline void fix_decimals()
+  {
+    DBUG_ASSERT(result_type() == DECIMAL_RESULT);
+    if (decimals == NOT_FIXED_DEC)
+      set_if_smaller(decimals, max_length - 1);
+  }
+
+public:
+  Item_func_numhybrid(THD *thd): Item_func_hybrid_field_type(thd)
+  { }
+  Item_func_numhybrid(THD *thd, Item *a): Item_func_hybrid_field_type(thd, a)
+  { }
+  Item_func_numhybrid(THD *thd, Item *a, Item *b):
+    Item_func_hybrid_field_type(thd, a, b)
+  { }
+  Item_func_numhybrid(THD *thd, Item *a, Item *b, Item *c):
+    Item_func_hybrid_field_type(thd, a, b, c)
+  { }
+  Item_func_numhybrid(THD *thd, List<Item> &list):
+    Item_func_hybrid_field_type(thd, list)
+  { }
+  String *str_op(String *str) { DBUG_ASSERT(0); return 0; }
+  bool date_op(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+  {
+    DBUG_ASSERT(0);
+    return true;
+  }
+  bool time_op(THD *thd, MYSQL_TIME *ltime)
+  {
+    DBUG_ASSERT(0);
+    return true;
+  }
+  bool native_op(THD *thd, Native *to)
+  {
+    DBUG_ASSERT(0);
+    return true;
+  }
+};
+
+
+/* function where type of result detected by first argument */
+class Item_func_num1: public Item_func_numhybrid
+{
+public:
+  Item_func_num1(THD *thd, Item *a): Item_func_numhybrid(thd, a) {}
+  Item_func_num1(THD *thd, Item *a, Item *b): Item_func_numhybrid(thd, a, b) {}
+  bool check_partition_func_processor(void *int_arg) { return FALSE; }
+  bool check_vcol_func_processor(void *arg) { return FALSE; }
+};
+
+
+/* Base class for operations like '+', '-', '*' */
+class Item_num_op :public Item_func_numhybrid
+{
+protected:
+  bool check_arguments() const
+  {
+    return false; // Checked by aggregate_for_num_op()
+  }
+public:
+  Item_num_op(THD *thd, Item *a, Item *b): Item_func_numhybrid(thd, a, b) {}
+  virtual void result_precision()= 0;
+
+  virtual inline void print(String *str, enum_query_type query_type)
+  {
+    print_op(str, query_type);
+  }
+  bool fix_type_handler(const Type_aggregator *aggregator);
+  void fix_length_and_dec_double()
+  {
+    aggregate_numeric_attributes_real(args, arg_count);
+    max_length= float_length(decimals);
+  }
+  void fix_length_and_dec_decimal()
+  {
+    unsigned_flag= args[0]->unsigned_flag & args[1]->unsigned_flag;
+    result_precision();
+    fix_decimals();
+  }
+  void fix_length_and_dec_int()
+  {
+    unsigned_flag= args[0]->unsigned_flag | args[1]->unsigned_flag;
+    result_precision();
+    decimals= 0;
+    set_handler(type_handler_long_or_longlong());
+  }
+  void fix_length_and_dec_temporal(bool downcast_decimal_to_int)
+  {
+    set_handler(&type_handler_newdecimal);
+    fix_length_and_dec_decimal();
+    if (decimals == 0 && downcast_decimal_to_int)
+      set_handler(type_handler_long_or_longlong());
+  }
+  bool need_parentheses_in_default() { return true; }
+};
+
+
+class Item_int_func :public Item_func
+{
+public:
+  /*
+    QQ: shouldn't 20 characters be enough:
+    Max unsigned =  18,446,744,073,709,551,615 = 20 digits, 20 characters
+    Max signed   =   9,223,372,036,854,775,807 = 19 digits, 19 characters
+    Min signed   =  -9,223,372,036,854,775,808 = 19 digits, 20 characters
+  */
+  Item_int_func(THD *thd): Item_func(thd)
+  { collation= DTCollation_numeric(); fix_char_length(21); }
+  Item_int_func(THD *thd, Item *a): Item_func(thd, a)
+  { collation= DTCollation_numeric(); fix_char_length(21); }
+  Item_int_func(THD *thd, Item *a, Item *b): Item_func(thd, a, b)
+  { collation= DTCollation_numeric(); fix_char_length(21); }
+  Item_int_func(THD *thd, Item *a, Item *b, Item *c): Item_func(thd, a, b, c)
+  { collation= DTCollation_numeric(); fix_char_length(21); }
+  Item_int_func(THD *thd, Item *a, Item *b, Item *c, Item *d):
+    Item_func(thd, a, b, c, d)
+  { collation= DTCollation_numeric(); fix_char_length(21); }
+  Item_int_func(THD *thd, List<Item> &list): Item_func(thd, list)
+  { collation= DTCollation_numeric(); fix_char_length(21); }
+  Item_int_func(THD *thd, Item_int_func *item) :Item_func(thd, item)
+  { collation= DTCollation_numeric(); }
+  double val_real();
+  String *val_str(String*str);
+  my_decimal *val_decimal(my_decimal *decimal_value)
+  {
+    return val_decimal_from_int(decimal_value);
+  }
+  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+  { return get_date_from_int(thd, ltime, fuzzydate); }
+  const Type_handler *type_handler() const= 0;
+  bool fix_length_and_dec() { return FALSE; }
+};
+
+
+class Item_long_func: public Item_int_func
+{
+public:
+  Item_long_func(THD *thd): Item_int_func(thd) { }
+  Item_long_func(THD *thd, Item *a): Item_int_func(thd, a) {}
+  Item_long_func(THD *thd, Item *a, Item *b): Item_int_func(thd, a, b) {}
+  Item_long_func(THD *thd, Item *a, Item *b, Item *c): Item_int_func(thd, a, b, c) {}
+  Item_long_func(THD *thd, List<Item> &list): Item_int_func(thd, list) { }
+  Item_long_func(THD *thd, Item_long_func *item) :Item_int_func(thd, item) {}
+  const Type_handler *type_handler() const
+  {
+    if (unsigned_flag)
+      return &type_handler_ulong;
+    return &type_handler_slong;
+  }
+  bool fix_length_and_dec() { max_length= 11; return FALSE; }
+};
+
+
+class Item_func_hash: public Item_int_func
+{
+public:
+  Item_func_hash(THD *thd, List<Item> &item): Item_int_func(thd, item)
+  {}
+  longlong val_int();
+  bool fix_length_and_dec();
+  const Type_handler *type_handler() const { return &type_handler_slong; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_hash>(thd, this); }
+  const char *func_name() const { return "<hash>"; }
+};
+
+class Item_longlong_func: public Item_int_func
+{
+public:
+  Item_longlong_func(THD *thd): Item_int_func(thd) { }
+  Item_longlong_func(THD *thd, Item *a): Item_int_func(thd, a) {}
+  Item_longlong_func(THD *thd, Item *a, Item *b): Item_int_func(thd, a, b) {}
+  Item_longlong_func(THD *thd, Item *a, Item *b, Item *c): Item_int_func(thd, a, b, c) {}
+  Item_longlong_func(THD *thd, Item *a, Item *b, Item *c, Item *d):
+    Item_int_func(thd, a, b, c, d) {}
+  Item_longlong_func(THD *thd, List<Item> &list): Item_int_func(thd, list) { }
+  Item_longlong_func(THD *thd, Item_longlong_func *item) :Item_int_func(thd, item) {}
+  const Type_handler *type_handler() const
+  {
+    if (unsigned_flag)
+      return &type_handler_ulonglong;
+    return &type_handler_slonglong;
+  }
+};
+
+
+class Cursor_ref
+{
+protected:
+  LEX_CSTRING m_cursor_name;
+  uint m_cursor_offset;
+  class sp_cursor *get_open_cursor_or_error();
+  Cursor_ref(const LEX_CSTRING *name, uint offset)
+   :m_cursor_name(*name), m_cursor_offset(offset)
+  { }
+  void print_func(String *str, const char *func_name);
+};
+
+
+
+class Item_func_cursor_rowcount: public Item_longlong_func,
+                                 public Cursor_ref
+{
+public:
+  Item_func_cursor_rowcount(THD *thd, const LEX_CSTRING *name, uint offset)
+   :Item_longlong_func(thd), Cursor_ref(name, offset) { maybe_null= true; }
+  const char *func_name() const { return "%ROWCOUNT"; }
+  longlong val_int();
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), arg, VCOL_SESSION_FUNC);
+  }
+  void print(String *str, enum_query_type query_type)
+  {
+    return Cursor_ref::print_func(str, func_name());
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_cursor_rowcount>(thd, this); }
+};
+
+
+
+class Item_func_connection_id :public Item_long_func
+{
+  longlong value;
+
+public:
+  Item_func_connection_id(THD *thd): Item_long_func(thd) { unsigned_flag=1; }
+  const char *func_name() const { return "connection_id"; }
+  bool fix_length_and_dec();
+  bool fix_fields(THD *thd, Item **ref);
+  longlong val_int() { DBUG_ASSERT(fixed == 1); return value; }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_SESSION_FUNC);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_connection_id>(thd, this); }
+};
+
+
+class Item_func_signed :public Item_int_func
+{
+public:
+  Item_func_signed(THD *thd, Item *a): Item_int_func(thd, a)
+  {
+    unsigned_flag= 0;
+  }
+  const char *func_name() const { return "cast_as_signed"; }
+  const Type_handler *type_handler() const
+  {
+    return Type_handler::type_handler_long_or_longlong(max_char_length(),
+                                                       false);
+  }
+  longlong val_int()
+  {
+    longlong value= args[0]->val_int_signed_typecast();
+    null_value= args[0]->null_value;
+    return value;
+  }
+  void fix_length_and_dec_double()
+  {
+    fix_char_length(MAX_BIGINT_WIDTH);
+  }
+  void fix_length_and_dec_generic()
+  {
+    uint32 char_length= MY_MIN(args[0]->max_char_length(),
+                               MY_INT64_NUM_DECIMAL_DIGITS);
+    /*
+      args[0]->max_char_length() can return 0.
+      Reserve max_length to fit at least one character for one digit,
+      plus one character for the sign (if signed).
+    */
+    set_if_bigger(char_length, 1U + (unsigned_flag ? 0 : 1));
+    fix_char_length(char_length);
+  }
+  void fix_length_and_dec_string()
+  {
+    /*
+      For strings, use decimal_int_part() instead of max_char_length().
+      This is important for Item_hex_hybrid:
+        SELECT CAST(0x1FFFFFFFF AS SIGNED);
+      Length is 5, decimal_int_part() is 13.
+    */
+    uint32 char_length= MY_MIN(args[0]->decimal_int_part(),
+                               MY_INT64_NUM_DECIMAL_DIGITS);
+    set_if_bigger(char_length, 1U + (unsigned_flag ? 0 : 1));
+    fix_char_length(char_length);
+  }
+  bool fix_length_and_dec()
+  {
+    return args[0]->type_handler()->Item_func_signed_fix_length_and_dec(this);
+  }
+  virtual void print(String *str, enum_query_type query_type);
+  uint decimal_precision() const { return args[0]->decimal_precision(); }
+  bool need_parentheses_in_default() { return true; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_signed>(thd, this); }
+};
+
+
+class Item_func_unsigned :public Item_func_signed
+{
+public:
+  Item_func_unsigned(THD *thd, Item *a): Item_func_signed(thd, a)
+  {
+    unsigned_flag= 1;
+  }
+  const char *func_name() const { return "cast_as_unsigned"; }
+  const Type_handler *type_handler() const
+  {
+    if (max_char_length() <= MY_INT32_NUM_DECIMAL_DIGITS - 1)
+      return &type_handler_ulong;
+    return &type_handler_ulonglong;
+  }
+  longlong val_int()
+  {
+    longlong value= args[0]->val_int_unsigned_typecast();
+    null_value= args[0]->null_value;
+    return value;
+  }
+  bool fix_length_and_dec()
+  {
+    return args[0]->type_handler()->Item_func_unsigned_fix_length_and_dec(this);
+  }
+  uint decimal_precision() const { return max_length; }
+  virtual void print(String *str, enum_query_type query_type);
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_unsigned>(thd, this); }
+};
+
+
+class Item_decimal_typecast :public Item_func
+{
+  my_decimal decimal_value;
+public:
+  Item_decimal_typecast(THD *thd, Item *a, uint len, uint dec)
+   :Item_func(thd, a)
+  {
+    decimals= (uint8) dec;
+    collation= DTCollation_numeric();
+    fix_char_length(my_decimal_precision_to_length_no_truncation(len, dec,
+                                                                 unsigned_flag));
+  }
+  String *val_str(String *str) { return VDec(this).to_string(str); }
+  double val_real() { return VDec(this).to_double(); }
+  longlong val_int() { return VDec(this).to_longlong(unsigned_flag); }
+  my_decimal *val_decimal(my_decimal*);
+  bool get_date(THD *thd, MYSQL_TIME *to, date_mode_t mode)
+  {
+    return decimal_to_datetime_with_warn(thd, VDec(this).ptr(), to, mode,
+                                         NULL, NULL);
+  }
+  const Type_handler *type_handler() const { return &type_handler_newdecimal; }
+  void fix_length_and_dec_generic() {}
+  bool fix_length_and_dec()
+  {
+    return
+      args[0]->type_handler()->Item_decimal_typecast_fix_length_and_dec(this);
+  }
+  const char *func_name() const { return "decimal_typecast"; }
+  virtual void print(String *str, enum_query_type query_type);
+  bool need_parentheses_in_default() { return true; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_decimal_typecast>(thd, this); }
+};
+
+
+class Item_real_typecast: public Item_real_func
+{
+protected:
+  double val_real_with_truncate(double max_value);
+public:
+  Item_real_typecast(THD *thd, Item *a, uint len, uint dec)
+   :Item_real_func(thd, a)
+  {
+    decimals=   (uint8)  dec;
+    max_length= (uint32) len;
+  }
+  bool need_parentheses_in_default() { return true; }
+  void print(String *str, enum_query_type query_type);
+  void fix_length_and_dec_generic() { maybe_null= 1; }
+};
+
+
+class Item_float_typecast :public Item_real_typecast
+{
+public:
+  Item_float_typecast(THD *thd, Item *a)
+   :Item_real_typecast(thd, a, MAX_FLOAT_STR_LENGTH, NOT_FIXED_DEC)
+  { }
+  const Type_handler *type_handler() const { return &type_handler_float; }
+  bool fix_length_and_dec()
+  {
+    return
+      args[0]->type_handler()->Item_float_typecast_fix_length_and_dec(this);
+  }
+  const char *func_name() const { return "float_typecast"; }
+  double val_real()
+  {
+    return (double) (float) val_real_with_truncate(FLT_MAX);
+  }
+  String *val_str(String*str)
+  {
+    Float nr(Item_float_typecast::val_real());
+    if (null_value)
+      return 0;
+    nr.to_string(str, decimals);
+    return str;
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_float_typecast>(thd, this); }
+};
+
+
+class Item_double_typecast :public Item_real_typecast
+{
+public:
+  Item_double_typecast(THD *thd, Item *a, uint len, uint dec):
+    Item_real_typecast(thd, a, len, dec)
+  { }
+  bool fix_length_and_dec()
+  {
+    return
+      args[0]->type_handler()->Item_double_typecast_fix_length_and_dec(this);
+  }
+  const char *func_name() const { return "double_typecast"; }
+  double val_real() { return val_real_with_truncate(DBL_MAX); }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_double_typecast>(thd, this); }
+};
+
+
+class Item_func_additive_op :public Item_num_op
+{
+public:
+  Item_func_additive_op(THD *thd, Item *a, Item *b): Item_num_op(thd, a, b) {}
+  void result_precision();
+  bool check_partition_func_processor(void *int_arg) {return FALSE;}
+  bool check_vcol_func_processor(void *arg) { return FALSE;}
+};
+
+
+class Item_func_plus :public Item_func_additive_op
+{
+public:
+  Item_func_plus(THD *thd, Item *a, Item *b):
+    Item_func_additive_op(thd, a, b) {}
+  const char *func_name() const { return "+"; }
+  enum precedence precedence() const { return ADD_PRECEDENCE; }
+  bool fix_length_and_dec();
+  longlong int_op();
+  double real_op();
+  my_decimal *decimal_op(my_decimal *);
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_plus>(thd, this); }
+};
+
+class Item_func_minus :public Item_func_additive_op
+{
+  bool m_depends_on_sql_mode_no_unsigned_subtraction;
+public:
+  Item_func_minus(THD *thd, Item *a, Item *b):
+    Item_func_additive_op(thd, a, b),
+    m_depends_on_sql_mode_no_unsigned_subtraction(false)
+  { }
+  const char *func_name() const { return "-"; }
+  enum precedence precedence() const { return ADD_PRECEDENCE; }
+  Sql_mode_dependency value_depends_on_sql_mode() const;
+  longlong int_op();
+  double real_op();
+  my_decimal *decimal_op(my_decimal *);
+  bool fix_length_and_dec();
+  void fix_unsigned_flag();
+  void fix_length_and_dec_double()
+  {
+    Item_func_additive_op::fix_length_and_dec_double();
+    fix_unsigned_flag();
+  }
+  void fix_length_and_dec_decimal()
+  {
+    Item_func_additive_op::fix_length_and_dec_decimal();
+    fix_unsigned_flag();
+  }
+  void fix_length_and_dec_int()
+  {
+    Item_func_additive_op::fix_length_and_dec_int();
+    fix_unsigned_flag();
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_minus>(thd, this); }
+};
+
+
+class Item_func_mul :public Item_num_op
+{
+public:
+  Item_func_mul(THD *thd, Item *a, Item *b):
+    Item_num_op(thd, a, b) {}
+  const char *func_name() const { return "*"; }
+  enum precedence precedence() const { return MUL_PRECEDENCE; }
+  longlong int_op();
+  double real_op();
+  my_decimal *decimal_op(my_decimal *);
+  void result_precision();
+  bool fix_length_and_dec();
+  bool check_partition_func_processor(void *int_arg) {return FALSE;}
+  bool check_vcol_func_processor(void *arg) { return FALSE;}
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_mul>(thd, this); }
+};
+
+
+class Item_func_div :public Item_num_op
+{
+public:
+  uint prec_increment;
+  Item_func_div(THD *thd, Item *a, Item *b): Item_num_op(thd, a, b) {}
+  longlong int_op() { DBUG_ASSERT(0); return 0; }
+  double real_op();
+  my_decimal *decimal_op(my_decimal *);
+  const char *func_name() const { return "/"; }
+  enum precedence precedence() const { return MUL_PRECEDENCE; }
+  bool fix_length_and_dec();
+  void fix_length_and_dec_double();
+  void fix_length_and_dec_int();
+  void result_precision();
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_div>(thd, this); }
+};
+
+
+class Item_func_int_div :public Item_int_func
+{
+public:
+  Item_func_int_div(THD *thd, Item *a, Item *b): Item_int_func(thd, a, b)
+  {}
+  longlong val_int();
+  const char *func_name() const { return "DIV"; }
+  enum precedence precedence() const { return MUL_PRECEDENCE; }
+  const Type_handler *type_handler() const
+  { return type_handler_long_or_longlong(); }
+  bool fix_length_and_dec();
+  void print(String *str, enum_query_type query_type)
+  {
+    print_op(str, query_type);
+  }
+
+  bool check_partition_func_processor(void *int_arg) {return FALSE;}
+  bool check_vcol_func_processor(void *arg) { return FALSE;}
+  bool need_parentheses_in_default() { return true; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_int_div>(thd, this); }
+};
+
+
+class Item_func_mod :public Item_num_op
+{
+public:
+  Item_func_mod(THD *thd, Item *a, Item *b): Item_num_op(thd, a, b) {}
+  longlong int_op();
+  double real_op();
+  my_decimal *decimal_op(my_decimal *);
+  const char *func_name() const { return "MOD"; }
+  enum precedence precedence() const { return MUL_PRECEDENCE; }
+  void result_precision();
+  bool fix_length_and_dec();
+  void fix_length_and_dec_double()
+  {
+    Item_num_op::fix_length_and_dec_double();
+    unsigned_flag= args[0]->unsigned_flag;
+  }
+  void fix_length_and_dec_decimal()
+  {
+    result_precision();
+    fix_decimals();
+  }
+  void fix_length_and_dec_int()
+  {
+    result_precision();
+    DBUG_ASSERT(decimals == 0);
+    set_handler(type_handler_long_or_longlong());
+  }
+  bool check_partition_func_processor(void *int_arg) {return FALSE;}
+  bool check_vcol_func_processor(void *arg) { return FALSE;}
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_mod>(thd, this); }
+};
+
+
+class Item_func_neg :public Item_func_num1
+{
+public:
+  Item_func_neg(THD *thd, Item *a): Item_func_num1(thd, a) {}
+  double real_op();
+  longlong int_op();
+  my_decimal *decimal_op(my_decimal *);
+  const char *func_name() const { return "-"; }
+  enum Functype functype() const   { return NEG_FUNC; }
+  enum precedence precedence() const { return NEG_PRECEDENCE; }
+  void print(String *str, enum_query_type query_type)
+  {
+    str->append(func_name());
+    args[0]->print_parenthesised(str, query_type, precedence());
+  }
+  void fix_length_and_dec_int();
+  void fix_length_and_dec_double();
+  void fix_length_and_dec_decimal();
+  bool fix_length_and_dec();
+  uint decimal_precision() const { return args[0]->decimal_precision(); }
+  bool need_parentheses_in_default() { return true; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_neg>(thd, this); }
+};
+
+
+class Item_func_abs :public Item_func_num1
+{
+public:
+  Item_func_abs(THD *thd, Item *a): Item_func_num1(thd, a) {}
+  double real_op();
+  longlong int_op();
+  my_decimal *decimal_op(my_decimal *);
+  const char *func_name() const { return "abs"; }
+  void fix_length_and_dec_int();
+  void fix_length_and_dec_double();
+  void fix_length_and_dec_decimal();
+  bool fix_length_and_dec();
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_abs>(thd, this); }
+};
+
+// A class to handle logarithmic and trigonometric functions
+
+class Item_dec_func :public Item_real_func
+{
+  bool check_arguments() const
+  { return check_argument_types_can_return_real(0, arg_count); }
+ public:
+  Item_dec_func(THD *thd, Item *a): Item_real_func(thd, a) {}
+  Item_dec_func(THD *thd, Item *a, Item *b): Item_real_func(thd, a, b) {}
+  bool fix_length_and_dec()
+  {
+    decimals=NOT_FIXED_DEC; max_length=float_length(decimals);
+    maybe_null=1;
+    return FALSE;
+  }
+};
+
+class Item_func_exp :public Item_dec_func
+{
+public:
+  Item_func_exp(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "exp"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_exp>(thd, this); }
+};
+
+
+class Item_func_ln :public Item_dec_func
+{
+public:
+  Item_func_ln(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "ln"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_ln>(thd, this); }
+};
+
+
+class Item_func_log :public Item_dec_func
+{
+public:
+  Item_func_log(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  Item_func_log(THD *thd, Item *a, Item *b): Item_dec_func(thd, a, b) {}
+  double val_real();
+  const char *func_name() const { return "log"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_log>(thd, this); }
+};
+
+
+class Item_func_log2 :public Item_dec_func
+{
+public:
+  Item_func_log2(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "log2"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_log2>(thd, this); }
+};
+
+
+class Item_func_log10 :public Item_dec_func
+{
+public:
+  Item_func_log10(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "log10"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_log10>(thd, this); }
+};
+
+
+class Item_func_sqrt :public Item_dec_func
+{
+public:
+  Item_func_sqrt(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "sqrt"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_sqrt>(thd, this); }
+};
+
+
+class Item_func_pow :public Item_dec_func
+{
+public:
+  Item_func_pow(THD *thd, Item *a, Item *b): Item_dec_func(thd, a, b) {}
+  double val_real();
+  const char *func_name() const { return "pow"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_pow>(thd, this); }
+};
+
+
+class Item_func_acos :public Item_dec_func
+{
+public:
+  Item_func_acos(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "acos"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_acos>(thd, this); }
+};
+
+class Item_func_asin :public Item_dec_func
+{
+public:
+  Item_func_asin(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "asin"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_asin>(thd, this); }
+};
+
+class Item_func_atan :public Item_dec_func
+{
+public:
+  Item_func_atan(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  Item_func_atan(THD *thd, Item *a, Item *b): Item_dec_func(thd, a, b) {}
+  double val_real();
+  const char *func_name() const { return "atan"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_atan>(thd, this); }
+};
+
+class Item_func_cos :public Item_dec_func
+{
+public:
+  Item_func_cos(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "cos"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_cos>(thd, this); }
+};
+
+class Item_func_sin :public Item_dec_func
+{
+public:
+  Item_func_sin(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "sin"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_sin>(thd, this); }
+};
+
+class Item_func_tan :public Item_dec_func
+{
+public:
+  Item_func_tan(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "tan"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_tan>(thd, this); }
+};
+
+class Item_func_cot :public Item_dec_func
+{
+public:
+  Item_func_cot(THD *thd, Item *a): Item_dec_func(thd, a) {}
+  double val_real();
+  const char *func_name() const { return "cot"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_cot>(thd, this); }
+};
+
+
+class Item_func_int_val :public Item_func_hybrid_field_type
+{
+public:
+  Item_func_int_val(THD *thd, Item *a): Item_func_hybrid_field_type(thd, a) {}
+  bool check_partition_func_processor(void *int_arg) { return FALSE; }
+  bool check_vcol_func_processor(void *arg) { return FALSE; }
+  virtual decimal_round_mode round_mode() const= 0;
+  void fix_length_and_dec_double();
+  void fix_length_and_dec_int_or_decimal();
+  void fix_length_and_dec_time()
+  {
+    fix_attributes_time(0);
+    set_handler(&type_handler_time2);
+  }
+  void fix_length_and_dec_datetime()
+  {
+    fix_attributes_datetime(0);
+    set_handler(&type_handler_datetime2);
+    maybe_null= true; // E.g. CEILING(TIMESTAMP'0000-01-01 23:59:59.9')
+  }
+  bool fix_length_and_dec();
+  String *str_op(String *str) { DBUG_ASSERT(0); return 0; }
+  bool native_op(THD *thd, Native *to)
+  {
+    DBUG_ASSERT(0);
+    return true;
+  }
+};
+
+
+class Item_func_ceiling :public Item_func_int_val
+{
+public:
+  Item_func_ceiling(THD *thd, Item *a): Item_func_int_val(thd, a) {}
+  const char *func_name() const { return "ceiling"; }
+  decimal_round_mode round_mode() const { return CEILING; }
+  longlong int_op();
+  double real_op();
+  my_decimal *decimal_op(my_decimal *);
+  bool date_op(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
+  bool time_op(THD *thd, MYSQL_TIME *ltime);
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_ceiling>(thd, this); }
+};
+
+
+class Item_func_floor :public Item_func_int_val
+{
+public:
+  Item_func_floor(THD *thd, Item *a): Item_func_int_val(thd, a) {}
+  const char *func_name() const { return "floor"; }
+  decimal_round_mode round_mode() const { return FLOOR; }
+  longlong int_op();
+  double real_op();
+  my_decimal *decimal_op(my_decimal *);
+  bool date_op(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
+  bool time_op(THD *thd, MYSQL_TIME *ltime);
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_floor>(thd, this); }
+};
+
+/* This handles round and truncate */
+
+class Item_func_round :public Item_func_hybrid_field_type
+{
+  bool truncate;
+  void fix_length_and_dec_decimal(uint decimals_to_set);
+  void fix_length_and_dec_double(uint decimals_to_set);
+  bool test_if_length_can_increase();
+public:
+  Item_func_round(THD *thd, Item *a, Item *b, bool trunc_arg)
+    :Item_func_hybrid_field_type(thd, a, b), truncate(trunc_arg) {}
+  const char *func_name() const { return truncate ? "truncate" : "round"; }
+  double real_op();
+  longlong int_op();
+  my_decimal *decimal_op(my_decimal *);
+  bool date_op(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
+  bool time_op(THD *thd, MYSQL_TIME *ltime);
+  bool native_op(THD *thd, Native *to)
+  {
+    DBUG_ASSERT(0);
+    return true;
+  }
+  String *str_op(String *str)
+  {
+    DBUG_ASSERT(0);
+    return NULL;
+  }
+  void fix_arg_decimal();
+  void fix_arg_int(const Type_handler *preferred,
+                   const Type_std_attributes *preferred_attributes,
+                   bool use_decimal_on_length_increase);
+  void fix_arg_hex_hybrid();
+  void fix_arg_double();
+  void fix_arg_time();
+  void fix_arg_datetime();
+  void fix_arg_temporal(const Type_handler *h, uint int_part_length);
+  bool fix_length_and_dec()
+  {
+    /*
+      We don't want to translate ENUM/SET to CHAR here.
+      So let's real_type_handler(), not type_handler().
+    */
+    return args[0]->real_type_handler()->Item_func_round_fix_length_and_dec(this);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_round>(thd, this); }
+};
+
+
+class Item_func_rand :public Item_real_func
+{
+  struct my_rnd_struct *rand;
+  bool first_eval; // TRUE if val_real() is called 1st time
+  bool check_arguments() const
+  { return check_argument_types_can_return_int(0, arg_count); }
+  void seed_random (Item * val);
+public:
+  Item_func_rand(THD *thd, Item *a):
+    Item_real_func(thd, a), rand(0), first_eval(TRUE) {}
+  Item_func_rand(THD *thd): Item_real_func(thd) {}
+  double val_real();
+  const char *func_name() const { return "rand"; }
+  bool const_item() const { return 0; }
+  void update_used_tables();
+  bool fix_fields(THD *thd, Item **ref);
+  void cleanup() { first_eval= TRUE; Item_real_func::cleanup(); }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg,
+                                     VCOL_NON_DETERMINISTIC);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_rand>(thd, this); }
+};
+
+
+class Item_func_sign :public Item_long_func
+{
+  bool check_arguments() const
+  { return args[0]->check_type_can_return_real(func_name()); }
+public:
+  Item_func_sign(THD *thd, Item *a): Item_long_func(thd, a) {}
+  const char *func_name() const { return "sign"; }
+  uint decimal_precision() const { return 1; }
+  bool fix_length_and_dec() { fix_char_length(2); return FALSE; }
+  longlong val_int();
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_sign>(thd, this); }
+};
+
+
+class Item_func_units :public Item_real_func
+{
+  char *name;
+  double mul,add;
+  bool check_arguments() const
+  { return check_argument_types_can_return_real(0, arg_count); }
+public:
+  Item_func_units(THD *thd, char *name_arg, Item *a, double mul_arg,
+                  double add_arg):
+    Item_real_func(thd, a), name(name_arg), mul(mul_arg), add(add_arg) {}
+  double val_real();
+  const char *func_name() const { return name; }
+  bool fix_length_and_dec()
+  {
+    decimals= NOT_FIXED_DEC;
+    max_length= float_length(decimals);
+    return FALSE;
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_units>(thd, this); }
+};
+
+
+/**
+  Item_func_min_max does not derive from Item_func_hybrid_field_type
+  because the way how its methods val_xxx() and get_date() work depend
+  not only by its arguments, but also on the context in which
+  LEAST() and GREATEST() appear.
+  For example, using Item_func_min_max in a CAST like this:
+    CAST(LEAST('11','2') AS SIGNED)
+  forces Item_func_min_max to compare the arguments as numbers rather
+  than strings.
+  Perhaps this should be changed eventually (see MDEV-5893).
+*/
+class Item_func_min_max :public Item_hybrid_func
+{
+  String tmp_value;
+  int cmp_sign;
+protected:
+  bool check_arguments() const
+  {
+    return false; // Checked by aggregate_for_min_max()
+  }
+  bool fix_attributes(Item **item, uint nitems);
+public:
+  Item_func_min_max(THD *thd, List<Item> &list, int cmp_sign_arg):
+    Item_hybrid_func(thd, list), cmp_sign(cmp_sign_arg)
+  {}
+  String *val_str_native(String *str);
+  double val_real_native();
+  longlong val_int_native();
+  my_decimal *val_decimal_native(my_decimal *);
+  bool get_date_native(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate);
+  bool get_time_native(THD *thd, MYSQL_TIME *res);
+
+  double val_real()
+  {
+    DBUG_ASSERT(fixed);
+    return Item_func_min_max::type_handler()->
+             Item_func_min_max_val_real(this);
+  }
+  longlong val_int()
+  {
+    DBUG_ASSERT(fixed);
+    return Item_func_min_max::type_handler()->
+             Item_func_min_max_val_int(this);
+  }
+  String *val_str(String *str)
+  {
+    DBUG_ASSERT(fixed);
+    return Item_func_min_max::type_handler()->
+             Item_func_min_max_val_str(this, str);
+  }
+  my_decimal *val_decimal(my_decimal *dec)
+  {
+    DBUG_ASSERT(fixed);
+    return Item_func_min_max::type_handler()->
+             Item_func_min_max_val_decimal(this, dec);
+  }
+  bool get_date(THD *thd, MYSQL_TIME *res, date_mode_t fuzzydate)
+  {
+    DBUG_ASSERT(fixed);
+    return Item_func_min_max::type_handler()->
+             Item_func_min_max_get_date(thd, this, res, fuzzydate);
+  }
+  bool val_native(THD *thd, Native *to);
+  void aggregate_attributes_real(Item **items, uint nitems)
+  {
+    /*
+      Aggregating attributes for the double data type for LEAST/GREATEST
+      is almost the same with aggregating for CASE-alike hybrid functions,
+      (CASE..THEN, COALESCE, IF, etc).
+      There is one notable difference though, when a numeric argument is mixed
+      with a string argument:
+      - CASE-alike functions return a string data type in such cases
+        COALESCE(10,'x') -> VARCHAR(2) = '10'
+      - LEAST/GREATEST returns double:
+        GREATEST(10,'10e4') -> DOUBLE = 100000
+      As the string argument can represent a number in the scientific notation,
+      like in the example above, max_length of the result can be longer than
+      max_length of the arguments. To handle this properly, max_length is
+      additionally assigned to the result of float_length(decimals).
+    */
+    Item_func::aggregate_attributes_real(items, nitems);
+    max_length= float_length(decimals);
+  }
+  bool fix_length_and_dec()
+  {
+    if (aggregate_for_min_max(func_name(), args, arg_count))
+      return true;
+    fix_attributes(args, arg_count);
+    return false;
+  }
+};
+
+class Item_func_min :public Item_func_min_max
+{
+public:
+  Item_func_min(THD *thd, List<Item> &list): Item_func_min_max(thd, list, 1) {}
+  const char *func_name() const { return "least"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_min>(thd, this); }
+};
+
+class Item_func_max :public Item_func_min_max
+{
+public:
+  Item_func_max(THD *thd, List<Item> &list): Item_func_min_max(thd, list, -1) {}
+  const char *func_name() const { return "greatest"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_max>(thd, this); }
+};
+
+
+/* 
+  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(THD *thd, Item *a): Item_func(thd, a)
+  {
+    name= a->name;
+  }
+  double val_real() { return val_real_from_item(args[0]); }
+  longlong val_int() { return val_int_from_item(args[0]); }
+  String *val_str(String *str) { return val_str_from_item(args[0], str); }
+  bool val_native(THD *thd, Native *to)
+    { return val_native_from_item(thd, args[0], to); }
+  my_decimal *val_decimal(my_decimal *dec)
+    { return val_decimal_from_item(args[0], dec); }
+  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+    { return get_date_from_item(thd, args[0], ltime, fuzzydate); }
+  const char *func_name() const { return "rollup_const"; }
+  bool const_item() const { return 0; }
+  const Type_handler *type_handler() const { return args[0]->type_handler(); }
+  bool fix_length_and_dec()
+  {
+    Type_std_attributes::set(*args[0]);
+    return FALSE;
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_rollup_const>(thd, this); }
+};
+
+
+class Item_long_func_length: public Item_long_func
+{
+  bool check_arguments() const
+  { return args[0]->check_type_can_return_str(func_name()); }
+public:
+  Item_long_func_length(THD *thd, Item *a): Item_long_func(thd, a) {}
+  bool fix_length_and_dec() { max_length=10; return FALSE; }
+};
+
+
+class Item_func_octet_length :public Item_long_func_length
+{
+  String value;
+public:
+  Item_func_octet_length(THD *thd, Item *a): Item_long_func_length(thd, a) {}
+  longlong val_int();
+  const char *func_name() const { return "octet_length"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_octet_length>(thd, this); }
+};
+
+class Item_func_bit_length :public Item_longlong_func
+{
+  String value;
+public:
+  Item_func_bit_length(THD *thd, Item *a): Item_longlong_func(thd, a) {}
+  bool fix_length_and_dec()
+  {
+    max_length= 11; // 0x100000000*8 = 34,359,738,368
+    return FALSE;
+  }
+  longlong val_int();
+  const char *func_name() const { return "bit_length"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_bit_length>(thd, this); }
+};
+
+class Item_func_char_length :public Item_long_func_length
+{
+  String value;
+public:
+  Item_func_char_length(THD *thd, Item *a): Item_long_func_length(thd, a) {}
+  longlong val_int();
+  const char *func_name() const { return "char_length"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_char_length>(thd, this); }
+};
+
+class Item_func_coercibility :public Item_long_func
+{
+  bool check_arguments() const
+  { return args[0]->check_type_can_return_str(func_name()); }
+public:
+  Item_func_coercibility(THD *thd, Item *a): Item_long_func(thd, a) {}
+  longlong val_int();
+  const char *func_name() const { return "coercibility"; }
+  bool fix_length_and_dec() { max_length=10; maybe_null= 0; return FALSE; }
+  bool eval_not_null_tables(void *)
+  {
+    not_null_tables_cache= 0;
+    return false;
+  }
+  bool find_not_null_fields(table_map allowed)
+  {
+    return false;
+  }
+  Item* propagate_equal_fields(THD *thd, const Context &ctx, COND_EQUAL *cond)
+  { return this; }
+  bool const_item() const { return true; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_coercibility>(thd, this); }
+};
+
+
+/*
+  In the corner case LOCATE could return (4,294,967,296 + 1),
+  which would not fit into Item_long_func range.
+  But string lengths are limited with max_allowed_packet,
+  which cannot be bigger than 1024*1024*1024.
+*/
+class Item_func_locate :public Item_long_func
+{
+  bool check_arguments() const
+  {
+    return check_argument_types_can_return_str(0, 2) ||
+           (arg_count > 2 && args[2]->check_type_can_return_int(func_name()));
+  }
+  String value1,value2;
+  DTCollation cmp_collation;
+public:
+  Item_func_locate(THD *thd, Item *a, Item *b)
+   :Item_long_func(thd, a, b) {}
+  Item_func_locate(THD *thd, Item *a, Item *b, Item *c)
+   :Item_long_func(thd, a, b, c) {}
+  const char *func_name() const { return "locate"; }
+  longlong val_int();
+  bool fix_length_and_dec()
+  {
+    max_length= MY_INT32_NUM_DECIMAL_DIGITS;
+    return agg_arg_charsets_for_comparison(cmp_collation, args, 2);
+  }
+  virtual void print(String *str, enum_query_type query_type);
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_locate>(thd, this); }
+};
+
+
+class Item_func_field :public Item_long_func
+{
+  String value,tmp;
+  Item_result cmp_type;
+  DTCollation cmp_collation;
+public:
+  Item_func_field(THD *thd, List<Item> &list): Item_long_func(thd, list) {}
+  longlong val_int();
+  const char *func_name() const { return "field"; }
+  bool fix_length_and_dec();
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_field>(thd, this); }
+};
+
+
+class Item_func_ascii :public Item_long_func
+{
+  bool check_arguments() const
+  { return check_argument_types_can_return_str(0, arg_count); }
+  String value;
+public:
+  Item_func_ascii(THD *thd, Item *a): Item_long_func(thd, a) {}
+  longlong val_int();
+  const char *func_name() const { return "ascii"; }
+  bool fix_length_and_dec() { max_length=3; return FALSE; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_ascii>(thd, this); }
+};
+
+class Item_func_ord :public Item_long_func
+{
+  bool check_arguments() const
+  { return args[0]->check_type_can_return_str(func_name()); }
+  String value;
+public:
+  Item_func_ord(THD *thd, Item *a): Item_long_func(thd, a) {}
+  bool fix_length_and_dec() { fix_char_length(7); return FALSE; }
+  longlong val_int();
+  const char *func_name() const { return "ord"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_ord>(thd, this); }
+};
+
+class Item_func_find_in_set :public Item_long_func
+{
+  bool check_arguments() const
+  { return check_argument_types_can_return_str(0, 2); }
+  String value,value2;
+  uint enum_value;
+  ulonglong enum_bit;
+  DTCollation cmp_collation;
+public:
+  Item_func_find_in_set(THD *thd, Item *a, Item *b):
+    Item_long_func(thd, a, b), enum_value(0) {}
+  longlong val_int();
+  const char *func_name() const { return "find_in_set"; }
+  bool fix_length_and_dec();
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_find_in_set>(thd, this); }
+};
+
+/* Base class for all bit functions: '~', '|', '^', '&', '>>', '<<' */
+
+class Item_func_bit_operator: public Item_handled_func
+{
+  bool check_arguments() const
+  { return check_argument_types_can_return_int(0, arg_count); }
+protected:
+  bool fix_length_and_dec_op1_std(const Handler *ha_int, const Handler *ha_dec)
+  {
+    set_func_handler(args[0]->cmp_type() == INT_RESULT ? ha_int : ha_dec);
+    return m_func_handler->fix_length_and_dec(this);
+  }
+  bool fix_length_and_dec_op2_std(const Handler *ha_int, const Handler *ha_dec)
+  {
+    set_func_handler(args[0]->cmp_type() == INT_RESULT &&
+                     args[1]->cmp_type() == INT_RESULT ? ha_int : ha_dec);
+    return m_func_handler->fix_length_and_dec(this);
+  }
+public:
+  Item_func_bit_operator(THD *thd, Item *a)
+   :Item_handled_func(thd, a) {}
+  Item_func_bit_operator(THD *thd, Item *a, Item *b)
+   :Item_handled_func(thd, a, b) {}
+  void print(String *str, enum_query_type query_type)
+  {
+    print_op(str, query_type);
+  }
+  bool need_parentheses_in_default() { return true; }
+};
+
+class Item_func_bit_or :public Item_func_bit_operator
+{
+public:
+  Item_func_bit_or(THD *thd, Item *a, Item *b)
+   :Item_func_bit_operator(thd, a, b) {}
+  bool fix_length_and_dec();
+  const char *func_name() const { return "|"; }
+  enum precedence precedence() const { return BITOR_PRECEDENCE; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_bit_or>(thd, this); }
+};
+
+class Item_func_bit_and :public Item_func_bit_operator
+{
+public:
+  Item_func_bit_and(THD *thd, Item *a, Item *b)
+   :Item_func_bit_operator(thd, a, b) {}
+  bool fix_length_and_dec();
+  const char *func_name() const { return "&"; }
+  enum precedence precedence() const { return BITAND_PRECEDENCE; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_bit_and>(thd, this); }
+};
+
+class Item_func_bit_count :public Item_handled_func
+{
+  bool check_arguments() const
+  { return args[0]->check_type_can_return_int(func_name()); }
+public:
+  Item_func_bit_count(THD *thd, Item *a): Item_handled_func(thd, a) {}
+  const char *func_name() const { return "bit_count"; }
+  bool fix_length_and_dec();
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_bit_count>(thd, this); }
+};
+
+class Item_func_shift_left :public Item_func_bit_operator
+{
+public:
+  Item_func_shift_left(THD *thd, Item *a, Item *b)
+   :Item_func_bit_operator(thd, a, b) {}
+  bool fix_length_and_dec();
+  const char *func_name() const { return "<<"; }
+  enum precedence precedence() const { return SHIFT_PRECEDENCE; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_shift_left>(thd, this); }
+};
+
+class Item_func_shift_right :public Item_func_bit_operator
+{
+public:
+  Item_func_shift_right(THD *thd, Item *a, Item *b)
+   :Item_func_bit_operator(thd, a, b) {}
+  bool fix_length_and_dec();
+  const char *func_name() const { return ">>"; }
+  enum precedence precedence() const { return SHIFT_PRECEDENCE; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_shift_right>(thd, this); }
+};
+
+class Item_func_bit_neg :public Item_func_bit_operator
+{
+public:
+  Item_func_bit_neg(THD *thd, Item *a): Item_func_bit_operator(thd, a) {}
+  bool fix_length_and_dec();
+  const char *func_name() const { return "~"; }
+  enum precedence precedence() const { return NEG_PRECEDENCE; }
+  void print(String *str, enum_query_type query_type)
+  {
+    str->append(func_name());
+    args[0]->print_parenthesised(str, query_type, precedence());
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_bit_neg>(thd, this); }
+};
+
+
+class Item_func_last_insert_id :public Item_longlong_func
+{
+  bool check_arguments() const
+  { return check_argument_types_can_return_int(0, arg_count); }
+public:
+  Item_func_last_insert_id(THD *thd): Item_longlong_func(thd) {}
+  Item_func_last_insert_id(THD *thd, Item *a): Item_longlong_func(thd, a) {}
+  longlong val_int();
+  const char *func_name() const { return "last_insert_id"; }
+  bool fix_length_and_dec()
+  {
+    unsigned_flag= true;
+    if (arg_count)
+      max_length= args[0]->max_length;
+    return FALSE;
+  }
+  bool fix_fields(THD *thd, Item **ref);
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_last_insert_id>(thd, this); }
+};
+
+
+class Item_func_benchmark :public Item_long_func
+{
+  bool check_arguments() const
+  {
+    return args[0]->check_type_can_return_int(func_name()) ||
+           args[1]->check_type_scalar(func_name());
+  }
+public:
+  Item_func_benchmark(THD *thd, Item *count_expr, Item *expr):
+    Item_long_func(thd, count_expr, expr)
+  {}
+  longlong val_int();
+  const char *func_name() const { return "benchmark"; }
+  bool fix_length_and_dec() { max_length=1; maybe_null=0; return FALSE; }
+  virtual void print(String *str, enum_query_type query_type);
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_benchmark>(thd, this); }
+};
+
+
+void item_func_sleep_init(void);
+void item_func_sleep_free(void);
+
+class Item_func_sleep :public Item_long_func
+{
+  bool check_arguments() const
+  { return args[0]->check_type_can_return_real(func_name()); }
+public:
+  Item_func_sleep(THD *thd, Item *a): Item_long_func(thd, a) {}
+  bool fix_length_and_dec() { fix_char_length(1); return FALSE; }
+  bool const_item() const { return 0; }
+  const char *func_name() const { return "sleep"; }
+  table_map used_tables() const
+  {
+    return used_tables_cache | RAND_TABLE_BIT;
+  }
+  bool is_expensive() { return 1; }
+  longlong val_int();
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_sleep>(thd, this); }
+};
+
+
+
+#ifdef HAVE_DLOPEN
+
+class Item_udf_func :public Item_func
+{
+  /**
+    Mark "this" as non-deterministic if it uses no tables
+    and is not a constant at the same time.
+  */
+  void set_non_deterministic_if_needed()
+  {
+    if (!const_item_cache && !used_tables_cache)
+      used_tables_cache= RAND_TABLE_BIT;
+  }
+protected:
+  udf_handler udf;
+  bool is_expensive_processor(void *arg) { return TRUE; }
+
+  class VDec_udf: public Dec_ptr_and_buffer
+  {
+  public:
+    VDec_udf(Item_udf_func *func, udf_handler *udf)
+    {
+      my_bool tmp_null_value;
+      m_ptr= udf->val_decimal(&tmp_null_value, &m_buffer);
+      DBUG_ASSERT(is_null() == (tmp_null_value != 0));
+      func->null_value= is_null();
+    }
+  };
+
+public:
+  Item_udf_func(THD *thd, udf_func *udf_arg):
+    Item_func(thd), udf(udf_arg) {}
+  Item_udf_func(THD *thd, udf_func *udf_arg, List<Item> &list):
+    Item_func(thd, list), udf(udf_arg) {}
+  const char *func_name() const { return udf.name(); }
+  enum Functype functype() const   { return UDF_FUNC; }
+  bool fix_fields(THD *thd, Item **ref)
+  {
+    DBUG_ASSERT(fixed == 0);
+    bool res= udf.fix_fields(thd, this, arg_count, args);
+    set_non_deterministic_if_needed();
+    fixed= 1;
+    return res;
+  }
+  void fix_num_length_and_dec();
+  void update_used_tables()
+  {
+    /*
+      TODO: Make a member in UDF_INIT and return if a UDF is deterministic or
+      not.
+      Currently UDF_INIT has a member (const_item) that is an in/out 
+      parameter to the init() call.
+      The code in udf_handler::fix_fields also duplicates the arguments 
+      handling code in Item_func::fix_fields().
+      
+      The lack of information if a UDF is deterministic makes writing
+      a correct update_used_tables() for UDFs impossible.
+      One solution to this would be :
+       - Add a is_deterministic member of UDF_INIT
+       - (optionally) deprecate the const_item member of UDF_INIT
+       - Take away the duplicate code from udf_handler::fix_fields() and
+         make Item_udf_func call Item_func::fix_fields() to process its 
+         arguments as for any other function.
+       - Store the deterministic flag returned by <udf>_init into the 
+       udf_handler. 
+       - Don't implement Item_udf_func::fix_fields, implement
+       Item_udf_func::fix_length_and_dec() instead (similar to non-UDF
+       functions).
+       - Override Item_func::update_used_tables to call 
+       Item_func::update_used_tables() and add a RAND_TABLE_BIT to the 
+       result of Item_func::update_used_tables() if the UDF is 
+       non-deterministic.
+       - (optionally) rename RAND_TABLE_BIT to NONDETERMINISTIC_BIT to
+       better describe its usage.
+       
+      The above would require a change of the UDF API.
+      Until that change is done here's how the current code works:
+      We call Item_func::update_used_tables() only when we know that
+      the function depends on real non-const tables and is deterministic.
+      This can be done only because we know that the optimizer will
+      call update_used_tables() only when there's possibly a new const
+      table. So update_used_tables() can only make a Item_func more
+      constant than it is currently.
+      That's why we don't need to do anything if a function is guaranteed
+      to return non-constant (it's non-deterministic) or is already a
+      const.
+    */  
+    if ((used_tables_cache & ~PSEUDO_TABLE_BITS) && 
+        !(used_tables_cache & RAND_TABLE_BIT))
+    {
+      Item_func::update_used_tables();
+      set_non_deterministic_if_needed();
+    }
+  }
+  void cleanup();
+  bool eval_not_null_tables(void *opt_arg)
+  {
+    not_null_tables_cache= 0;
+    return 0;
+  }
+  bool find_not_null_fields(table_map allowed)
+  {
+    return false;
+  }
+  bool is_expensive() { return 1; }
+  virtual void print(String *str, enum_query_type query_type);
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_NON_DETERMINISTIC);
+  }
+  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+  {
+    return type_handler()->Item_get_date_with_warn(thd, this, ltime, fuzzydate);
+  }
+  bool excl_dep_on_grouping_fields(st_select_lex *sel)
+  { return false; }
+};
+
+
+class Item_func_udf_float :public Item_udf_func
+{
+ public:
+  Item_func_udf_float(THD *thd, udf_func *udf_arg):
+    Item_udf_func(thd, udf_arg) {}
+  Item_func_udf_float(THD *thd, udf_func *udf_arg,
+                      List<Item> &list):
+    Item_udf_func(thd, udf_arg, list) {}
+  longlong val_int()
+  {
+    DBUG_ASSERT(fixed == 1);
+    return Converter_double_to_longlong(Item_func_udf_float::val_real(),
+                                        unsigned_flag).result();
+  }
+  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);
+  const Type_handler *type_handler() const { return &type_handler_double; }
+  bool fix_length_and_dec() { fix_num_length_and_dec(); return FALSE; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_udf_float>(thd, this); }
+};
+
+
+class Item_func_udf_int :public Item_udf_func
+{
+public:
+  Item_func_udf_int(THD *thd, udf_func *udf_arg):
+    Item_udf_func(thd, udf_arg) {}
+  Item_func_udf_int(THD *thd, udf_func *udf_arg,
+                    List<Item> &list):
+    Item_udf_func(thd, udf_arg, list) {}
+  longlong val_int();
+  double val_real() { return (double) Item_func_udf_int::val_int(); }
+  my_decimal *val_decimal(my_decimal *decimal_value)
+  {
+    return val_decimal_from_int(decimal_value);
+  }
+  String *val_str(String *str);
+  const Type_handler *type_handler() const
+  {
+    if (unsigned_flag)
+      return &type_handler_ulonglong;
+    return &type_handler_slonglong;
+  }
+  bool fix_length_and_dec() { decimals= 0; max_length= 21; return FALSE; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_udf_int>(thd, this); }
+};
+
+
+class Item_func_udf_decimal :public Item_udf_func
+{
+public:
+  Item_func_udf_decimal(THD *thd, udf_func *udf_arg):
+    Item_udf_func(thd, udf_arg) {}
+  Item_func_udf_decimal(THD *thd, udf_func *udf_arg, List<Item> &list):
+    Item_udf_func(thd, udf_arg, list) {}
+  longlong val_int()
+  {
+    return VDec_udf(this, &udf).to_longlong(unsigned_flag);
+  }
+  double val_real()
+  {
+    return VDec_udf(this, &udf).to_double();
+  }
+  my_decimal *val_decimal(my_decimal *);
+  String *val_str(String *str)
+  {
+    return VDec_udf(this, &udf).to_string_round(str, decimals);
+  }
+  const Type_handler *type_handler() const { return &type_handler_newdecimal; }
+  bool fix_length_and_dec() { fix_num_length_and_dec(); return FALSE; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_udf_decimal>(thd, this); }
+};
+
+
+class Item_func_udf_str :public Item_udf_func
+{
+public:
+  Item_func_udf_str(THD *thd, udf_func *udf_arg):
+    Item_udf_func(thd, udf_arg) {}
+  Item_func_udf_str(THD *thd, udf_func *udf_arg, List<Item> &list):
+    Item_udf_func(thd, udf_arg, list) {}
+  String *val_str(String *);
+  double val_real()
+  {
+    int err_not_used;
+    char *end_not_used;
+    String *res;
+    res= val_str(&str_value);
+    return res ? res->charset()->strntod((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 ? res->charset()->strntoll(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;
+  }
+  const Type_handler *type_handler() const { return string_type_handler(); }
+  bool fix_length_and_dec();
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_udf_str>(thd, this); }
+};
+
+#else /* Dummy functions to get yy_*.cc files compiled */
+
+class Item_func_udf_float :public Item_real_func
+{
+ public:
+  Item_func_udf_float(THD *thd, udf_func *udf_arg):
+    Item_real_func(thd) {}
+  Item_func_udf_float(THD *thd, udf_func *udf_arg, List<Item> &list):
+    Item_real_func(thd, 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(THD *thd, udf_func *udf_arg):
+    Item_int_func(thd) {}
+  Item_func_udf_int(THD *thd, udf_func *udf_arg, List<Item> &list):
+    Item_int_func(thd, list) {}
+  const Type_handler *type_handler() const { return &type_handler_slonglong; }
+  longlong val_int() { DBUG_ASSERT(fixed == 1); return 0; }
+};
+
+
+class Item_func_udf_decimal :public Item_int_func
+{
+public:
+  Item_func_udf_decimal(THD *thd, udf_func *udf_arg):
+    Item_int_func(thd) {}
+  Item_func_udf_decimal(THD *thd, udf_func *udf_arg, List<Item> &list):
+    Item_int_func(thd, list) {}
+  const Type_handler *type_handler() const { return &type_handler_slonglong; }
+  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(THD *thd, udf_func *udf_arg):
+    Item_func(thd) {}
+  Item_func_udf_str(THD *thd, udf_func *udf_arg, List<Item> &list):
+    Item_func(thd, 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; }
+  bool fix_length_and_dec() { maybe_null=1; max_length=0; return FALSE; }
+};
+
+#endif /* HAVE_DLOPEN */
+
+void mysql_ull_cleanup(THD *thd);
+void mysql_ull_set_explicit_lock_duration(THD *thd);
+
+
+class Item_func_lock :public Item_long_func
+{
+ public:
+  Item_func_lock(THD *thd): Item_long_func(thd) { }
+  Item_func_lock(THD *thd, Item *a): Item_long_func(thd, a) {}
+  Item_func_lock(THD *thd, Item *a, Item *b): Item_long_func(thd, a, b) {}
+  table_map used_tables() const
+  {
+    return used_tables_cache | RAND_TABLE_BIT;
+  }
+  bool const_item() const { return 0; }
+  bool is_expensive() { return 1; }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+};
+
+
+class Item_func_get_lock final :public Item_func_lock
+{
+  bool check_arguments() const
+  {
+    return args[0]->check_type_general_purpose_string(func_name()) ||
+           args[1]->check_type_can_return_real(func_name());
+  }
+  String value;
+ public:
+  Item_func_get_lock(THD *thd, Item *a, Item *b) :Item_func_lock(thd, a, b) {}
+  longlong val_int() final;
+  const char *func_name() const final { return "get_lock"; }
+  bool fix_length_and_dec() { max_length= 1; maybe_null= 1; return FALSE; }
+  Item *get_copy(THD *thd) final
+  { return get_item_copy<Item_func_get_lock>(thd, this); }
+};
+
+
+class Item_func_release_all_locks final :public Item_func_lock
+{
+public:
+  Item_func_release_all_locks(THD *thd): Item_func_lock(thd)
+  { unsigned_flag= 1; }
+  longlong val_int() final;
+  const char *func_name() const final { return "release_all_locks"; }
+  Item *get_copy(THD *thd) final
+  { return get_item_copy<Item_func_release_all_locks>(thd, this); }
+};
+
+
+class Item_func_release_lock final :public Item_func_lock
+{
+  bool check_arguments() const
+  { return args[0]->check_type_general_purpose_string(func_name()); }
+  String value;
+public:
+  Item_func_release_lock(THD *thd, Item *a): Item_func_lock(thd, a) {}
+  longlong val_int() final;
+  const char *func_name() const { return "release_lock"; }
+  bool fix_length_and_dec() { max_length= 1; maybe_null= 1; return FALSE; }
+  Item *get_copy(THD *thd) final
+  { return get_item_copy<Item_func_release_lock>(thd, this); }
+};
+
+
+/* replication functions */
+
+class Item_master_pos_wait :public Item_longlong_func
+{
+  bool check_arguments() const
+  {
+    return
+      args[0]->check_type_general_purpose_string(func_name()) ||
+      args[1]->check_type_can_return_int(func_name()) ||
+      (arg_count > 2 && args[2]->check_type_can_return_int(func_name())) ||
+      (arg_count > 3 && args[3]->check_type_general_purpose_string(func_name()));
+  }
+  String value;
+public:
+  Item_master_pos_wait(THD *thd, Item *a, Item *b)
+   :Item_longlong_func(thd, a, b) {}
+  Item_master_pos_wait(THD *thd, Item *a, Item *b, Item *c):
+    Item_longlong_func(thd, a, b, c) {}
+  Item_master_pos_wait(THD *thd, Item *a, Item *b, Item *c, Item *d):
+    Item_longlong_func(thd, a, b, c, d) {}
+  longlong val_int();
+  const char *func_name() const { return "master_pos_wait"; }
+  bool fix_length_and_dec() { max_length=21; maybe_null=1; return FALSE; }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_master_pos_wait>(thd, this); }
+};
+
+
+class Item_master_gtid_wait :public Item_long_func
+{
+  bool check_arguments() const
+  {
+    return args[0]->check_type_general_purpose_string(func_name()) ||
+           (arg_count > 1 && args[1]->check_type_can_return_real(func_name()));
+  }
+  String value;
+public:
+  Item_master_gtid_wait(THD *thd, Item *a)
+   :Item_long_func(thd, a) {}
+  Item_master_gtid_wait(THD *thd, Item *a, Item *b)
+   :Item_long_func(thd, a, b) {}
+  longlong val_int();
+  const char *func_name() const { return "master_gtid_wait"; }
+  bool fix_length_and_dec() { max_length=2; return FALSE; }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_master_gtid_wait>(thd, this); }
+};
+
+
+/* Handling of user definable variables */
+
+class user_var_entry;
+
+
+/**
+  A class to set and get user variables
+*/
+class Item_func_user_var :public Item_hybrid_func
+{
+protected:
+  user_var_entry *m_var_entry;
+public:
+  LEX_CSTRING name; // keep it public
+  Item_func_user_var(THD *thd, const LEX_CSTRING *a)
+    :Item_hybrid_func(thd), m_var_entry(NULL), name(*a) { }
+  Item_func_user_var(THD *thd, const LEX_CSTRING *a, Item *b)
+    :Item_hybrid_func(thd, b), m_var_entry(NULL), name(*a) { }
+  Item_func_user_var(THD *thd, Item_func_user_var *item)
+    :Item_hybrid_func(thd, item),
+    m_var_entry(item->m_var_entry), name(item->name) { }
+  Field *create_tmp_field_ex(MEM_ROOT *root, TABLE *table, Tmp_field_src *src,
+                             const Tmp_field_param *param)
+  {
+    DBUG_ASSERT(fixed);
+    return create_tmp_field_ex_from_handler(root, table, src, param,
+                                            type_handler());
+  }
+  Field *create_field_for_create_select(MEM_ROOT *root, TABLE *table)
+  { return create_table_field_from_handler(root, table); }
+  bool check_vcol_func_processor(void *arg);
+  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+  {
+    return type_handler()->Item_get_date_with_warn(thd, this, ltime, fuzzydate);
+  }
+};
+
+
+class Item_func_set_user_var :public Item_func_user_var
+{
+  /*
+    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;
+  String value;
+  my_decimal decimal_buff;
+  bool null_item;
+  union
+  {
+    longlong vint;
+    double vreal;
+    String *vstr;
+    my_decimal *vdec;
+  } save_result;
+
+public:
+  Item_func_set_user_var(THD *thd, const LEX_CSTRING *a, Item *b):
+    Item_func_user_var(thd, a, b),
+    entry_thread_id(0)
+  {}
+  Item_func_set_user_var(THD *thd, Item_func_set_user_var *item)
+    :Item_func_user_var(thd, item),
+    entry_thread_id(item->entry_thread_id),
+    value(item->value), decimal_buff(item->decimal_buff),
+    null_item(item->null_item), save_result(item->save_result)
+  {}
+
+  enum Functype functype() const { return SUSERVAR_FUNC; }
+  double val_real();
+  longlong val_int();
+  String *val_str(String *str);
+  my_decimal *val_decimal(my_decimal *);
+  double val_result();
+  longlong val_int_result();
+  bool val_bool_result();
+  String *str_result(String *str);
+  my_decimal *val_decimal_result(my_decimal *);
+  bool is_null_result();
+  bool update_hash(void *ptr, size_t length, enum Item_result type,
+                   CHARSET_INFO *cs, bool unsigned_arg);
+  bool send(Protocol *protocol, st_value *buffer);
+  void make_send_field(THD *thd, Send_field *tmp_field);
+  bool check(bool use_result_field);
+  void save_item_result(Item *item);
+  bool update();
+  bool fix_fields(THD *thd, Item **ref);
+  bool fix_length_and_dec();
+  void print(String *str, enum_query_type query_type);
+  enum precedence precedence() const { return ASSIGN_PRECEDENCE; }
+  void print_as_stmt(String *str, enum_query_type query_type);
+  const char *func_name() const { return "set_user_var"; }
+  int save_in_field(Field *field, bool no_conversions,
+                    bool can_use_result_field);
+  int save_in_field(Field *field, bool no_conversions)
+  {
+    return save_in_field(field, no_conversions, 1);
+  }
+  void save_org_in_field(Field *field,
+                         fast_field_copier data __attribute__ ((__unused__)))
+    { (void)save_in_field(field, 1, 0); }
+  bool register_field_in_read_map(void *arg);
+  bool register_field_in_bitmap(void *arg);
+  bool set_entry(THD *thd, bool create_if_not_exists);
+  void cleanup();
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_set_user_var>(thd, this); }
+  bool excl_dep_on_table(table_map tab_map) { return false; }
+};
+
+
+class Item_func_get_user_var :public Item_func_user_var,
+                              private Settable_routine_parameter
+{
+public:
+  Item_func_get_user_var(THD *thd, const LEX_CSTRING *a):
+    Item_func_user_var(thd, a) {}
+  enum Functype functype() const { return GUSERVAR_FUNC; }
+  LEX_CSTRING get_name() { return name; }
+  double val_real();
+  longlong val_int();
+  my_decimal *val_decimal(my_decimal*);
+  String *val_str(String* str);
+  bool fix_length_and_dec();
+  virtual void print(String *str, enum_query_type query_type);
+  /*
+    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; }
+  bool eq(const Item *item, bool binary_cmp) const;
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_get_user_var>(thd, this); }
+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_fixed_hybrid,
+                                  public Load_data_outvar
+{
+  LEX_CSTRING org_name;
+  user_var_entry *entry;
+public:
+  Item_user_var_as_out_param(THD *thd, const LEX_CSTRING *a)
+  :Item_fixed_hybrid(thd)
+  {
+    DBUG_ASSERT(a->length < UINT_MAX32);
+    org_name= *a;
+    set_name(thd, a->str, a->length, system_charset_info);
+  }
+  Load_data_outvar *get_load_data_outvar()
+  {
+    return this;
+  }
+  bool load_data_set_null(THD *thd, const Load_data_param *param)
+  {
+    set_null_value(param->charset());
+    return false;
+  }
+  bool load_data_set_no_data(THD *thd, const Load_data_param *param)
+  {
+    set_null_value(param->charset());
+    return false;
+  }
+  bool load_data_set_value(THD *thd, const char *pos, uint length,
+                           const Load_data_param *param)
+  {
+    set_value(pos, length, param->charset());
+    return false;
+  }
+  void load_data_print_for_log_event(THD *thd, String *to) const;
+  bool load_data_add_outvar(THD *thd, Load_data_param *param) const
+  {
+    return param->add_outvar_user_var(thd);
+  }
+  uint load_data_fixed_length() const
+  {
+    return 0;
+  }
+  Field *create_tmp_field_ex(MEM_ROOT *root, TABLE *table, Tmp_field_src *src,
+                             const Tmp_field_param *param)
+  {
+    DBUG_ASSERT(0);
+    return NULL;
+  }
+  /* We should return something different from FIELD_ITEM here */
+  enum Type type() const { return CONST_ITEM;}
+  double val_real();
+  longlong val_int();
+  String *val_str(String *str);
+  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
+  my_decimal *val_decimal(my_decimal *decimal_buffer);
+  /* fix_fields() binds variable name with its entry structure */
+  bool fix_fields(THD *thd, Item **ref);
+  void set_null_value(CHARSET_INFO* cs);
+  void set_value(const char *str, uint length, CHARSET_INFO* cs);
+  const Type_handler *type_handler() const { return &type_handler_double; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_user_var_as_out_param>(thd, this); }
+};
+
+
+/* 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_func
+{
+  sys_var *var;
+  enum_var_type var_type, orig_var_type;
+  LEX_CSTRING component;
+  longlong cached_llval;
+  double cached_dval;
+  String cached_strval;
+  bool cached_null_value;
+  query_id_t used_query_id;
+  uchar cache_present;
+
+public:
+  Item_func_get_system_var(THD *thd, sys_var *var_arg,
+                           enum_var_type var_type_arg,
+                           LEX_CSTRING *component_arg, const char *name_arg,
+                           size_t name_len_arg);
+  enum Functype functype() const { return GSYSVAR_FUNC; }
+  void update_null_value();
+  bool fix_length_and_dec();
+  void print(String *str, enum_query_type query_type);
+  bool const_item() const { return true; }
+  table_map used_tables() const { return 0; }
+  const Type_handler *type_handler() 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); }
+  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+  {
+    return type_handler()->Item_get_date_with_warn(thd, this, ltime, fuzzydate);
+  }
+  /* TODO: fix to support views */
+  const char *func_name() const { return "get_system_var"; }
+  /**
+    Indicates whether this system variable is written to the binlog or not.
+
+    Variables are written to the binlog as part of "status_vars" in
+    Query_log_event, as an Intvar_log_event, or a Rand_log_event.
+
+    @return true if the variable is written to the binlog, false otherwise.
+  */
+  bool is_written_to_binlog();
+  bool eq(const Item *item, bool binary_cmp) const;
+
+  void cleanup();
+  bool check_vcol_func_processor(void *arg);
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_get_system_var>(thd, this); }
+};
+
+
+/* for fulltext search */
+
+class Item_func_match :public Item_real_func
+{
+public:
+  uint key, flags;
+  bool join_key;
+  DTCollation cmp_collation;
+  FT_INFO *ft_handler;
+  TABLE *table;
+  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(THD *thd, List<Item> &a, uint b):
+    Item_real_func(thd, a), key(0), flags(b), join_key(0), ft_handler(0),
+    table(0), master(0), concat_ws(0) { }
+  void cleanup()
+  {
+    DBUG_ENTER("Item_func_match::cleanup");
+    Item_real_func::cleanup();
+    if (!master && ft_handler)
+      ft_handler->please->close_search(ft_handler);
+    ft_handler= 0;
+    concat_ws= 0;
+    table= 0;           // required by Item_func_match::eq()
+    DBUG_VOID_RETURN;
+  }
+  bool is_expensive_processor(void *arg) { return TRUE; }
+  enum Functype functype() const { return FT_FUNC; }
+  const char *func_name() const { return "match"; }
+  bool eval_not_null_tables(void *opt_arg)
+  {
+    not_null_tables_cache= 0;
+    return 0;
+  }
+  bool find_not_null_fields(table_map allowed)
+  {
+    return false;
+  }
+  bool fix_fields(THD *thd, Item **ref);
+  bool eq(const Item *, bool binary_cmp) const;
+  /* 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();
+  bool init_search(THD *thd, bool no_order);
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function("match ... against()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_match>(thd, this); }
+  Item *build_clone(THD *thd) { return 0; }
+private:
+  /**
+     Check whether storage engine for given table, 
+     allows FTS Boolean search on non-indexed columns.
+
+     @todo A flag should be added to the extended fulltext API so that 
+           it may be checked whether search on non-indexed columns are 
+           supported. Currently, it is not possible to check for such a 
+           flag since @c this->ft_handler is not yet set when this function is 
+           called.  The current hack is to assume that search on non-indexed
+           columns are supported for engines that does not support the extended
+           fulltext API (e.g., MyISAM), while it is not supported for other 
+           engines (e.g., InnoDB)
+
+     @param table_arg Table for which storage engine to check
+
+     @retval true if BOOLEAN search on non-indexed columns is supported
+     @retval false otherwise
+   */
+  bool allows_search_on_non_indexed_columns(TABLE* table_arg)
+  {
+    // Only Boolean search may support non_indexed columns
+    if (!(flags & FT_BOOL))
+      return false;
+
+    DBUG_ASSERT(table_arg && table_arg->file);
+
+    // Assume that if extended fulltext API is not supported,
+    // non-indexed columns are allowed.  This will be true for MyISAM.
+    if ((table_arg->file->ha_table_flags() & HA_CAN_FULLTEXT_EXT) == 0)
+      return true;
+
+    return false;
+  }
+};
+
+
+class Item_func_bit_xor : public Item_func_bit_operator
+{
+public:
+  Item_func_bit_xor(THD *thd, Item *a, Item *b)
+   :Item_func_bit_operator(thd, a, b) {}
+  bool fix_length_and_dec();
+  const char *func_name() const { return "^"; }
+  enum precedence precedence() const { return BITXOR_PRECEDENCE; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_bit_xor>(thd, this); }
+};
+
+class Item_func_is_free_lock :public Item_long_func
+{
+  bool check_arguments() const
+  { return args[0]->check_type_general_purpose_string(func_name()); }
+  String value;
+public:
+  Item_func_is_free_lock(THD *thd, Item *a): Item_long_func(thd, a) {}
+  longlong val_int();
+  const char *func_name() const { return "is_free_lock"; }
+  bool fix_length_and_dec()
+  {
+    decimals=0; max_length=1; maybe_null=1;
+    return FALSE;
+  }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_is_free_lock>(thd, this); }
+};
+
+class Item_func_is_used_lock :public Item_long_func
+{
+  bool check_arguments() const
+  { return args[0]->check_type_general_purpose_string(func_name()); }
+  String value;
+public:
+  Item_func_is_used_lock(THD *thd, Item *a): Item_long_func(thd, a) {}
+  longlong val_int();
+  const char *func_name() const { return "is_used_lock"; }
+  bool fix_length_and_dec()
+  {
+    decimals=0; max_length=10; maybe_null=1;
+    return FALSE;
+  }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_is_used_lock>(thd, this); }
+};
+
+
+struct Lex_cast_type_st: public Lex_length_and_dec_st
+{
+private:
+  const Type_handler *m_type_handler;
+public:
+  void set(const Type_handler *handler, const char *length, const char *dec)
+  {
+    m_type_handler= handler;
+    Lex_length_and_dec_st::set(length, dec);
+  }
+  void set(const Type_handler *handler, Lex_length_and_dec_st length_and_dec)
+  {
+    m_type_handler= handler;
+    Lex_length_and_dec_st::operator=(length_and_dec);
+  }
+  void set(const Type_handler *handler, const char *length)
+  {
+    set(handler, length, 0);
+  }
+  void set(const Type_handler *handler)
+  {
+    set(handler, 0, 0);
+  }
+  const Type_handler *type_handler() const { return m_type_handler; }
+  Item *create_typecast_item(THD *thd, Item *item,
+                             CHARSET_INFO *cs= NULL) const
+  {
+    return m_type_handler->
+      create_typecast_item(thd, item,
+                           Type_cast_attributes(length(), dec(), cs));
+  }
+  Item *create_typecast_item_or_error(THD *thd, Item *item,
+                                      CHARSET_INFO *cs= NULL) const;
+};
+
+
+class Item_func_row_count :public Item_longlong_func
+{
+public:
+  Item_func_row_count(THD *thd): Item_longlong_func(thd) {}
+  longlong val_int();
+  const char *func_name() const { return "row_count"; }
+  bool fix_length_and_dec() { decimals= 0; maybe_null=0; return FALSE; }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_row_count>(thd, this); }
+};
+
+
+/*
+ *
+ * Stored FUNCTIONs
+ *
+ */
+
+class Item_func_sp :public Item_func,
+                    public Item_sp
+{
+private:
+  const Sp_handler *m_handler;
+
+  bool execute();
+
+protected:
+  bool is_expensive_processor(void *arg)
+  { return is_expensive(); }
+
+  bool check_arguments() const
+  {
+    // sp_prepare_func_item() checks that the number of columns is correct
+    return false;
+  } 
+public:
+
+  Item_func_sp(THD *thd, Name_resolution_context *context_arg,
+               sp_name *name, const Sp_handler *sph);
+
+  Item_func_sp(THD *thd, Name_resolution_context *context_arg,
+               sp_name *name, const Sp_handler *sph, List<Item> &list);
+
+  virtual ~Item_func_sp()
+  {}
+
+  void update_used_tables();
+
+  void cleanup();
+
+  const char *func_name() const;
+
+  const Type_handler *type_handler() const;
+
+  Field *create_tmp_field_ex(MEM_ROOT *root, TABLE *table, Tmp_field_src *src,
+                             const Tmp_field_param *param);
+  Field *create_field_for_create_select(MEM_ROOT *root, TABLE *table)
+  {
+    return result_type() != STRING_RESULT ?
+           sp_result_field :
+           create_table_field_from_handler(root, table);
+  }
+  void make_send_field(THD *thd, Send_field *tmp_field);
+
+  longlong val_int()
+  {
+    if (execute())
+      return (longlong) 0;
+    return sp_result_field->val_int();
+  }
+
+  double val_real()
+  {
+    if (execute())
+      return 0.0;
+    return sp_result_field->val_real();
+  }
+
+  my_decimal *val_decimal(my_decimal *dec_buf)
+  {
+    if (execute())
+      return NULL;
+    return sp_result_field->val_decimal(dec_buf);
+  }
+
+  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+  {
+    if (execute())
+      return true;
+    return sp_result_field->get_date(ltime, fuzzydate);
+  }
+
+  String *val_str(String *str)
+  {
+    String buf;
+    char buff[20];
+    buf.set(buff, 20, str->charset());
+    buf.length(0);
+    if (execute())
+      return NULL;
+    /*
+      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.
+    */
+    sp_result_field->val_str(&buf);
+    str->copy(buf);
+    return str;
+  }
+
+  bool val_native(THD *thd, Native *to)
+  {
+    if (execute())
+      return true;
+    return null_value= sp_result_field->val_native(to);
+  }
+
+  void update_null_value()
+  { 
+    execute();
+  }
+
+  virtual bool change_context_processor(void *cntx)
+    { context= (Name_resolution_context *)cntx; return FALSE; }
+
+  virtual enum Functype functype() const { return FUNC_SP; }
+
+  bool fix_fields(THD *thd, Item **ref);
+  bool fix_length_and_dec(void);
+  bool is_expensive();
+
+  inline Field *get_sp_result_field()
+  {
+    return sp_result_field;
+  }
+  const sp_name *get_sp_name() const
+  {
+    return m_name;
+  }
+
+  bool check_vcol_func_processor(void *arg);
+  bool limit_index_condition_pushdown_processor(void *opt_arg)
+  {
+    return TRUE;
+  }
+  Item *get_copy(THD *) { return 0; }
+  bool eval_not_null_tables(void *opt_arg)
+  {
+    not_null_tables_cache= 0;
+    return 0;
+  }
+  bool excl_dep_on_grouping_fields(st_select_lex *sel)
+  { return false; }
+  bool find_not_null_fields(table_map allowed)
+  {
+    return false;
+  }
+};
+
+
+class Item_func_found_rows :public Item_longlong_func
+{
+public:
+  Item_func_found_rows(THD *thd): Item_longlong_func(thd) {}
+  longlong val_int();
+  const char *func_name() const { return "found_rows"; }
+  bool fix_length_and_dec() { decimals= 0; maybe_null=0; return FALSE; }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_found_rows>(thd, this); }
+};
+
+
+class Item_func_oracle_sql_rowcount :public Item_longlong_func
+{
+public:
+  Item_func_oracle_sql_rowcount(THD *thd): Item_longlong_func(thd) {}
+  longlong val_int();
+  const char *func_name() const { return "SQL%ROWCOUNT"; }
+  void print(String *str, enum_query_type query_type)
+  {
+    str->append(func_name());
+  }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_oracle_sql_rowcount>(thd, this); }
+};
+
+
+class Item_func_sqlcode: public Item_long_func
+{
+public:
+  Item_func_sqlcode(THD *thd): Item_long_func(thd) { }
+  longlong val_int();
+  const char *func_name() const { return "SQLCODE"; }
+  void print(String *str, enum_query_type query_type)
+  {
+    str->append(func_name());
+  }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_IMPOSSIBLE);
+  }
+  bool fix_length_and_dec()
+  {
+    maybe_null= null_value= false;
+    max_length= 11;
+    return FALSE;
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_sqlcode>(thd, this); }
+};
+
+
+void uuid_short_init();
+
+class Item_func_uuid_short :public Item_longlong_func
+{
+public:
+  Item_func_uuid_short(THD *thd): Item_longlong_func(thd) {}
+  const char *func_name() const { return "uuid_short"; }
+  longlong val_int();
+  bool const_item() const { return false; }
+  bool fix_length_and_dec()
+  { max_length= 21; unsigned_flag=1; return FALSE; }
+  table_map used_tables() const { return RAND_TABLE_BIT; }
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg, VCOL_NON_DETERMINISTIC);
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_uuid_short>(thd, this); }
+};
+
+
+class Item_func_last_value :public Item_func
+{
+protected:
+  Item *last_value;
+public:
+  Item_func_last_value(THD *thd, List<Item> &list): Item_func(thd, list) {}
+  double val_real();
+  longlong val_int();
+  String *val_str(String *);
+  my_decimal *val_decimal(my_decimal *);
+  bool get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate);
+  bool val_native(THD *thd, Native *);
+  bool fix_length_and_dec();
+  const char *func_name() const { return "last_value"; }
+  const Type_handler *type_handler() const { return last_value->type_handler(); }
+  bool eval_not_null_tables(void *)
+  {
+    not_null_tables_cache= 0;
+    return 0;
+  }
+  bool find_not_null_fields(table_map allowed)
+  {
+    return false;
+  }
+  bool const_item() const { return 0; }
+  void evaluate_sideeffects();
+  void update_used_tables()
+  {
+    Item_func::update_used_tables();
+    maybe_null= last_value->maybe_null;
+  }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_last_value>(thd, this); }
+};
+
+
+/* Implementation for sequences: NEXT VALUE FOR sequence and NEXTVAL() */
+
+class Item_func_nextval :public Item_longlong_func
+{
+protected:
+  TABLE_LIST *table_list;
+  TABLE *table;
+public:
+  Item_func_nextval(THD *thd, TABLE_LIST *table_list_arg):
+  Item_longlong_func(thd), table_list(table_list_arg) {}
+  longlong val_int();
+  const char *func_name() const { return "nextval"; }
+  bool fix_length_and_dec()
+  {
+    unsigned_flag= 0;
+    max_length= MAX_BIGINT_WIDTH;
+    maybe_null= 1;                              /* In case of errors */
+    return FALSE;
+  }
+  /*
+    update_table() function must be called during the value function
+    as in case of DEFAULT the sequence table may not yet be open
+    while fix_fields() are called
+  */
+  void update_table()
+  {
+    if (!(table= table_list->table))
+    {
+      /*
+        If nextval was used in DEFAULT then next_local points to
+        the table_list used by to open the sequence table
+      */
+      table= table_list->next_local->table;
+    }
+  }
+  bool const_item() const { return 0; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_nextval>(thd, this); }
+  void print(String *str, enum_query_type query_type);
+  bool check_vcol_func_processor(void *arg)
+  {
+    return mark_unsupported_function(func_name(), "()", arg,
+                                     (VCOL_NON_DETERMINISTIC |
+                                      VCOL_NOT_VIRTUAL));
+  }
+};
+
+
+/* Implementation for sequences: LASTVAL(sequence), PostgreSQL style */
+
+class Item_func_lastval :public Item_func_nextval
+{
+public:
+  Item_func_lastval(THD *thd, TABLE_LIST *table_list_arg):
+  Item_func_nextval(thd, table_list_arg) {}
+  longlong val_int();
+  const char *func_name() const { return "lastval"; }
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_lastval>(thd, this); }
+};
+
+
+/* Implementation for sequences: SETVAL(sequence), PostgreSQL style */
+
+class Item_func_setval :public Item_func_nextval
+{
+  longlong nextval;
+  ulonglong round;
+  bool is_used;
+public:
+  Item_func_setval(THD *thd, TABLE_LIST *table_list_arg, longlong nextval_arg,
+                   ulonglong round_arg, bool is_used_arg)
+    : Item_func_nextval(thd, table_list_arg),
+    nextval(nextval_arg), round(round_arg), is_used(is_used_arg)
+  {}
+  longlong val_int();
+  const char *func_name() const { return "setval"; }
+  void print(String *str, enum_query_type query_type);
+  Item *get_copy(THD *thd)
+  { return get_item_copy<Item_func_setval>(thd, this); }
+};
+
+
+Item *get_system_var(THD *thd, enum_var_type var_type,
+                     const LEX_CSTRING *name, const LEX_CSTRING *component);
+extern bool check_reserved_words(const LEX_CSTRING *name);
+double my_double_round(double value, longlong dec, bool dec_unsigned,
+                       bool truncate);
+
+extern bool volatile  mqh_used;
+
+bool update_hash(user_var_entry *entry, bool set_null, void *ptr, size_t length,
+                 Item_result type, CHARSET_INFO *cs,
+                 bool unsigned_arg);
+
+#endif /* ITEM_FUNC_INCLUDED */