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

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

1 files changed, 5974 insertions, 0 deletions

diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
new file mode 100644
index 00000000..4bbf36ec
--- /dev/null
+++ b/sql/item_strfunc.cc
@@ -0,0 +1,5974 @@
+/*
+   Copyright (c) 2000, 2017, Oracle and/or its affiliates.
+   Copyright (c) 2009, 2022, MariaDB Corporation.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335  USA
+*/
+
+/**
+  @file
+
+  @brief
+  This file defines all string functions
+
+  @warning
+    Some string functions don't always put and end-null on a String.
+    (This shouldn't be needed)
+*/
+
+#ifdef USE_PRAGMA_IMPLEMENTATION
+#pragma implementation				// gcc: Class implementation
+#endif
+
+#include "mariadb.h"                          // HAVE_*
+
+#include "sql_priv.h"
+/*
+  It is necessary to include set_var.h instead of item.h because there
+  are dependencies on include order for set_var.h and item.h. This
+  will be resolved later.
+*/
+#include "sql_class.h"                          // set_var.h: THD
+#include "set_var.h"
+#include "sql_base.h"
+#include "sql_time.h"
+#include "des_key_file.h"       // st_des_keyschedule, st_des_keyblock
+#include "password.h"           // my_make_scrambled_password,
+                                // my_make_scrambled_password_323
+#include <m_ctype.h>
+#include <my_md5.h>
+C_MODE_START
+#include "../mysys/my_static.h"			// For soundex_map
+C_MODE_END
+#include "sql_show.h"                           // append_identifier
+#include <sql_repl.h>
+#include "sql_statistics.h"
+
+/* fmtlib include (https://fmt.dev/). */
+#define FMT_STATIC_THOUSANDS_SEPARATOR ','
+#define FMT_HEADER_ONLY 1
+#include "fmt/format-inl.h"
+
+size_t username_char_length= USERNAME_CHAR_LENGTH;
+
+/*
+  Calculate max length of string from length argument to LEFT and RIGHT
+*/
+
+static uint32 max_length_for_string(Item *item)
+{
+  ulonglong length= item->val_int();
+  /* Note that if value is NULL, val_int() returned 0 */
+  if (length > (ulonglong) INT_MAX32)
+  {
+    /* Limit string length to maxium string length in MariaDB (2G) */
+    length= item->unsigned_flag ? (ulonglong) INT_MAX32 : 0;
+  }
+  return (uint32) length;
+}
+
+
+/*
+  For the Items which have only val_str_ascii() method
+  and don't have their own "native" val_str(),
+  we provide a "wrapper" method to convert from ASCII
+  to Item character set when it's necessary.
+  Conversion happens only in case of "tricky" Item character set (e.g. UCS2).
+  Normally conversion does not happen, and val_str_ascii() is immediately
+  returned instead.
+
+  No matter if conversion is needed or not needed,
+  the result is always returned in "str" (see MDEV-10306 why).
+
+  @param [OUT] str          - Store the result here
+  @param [IN]  ascii_buffer - Use this temporary buffer to call val_str_ascii()
+*/
+String *Item_func::val_str_from_val_str_ascii(String *str, String *ascii_buffer)
+{
+  DBUG_ASSERT(fixed());
+
+  if (!(collation.collation->state & MY_CS_NONASCII))
+  {
+    String *res= val_str_ascii(str);
+    if (res)
+      res->set_charset(collation.collation);
+    return res;
+  }
+  
+  DBUG_ASSERT(str != ascii_buffer);
+  
+  uint errors;
+  String *res= val_str_ascii(ascii_buffer);
+  if (!res)
+    return 0;
+  
+  if ((null_value= str->copy(res->ptr(), res->length(),
+                             &my_charset_latin1, collation.collation,
+                             &errors)))
+    return 0;
+  
+  return str;
+}
+
+
+bool Item_str_func::fix_fields(THD *thd, Item **ref)
+{
+  bool res= Item_func::fix_fields(thd, ref);
+  /*
+    In Item_str_func::check_well_formed_result() we may set null_value
+    flag on the same condition as in test() below.
+  */
+  if (thd->is_strict_mode())
+    set_maybe_null();
+  return res;
+}
+
+
+my_decimal *Item_str_func::val_decimal(my_decimal *decimal_value)
+{
+  DBUG_ASSERT(fixed());
+  StringBuffer<64> tmp;
+  String *res= val_str(&tmp);
+  return res ? decimal_from_string_with_check(decimal_value, res) : 0;
+}
+
+
+double Item_str_func::val_real()
+{
+  DBUG_ASSERT(fixed());
+  StringBuffer<64> tmp;
+  String *res= val_str(&tmp);
+  return res ? double_from_string_with_check(res) : 0.0;
+}
+
+
+longlong Item_str_func::val_int()
+{
+  DBUG_ASSERT(fixed());
+  StringBuffer<22> tmp;
+  String *res= val_str(&tmp);
+  return res ? longlong_from_string_with_check(res) : 0;
+}
+
+
+String *Item_func_md5::val_str_ascii(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String * sptr= args[0]->val_str(str);
+  if (sptr)
+  {
+    uchar digest[16];
+
+    null_value=0;
+    compute_md5_hash(digest, (const char *) sptr->ptr(), sptr->length());
+    if (str->alloc(32))				// Ensure that memory is free
+    {
+      null_value=1;
+      return 0;
+    }
+    array_to_hex((char *) str->ptr(), digest, 16);
+    str->set_charset(&my_charset_numeric);
+    str->length((uint) 32);
+    return str;
+  }
+  null_value=1;
+  return 0;
+}
+
+
+String *Item_func_sha::val_str_ascii(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String * sptr= args[0]->val_str(str);
+  if (sptr)  /* If we got value different from NULL */
+  {
+    /* Temporary buffer to store 160bit digest */
+    uint8 digest[MY_SHA1_HASH_SIZE];
+    my_sha1(digest, (const char *) sptr->ptr(), sptr->length());
+    /* Ensure that memory is free and we got result */
+    if (!str->alloc(MY_SHA1_HASH_SIZE*2))
+    {
+      array_to_hex((char *) str->ptr(), digest, MY_SHA1_HASH_SIZE);
+      str->set_charset(&my_charset_numeric);
+      str->length((uint)  MY_SHA1_HASH_SIZE*2);
+      null_value=0;
+      return str;
+    }
+  }
+  null_value=1;
+  return 0;
+}
+
+bool Item_func_sha::fix_length_and_dec(THD *thd)
+{
+  // size of hex representation of hash
+  fix_length_and_charset(MY_SHA1_HASH_SIZE * 2, default_charset());
+  return FALSE;
+}
+
+String *Item_func_sha2::val_str_ascii(String *str)
+{
+  DBUG_ASSERT(fixed());
+  unsigned char digest_buf[512/8]; // enough for SHA512
+  String *input_string;
+  const char *input_ptr;
+  size_t input_len;
+
+  input_string= args[0]->val_str(str);
+  str->set_charset(&my_charset_bin);
+
+  if (input_string == NULL)
+  {
+    null_value= TRUE;
+    return (String *) NULL;
+  }
+
+  null_value= args[0]->null_value;
+  if (null_value)
+    return (String *) NULL;
+
+  input_ptr= input_string->ptr();
+  input_len= input_string->length();
+
+  longlong digest_length= args[1]->val_int();
+  switch (digest_length) {
+  case 512:
+    my_sha512(digest_buf, input_ptr, input_len);
+    break;
+  case 384:
+    my_sha384(digest_buf, input_ptr, input_len);
+    break;
+  case 224:
+    my_sha224(digest_buf, input_ptr, input_len);
+    break;
+  case 0: // SHA-256 is the default
+    digest_length= 256;
+    /* fall through */
+  case 256:
+    my_sha256(digest_buf, input_ptr, input_len);
+    break;
+  default:
+    if (!args[1]->const_item())
+    {
+      THD *thd= current_thd;
+      push_warning_printf(thd,
+                          Sql_condition::WARN_LEVEL_WARN,
+                          ER_WRONG_PARAMETERS_TO_NATIVE_FCT,
+                          ER_THD(thd, ER_WRONG_PARAMETERS_TO_NATIVE_FCT),
+                          "sha2");
+    }
+    null_value= TRUE;
+    return NULL;
+  }
+  digest_length/= 8; /* bits to bytes */
+
+  /* 
+    Since we're subverting the usual String methods, we must make sure that
+    the destination has space for the bytes we're about to write.
+  */
+  str->alloc((uint) digest_length*2 + 1); /* Each byte as two nybbles */
+
+  /* Convert the large number to a string-hex representation. */
+  array_to_hex((char *) str->ptr(), digest_buf, (uint)digest_length);
+
+  /* We poked raw bytes in.  We must inform the the String of its length. */
+  str->length((uint) digest_length*2); /* Each byte as two nybbles */
+
+  null_value= FALSE;
+  return str;
+}
+
+
+bool Item_func_sha2::fix_length_and_dec(THD *thd)
+{
+  set_maybe_null();
+  max_length = 0;
+
+  int sha_variant= (int)(args[1]->const_item() ? args[1]->val_int() : 512);
+
+  switch (sha_variant) {
+  case 0: // SHA-256 is the default
+    sha_variant= 256;
+    /* fall through */
+  case 512:
+  case 384:
+  case 256:
+  case 224:
+    fix_length_and_charset(sha_variant/8 * 2, default_charset());
+    break;
+  default:
+    THD *thd= current_thd;
+    push_warning_printf(thd,
+                        Sql_condition::WARN_LEVEL_WARN,
+                        ER_WRONG_PARAMETERS_TO_NATIVE_FCT,
+                        ER_THD(thd, ER_WRONG_PARAMETERS_TO_NATIVE_FCT),
+                        "sha2");
+  }
+  return FALSE;
+}
+
+/* Implementation of AES encryption routines */
+void Item_aes_crypt::create_key(String *user_key, uchar *real_key)
+{
+  uchar *real_key_end= real_key + AES_KEY_LENGTH / 8;
+  uchar *ptr;
+  const char *sptr= user_key->ptr();
+  const char *key_end= sptr + user_key->length();
+
+  bzero(real_key, AES_KEY_LENGTH / 8);
+
+  for (ptr= real_key; sptr < key_end; ptr++, sptr++)
+  {
+    if (ptr == real_key_end)
+      ptr= real_key;
+    *ptr ^= (uchar) *sptr;
+  }
+}
+
+
+String *Item_aes_crypt::val_str(String *str2)
+{
+  DBUG_ASSERT(fixed());
+  StringBuffer<80> user_key_buf;
+  String *sptr= args[0]->val_str(&tmp_value);
+  String *user_key=  args[1]->val_str(&user_key_buf);
+  uint32 aes_length;
+
+  if (sptr && user_key) // we need both arguments to be not NULL
+  {
+    null_value=0;
+    aes_length=my_aes_get_size(MY_AES_ECB, sptr->length());
+
+    if (!str2->alloc(aes_length))		// Ensure that memory is free
+    {
+      uchar rkey[AES_KEY_LENGTH / 8];
+      create_key(user_key, rkey);
+
+      if (!my_aes_crypt(MY_AES_ECB, what, (uchar*)sptr->ptr(), sptr->length(),
+                 (uchar*)str2->ptr(), &aes_length,
+                 rkey, AES_KEY_LENGTH / 8, 0, 0))
+      {
+        str2->length((uint) aes_length);
+        DBUG_ASSERT(collation.collation == &my_charset_bin);
+        str2->set_charset(&my_charset_bin);
+        return str2;
+      }
+    }
+  }
+  null_value=1;
+  return 0;
+}
+
+bool Item_func_aes_encrypt::fix_length_and_dec(THD *thd)
+{
+  max_length=my_aes_get_size(MY_AES_ECB, args[0]->max_length);
+  what= ENCRYPTION_FLAG_ENCRYPT;
+  return FALSE;
+}
+
+
+
+bool Item_func_aes_decrypt::fix_length_and_dec(THD *thd)
+{
+  max_length=args[0]->max_length;
+  set_maybe_null();
+  what= ENCRYPTION_FLAG_DECRYPT;
+  return FALSE;
+}
+
+
+bool Item_func_to_base64::fix_length_and_dec(THD *thd)
+{
+  base_flags|= args[0]->base_flags & item_base_t::MAYBE_NULL;
+  collation.set(default_charset(), DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII);
+  if (args[0]->max_length > (uint) my_base64_encode_max_arg_length())
+  {
+    set_maybe_null();
+    fix_char_length_ulonglong((ulonglong) my_base64_encode_max_arg_length());
+  }
+  else
+  {
+    int length= my_base64_needed_encoded_length((int) args[0]->max_length);
+    DBUG_ASSERT(length > 0);
+    fix_char_length_ulonglong((ulonglong) length - 1);
+  }
+  return FALSE;
+}
+
+
+String *Item_func_to_base64::val_str_ascii(String *str)
+{
+  String *res= args[0]->val_str(&tmp_value);
+  bool too_long= false;
+  int length;
+  if (!res ||
+      res->length() > (uint) my_base64_encode_max_arg_length() ||
+      (too_long=
+       ((uint) (length= my_base64_needed_encoded_length((int) res->length())) >
+        current_thd->variables.max_allowed_packet)) ||
+      str->alloc((uint) length))
+  {
+    null_value= 1; // NULL input, too long input, or OOM.
+    if (too_long)
+    {
+      THD *thd= current_thd;
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                          ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                          func_name(),
+                          thd->variables.max_allowed_packet);
+    }
+    return 0;
+  }
+  my_base64_encode(res->ptr(), (int) res->length(), (char*) str->ptr());
+  DBUG_ASSERT(length > 0);
+  str->length((uint) length - 1); // Without trailing '\0'
+  null_value= 0;
+  return str;
+}
+
+
+bool Item_func_from_base64::fix_length_and_dec(THD *thd)
+{
+  if (args[0]->max_length > (uint) my_base64_decode_max_arg_length())
+  {
+    fix_char_length_ulonglong((ulonglong) my_base64_decode_max_arg_length());
+  }
+  else
+  {
+    int length= my_base64_needed_decoded_length((int) args[0]->max_length);
+    fix_char_length_ulonglong((ulonglong) length);
+  }
+  // Can be NULL, e.g. in case of badly formed input string
+  set_maybe_null();
+  return FALSE;
+}
+
+
+String *Item_func_from_base64::val_str(String *str)
+{
+  String *res= args[0]->val_str_ascii(&tmp_value);
+  int length;
+  const char *end_ptr;
+
+  if (!res)
+    goto err;
+
+  if (res->length() > (uint) my_base64_decode_max_arg_length() ||
+      ((uint) (length= my_base64_needed_decoded_length((int) res->length())) >
+       current_thd->variables.max_allowed_packet))
+  {
+    THD *thd= current_thd;
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                        ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                        ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                        func_name(),
+                        thd->variables.max_allowed_packet);
+    goto err;
+  }
+
+  if (str->alloc((uint) length))
+    goto err;
+
+  if ((length= my_base64_decode(res->ptr(), (int) res->length(),
+                                (char *) str->ptr(), &end_ptr, 0)) < 0 ||
+      end_ptr < res->ptr() + res->length())
+  {
+    THD *thd= current_thd;
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                        ER_BAD_BASE64_DATA, ER_THD(thd, ER_BAD_BASE64_DATA),
+                        (int) (end_ptr - res->ptr()));
+    goto err;
+  }
+
+  str->length((uint) length);
+  null_value= 0;
+  return str;
+err:
+  null_value= 1; // NULL input, too long input, OOM, or badly formed input
+  return 0;
+}
+///////////////////////////////////////////////////////////////////////////////
+
+
+const char *histogram_types[] =
+    {"SINGLE_PREC_HB", "DOUBLE_PREC_HB", "JSON_HB", 0};
+static TYPELIB histogram_types_typelib=
+  { array_elements(histogram_types),
+    "histogram_types",
+    histogram_types, NULL};
+const char *representation_by_type[]= {"%.3f", "%.5f"};
+
+String *Item_func_decode_histogram::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  char buff[STRING_BUFFER_USUAL_SIZE];
+  String *res, tmp(buff, sizeof(buff), &my_charset_bin);
+  int type;
+
+  tmp.length(0);
+  if (!(res= args[0]->val_str(&tmp)) ||
+      (type= find_type(res->c_ptr_safe(),
+                       &histogram_types_typelib, MYF(0))) <= 0)
+  {
+    null_value= 1;
+    return 0;
+  }
+  type--;
+
+  tmp.length(0);
+  if (!(res= args[1]->val_str(&tmp)))
+  {
+    null_value= 1;
+    return 0;
+  }
+
+  if (type == JSON_HB)
+  {
+    // It's a JSON histogram. Return it as-is.
+    null_value= 0;
+    return res;
+  }
+
+  if (type == DOUBLE_PREC_HB && res->length() % 2 != 0)
+    res->length(res->length() - 1); // one byte is unused
+
+  double prev= 0.0;
+  uint i;
+  str->length(0);
+  char numbuf[32];
+  const uchar *p= (uchar*)res->c_ptr_safe();
+  for (i= 0; i < res->length(); i++)
+  {
+    double val;
+    switch (type)
+    {
+    case SINGLE_PREC_HB:
+      val= p[i] / ((double)((1 << 8) - 1));
+      break;
+    case DOUBLE_PREC_HB:
+      val= uint2korr(p + i) / ((double)((1 << 16) - 1));
+      i++;
+      break;
+    default:
+      val= 0;
+      DBUG_ASSERT(0);
+    }
+    /* show delta with previous value */
+    size_t size= my_snprintf(numbuf, sizeof(numbuf),
+                          representation_by_type[type], val - prev);
+    str->append(numbuf, size);
+    str->append(',');
+    prev= val;
+  }
+  /* show delta with max */
+  size_t size= my_snprintf(numbuf, sizeof(numbuf),
+                        representation_by_type[type], 1.0 - prev);
+  str->append(numbuf, size);
+
+  null_value=0;
+  return str;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*
+  Realloc the result buffer.
+  NOTE: We should be prudent in the initial allocation unit -- the
+  size of the arguments is a function of data distribution, which
+  can be any. Instead of overcommitting at the first row, we grow
+  the allocated amount by the factor of 2. This ensures that no
+  more than 25% of memory will be overcommitted on average.
+
+  @param IN/OUT str    - the result string
+  @param IN     length - new total space required in "str"
+  @retval       false  - on success
+  @retval       true   - on error
+*/
+
+bool Item_func_concat::realloc_result(String *str, uint length) const
+{
+  if (str->alloced_length() >= length)
+    return false; // Alloced space is big enough, nothing to do.
+
+  if (str->alloced_length() == 0)
+    return str->alloc(length);
+
+  /*
+    Item_func_concat::val_str() makes sure the result length does not grow
+    higher than max_allowed_packet. So "length" is limited to 1G here.
+    We can't say anything about the current value of str->alloced_length(),
+    as str was initially set by args[0]->val_str(str).
+    So multiplication by 2 can overflow, if args[0] for some reasons
+    did not limit the result to max_alloced_packet. But it's not harmful,
+    "str" will be reallocated exactly to "length" bytes in case of overflow.
+  */
+  uint new_length= MY_MAX(str->alloced_length() * 2, length);
+  return str->realloc(new_length);
+}
+
+
+/**
+  Concatenate args with the following premises:
+  If only one arg (which is ok), return value of arg;
+*/
+
+String *Item_func_concat::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  THD *thd= current_thd;
+  String *res;
+
+  null_value=0;
+  if (!(res= args[0]->val_str(str)))
+    goto null;
+
+  if (res != str)
+    str->copy_or_move(res->ptr(), res->length(), res->charset());
+
+  for (uint i= 1 ; i < arg_count ; i++)
+  {
+    if (!(res= args[i]->val_str(&tmp_value)) ||
+        append_value(thd, str, res))
+      goto null;
+  }
+
+  str->set_charset(collation.collation);
+  return str;
+
+null:
+  null_value= true;
+  return 0;
+}
+
+
+String *Item_func_concat_operator_oracle::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  THD *thd= current_thd;
+  String *res= NULL;
+  uint i;
+
+  null_value=0;
+  // Search first non null argument
+  for (i= 0; i < arg_count; i++)
+  {
+    if ((res= args[i]->val_str(str)))
+      break;
+  }
+  if (!res)
+    goto null;
+
+  if (res != str)
+    str->copy(res->ptr(), res->length(), res->charset());
+
+  for (i++ ; i < arg_count ; i++)
+  {
+    if (!(res= args[i]->val_str(&tmp_value)) || res->length() == 0)
+     continue;
+    if (append_value(thd, str, res))
+      goto null;
+  }
+
+  str->set_charset(collation.collation);
+  return str;
+
+null:
+  null_value= true;
+  return 0;
+}
+
+
+bool Item_func_concat::append_value(THD *thd, String *res, const String *app)
+{
+  uint concat_len;
+  if ((concat_len= res->length() + app->length()) >
+      thd->variables.max_allowed_packet)
+  {
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                        ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                        ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
+                        thd->variables.max_allowed_packet);
+    return true;
+  }
+  DBUG_ASSERT(!res->uses_buffer_owned_by(app));
+  DBUG_ASSERT(!app->uses_buffer_owned_by(res));
+  return realloc_result(res, concat_len) || res->append(*app);
+}
+
+
+bool Item_func_concat::fix_length_and_dec(THD *thd)
+{
+  ulonglong char_length= 0;
+
+  if (agg_arg_charsets_for_string_result(collation, args, arg_count))
+    return TRUE;
+
+  for (uint i=0 ; i < arg_count ; i++)
+    char_length+= args[i]->max_char_length();
+
+  fix_char_length_ulonglong(char_length);
+  return FALSE;
+}
+
+/**
+  @details
+  Function des_encrypt() by tonu@spam.ee & monty
+  Works only if compiled with OpenSSL library support.
+  @return
+    A binary string where first character is CHAR(128 | key-number).
+    If one uses a string key key_number is 127.
+    Encryption result is longer than original by formula:
+  @code new_length= org_length + (8-(org_length % 8))+1 @endcode
+*/
+bool Item_func_des_encrypt::fix_length_and_dec(THD *thd)
+{
+  set_maybe_null();
+  /* 9 = MAX ((8- (arg_len % 8)) + 1) */
+  max_length = args[0]->max_length + 9;
+  push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE, ER_WARN_DEPRECATED_SYNTAX,
+                      ER_THD(thd, ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT),
+                      func_name_cstring().str);
+  return FALSE;
+}
+
+
+String *Item_func_des_encrypt::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
+  uint code= ER_WRONG_PARAMETERS_TO_PROCEDURE;
+  DES_cblock ivec;
+  struct st_des_keyblock keyblock;
+  struct st_des_keyschedule keyschedule;
+  const char *append_str="********";
+  uint key_number, res_length, tail;
+  String *res= args[0]->val_str(&tmp_value);
+
+  if ((null_value= args[0]->null_value))
+    return 0;                                   // ENCRYPT(NULL) == NULL
+  if ((res_length=res->length()) == 0)
+    return make_empty_result(str);
+  if (arg_count == 1)
+  {
+    /* Protect against someone doing FLUSH DES_KEY_FILE */
+    mysql_mutex_lock(&LOCK_des_key_file);
+    keyschedule= des_keyschedule[key_number=des_default_key];
+    mysql_mutex_unlock(&LOCK_des_key_file);
+  }
+  else if (args[1]->result_type() == INT_RESULT)
+  {
+    key_number= (uint) args[1]->val_int();
+    if (key_number > 9)
+      goto error;
+    mysql_mutex_lock(&LOCK_des_key_file);
+    keyschedule= des_keyschedule[key_number];
+    mysql_mutex_unlock(&LOCK_des_key_file);
+  }
+  else
+  {
+    String *keystr= args[1]->val_str(str);
+    if (!keystr)
+      goto error;
+    key_number=127;				// User key string
+
+    /* We make good 24-byte (168 bit) key from given plaintext key with MD5 */
+    bzero((char*) &ivec,sizeof(ivec));
+    if (!EVP_BytesToKey(EVP_des_ede3_cbc(),EVP_md5(),NULL,
+		   (uchar*) keystr->ptr(), (int) keystr->length(),
+		   1, (uchar*) &keyblock,ivec))
+      goto error;
+    DES_set_key_unchecked(&keyblock.key1,&keyschedule.ks1);
+    DES_set_key_unchecked(&keyblock.key2,&keyschedule.ks2);
+    DES_set_key_unchecked(&keyblock.key3,&keyschedule.ks3);
+  }
+
+  /*
+     The problem: DES algorithm requires original data to be in 8-bytes
+     chunks. Missing bytes get filled with '*'s and result of encryption
+     can be up to 8 bytes longer than original string. When decrypted,
+     we do not know the size of original string :(
+     We add one byte with value 0x1..0x8 as the last byte of the padded
+     string marking change of string length.
+  */
+
+  tail= 8 - (res_length % 8);                   // 1..8 marking extra length
+  res_length+=tail;
+  if (tmp_arg.alloc(res_length))
+    goto error;
+  tmp_arg.length(0);
+  tmp_arg.append(res->ptr(), res->length());
+  code= ER_OUT_OF_RESOURCES;
+  if (tmp_arg.append(append_str, tail) || str->alloc(res_length+1))
+    goto error;
+  tmp_arg[res_length-1]=tail;                   // save extra length
+  str->length(res_length+1);
+  str->set_charset(&my_charset_bin);
+  (*str)[0]=(char) (128 | key_number);
+  // Real encryption
+  bzero((char*) &ivec,sizeof(ivec));
+  DES_ede3_cbc_encrypt((const uchar*) (tmp_arg.ptr()),
+		       (uchar*) (str->ptr()+1),
+		       res_length,
+		       &keyschedule.ks1,
+		       &keyschedule.ks2,
+		       &keyschedule.ks3,
+		       &ivec, TRUE);
+  return str;
+
+error:
+  THD *thd= current_thd;
+  push_warning_printf(thd,Sql_condition::WARN_LEVEL_WARN,
+                      code, ER_THD(thd, code),
+                      "des_encrypt");
+#else
+  THD *thd= current_thd;
+  push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                      ER_FEATURE_DISABLED, ER_THD(thd, ER_FEATURE_DISABLED),
+                      "des_encrypt", "--with-ssl");
+#endif /* defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY) */
+  null_value=1;
+  return 0;
+}
+
+
+bool Item_func_des_decrypt::fix_length_and_dec(THD *thd)
+{
+  set_maybe_null();
+  /* 9 = MAX ((8- (arg_len % 8)) + 1) */
+  max_length= args[0]->max_length;
+  if (max_length >= 9U)
+    max_length-= 9U;
+  push_warning_printf(thd, Sql_condition::WARN_LEVEL_NOTE, ER_WARN_DEPRECATED_SYNTAX,
+                      ER_THD(thd, ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT),
+                      func_name_cstring().str);
+  return FALSE;
+}
+
+
+String *Item_func_des_decrypt::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+#if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
+  uint code= ER_WRONG_PARAMETERS_TO_PROCEDURE;
+  DES_cblock ivec;
+  struct st_des_keyblock keyblock;
+  struct st_des_keyschedule keyschedule;
+  String *res= args[0]->val_str(&tmp_value);
+  uint length,tail;
+
+  if ((null_value= args[0]->null_value))
+    return 0;
+  length= res->length();
+  if (length < 9 || (length % 8) != 1 || !((*res)[0] & 128))
+    return res;				// Skip decryption if not encrypted
+
+  if (arg_count == 1)			// If automatic uncompression
+  {
+    uint key_number=(uint) (*res)[0] & 127;
+    // Check if automatic key and that we have privilege to uncompress using it
+    if (!(current_thd->security_ctx->master_access & PRIV_DES_DECRYPT_ONE_ARG) ||
+        key_number > 9)
+      goto error;
+
+    mysql_mutex_lock(&LOCK_des_key_file);
+    keyschedule= des_keyschedule[key_number];
+    mysql_mutex_unlock(&LOCK_des_key_file);
+  }
+  else
+  {
+    // We make good 24-byte (168 bit) key from given plaintext key with MD5
+    String *keystr= args[1]->val_str(str);
+    if (!keystr)
+      goto error;
+
+    bzero((char*) &ivec,sizeof(ivec));
+    if (!EVP_BytesToKey(EVP_des_ede3_cbc(),EVP_md5(),NULL,
+		   (uchar*) keystr->ptr(),(int) keystr->length(),
+		   1,(uchar*) &keyblock,ivec))
+      goto error;
+    // Here we set all 64-bit keys (56 effective) one by one
+    DES_set_key_unchecked(&keyblock.key1,&keyschedule.ks1);
+    DES_set_key_unchecked(&keyblock.key2,&keyschedule.ks2);
+    DES_set_key_unchecked(&keyblock.key3,&keyschedule.ks3);
+  }
+  code= ER_OUT_OF_RESOURCES;
+  if (str->alloc(length-1))
+    goto error;
+
+  bzero((char*) &ivec,sizeof(ivec));
+  DES_ede3_cbc_encrypt((const uchar*) res->ptr()+1,
+		       (uchar*) (str->ptr()),
+		       length-1,
+		       &keyschedule.ks1,
+		       &keyschedule.ks2,
+		       &keyschedule.ks3,
+		       &ivec, FALSE);
+  /* Restore old length of key */
+  if ((tail=(uint) (uchar) (*str)[length-2]) > 8)
+    goto wrong_key;				     // Wrong key
+  str->length(length-1-tail);
+  str->set_charset(&my_charset_bin);
+  return str;
+
+error:
+  {
+    THD *thd= current_thd;
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                        code, ER_THD(thd, code),
+                        "des_decrypt");
+  }
+wrong_key:
+#else
+  {
+    THD *thd= current_thd;
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                        ER_FEATURE_DISABLED, ER_THD(thd, ER_FEATURE_DISABLED),
+                        "des_decrypt", "--with-ssl");
+  }
+#endif /* defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY) */
+  null_value=1;
+  return 0;
+}
+
+
+/**
+  concat with separator. First arg is the separator
+  concat_ws takes at least two arguments.
+*/
+
+String *Item_func_concat_ws::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  char tmp_str_buff[10];
+  String tmp_sep_str(tmp_str_buff, sizeof(tmp_str_buff),default_charset_info),
+         *sep_str, *res, *res2,*use_as_buff;
+  uint i;
+  bool is_const= 0;
+  THD *thd= 0;
+
+  null_value=0;
+  if (!(sep_str= args[0]->val_str(&tmp_sep_str)))
+    goto null;
+
+  use_as_buff= &tmp_value;
+  str->length(0);				// QQ; Should be removed
+  res=str;                                      // If 0 arg_count
+
+  // Skip until non-null argument is found.
+  // If not, return the empty string
+  for (i=1; i < arg_count; i++)
+    if ((res= args[i]->val_str(str)))
+    {
+      is_const= args[i]->const_item();
+      break;
+    }
+
+  if (i ==  arg_count)
+    return make_empty_result(str);
+
+  for (i++; i < arg_count ; i++)
+  {
+    if (!(res2= args[i]->val_str(use_as_buff)))
+      continue;					// Skip NULL
+
+    if (!thd)
+      thd= current_thd;
+    if (res->length() + sep_str->length() + res2->length() >
+	thd->variables.max_allowed_packet)
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+			  ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+			  ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                          func_name(),
+			  thd->variables.max_allowed_packet);
+      goto null;
+    }
+    if (!is_const && res->alloced_length() >=
+	res->length() + sep_str->length() + res2->length())
+    {						// Use old buffer
+      res->append(*sep_str);			// res->length() > 0 always
+      res->append(*res2);
+    }
+    else if (str->alloced_length() >=
+	     res->length() + sep_str->length() + res2->length())
+    {
+      /* We have room in str;  We can't get any errors here */
+      if (str->ptr() == res2->ptr())
+      {						// This is quite uncommon!
+	str->replace(0,0,*sep_str);
+	str->replace(0,0,*res);
+      }
+      else
+      {
+	str->copy(*res);
+	str->append(*sep_str);
+	str->append(*res2);
+      }
+      res=str;
+      use_as_buff= &tmp_value;
+    }
+    else if (res == &tmp_value)
+    {
+      if (res->append(*sep_str) || res->append(*res2))
+	goto null; // Must be a blob
+    }
+    else if (res2 == &tmp_value)
+    {						// This can happen only 1 time
+      if (tmp_value.replace(0,0,*sep_str) || tmp_value.replace(0,0,*res))
+	goto null;
+      res= &tmp_value;
+      use_as_buff=str;				// Put next arg here
+    }
+    else if (tmp_value.is_alloced() && res2->ptr() >= tmp_value.ptr() &&
+	     res2->ptr() < tmp_value.ptr() + tmp_value.alloced_length())
+    {
+      /*
+	This happens really seldom:
+	In this case res2 is sub string of tmp_value.  We will
+	now work in place in tmp_value to set it to res | sep_str | res2
+      */
+      /* Chop the last characters in tmp_value that isn't in res2 */
+      tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
+		       res2->length());
+      /* Place res2 at start of tmp_value, remove chars before res2 */
+      if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
+			    *res) ||
+	  tmp_value.replace(res->length(),0, *sep_str))
+	goto null;
+      res= &tmp_value;
+      use_as_buff=str;			// Put next arg here
+    }
+    else
+    {						// Two big const strings
+      /*
+        NOTE: We should be prudent in the initial allocation unit -- the
+        size of the arguments is a function of data distribution, which can
+        be any. Instead of overcommitting at the first row, we grow the
+        allocated amount by the factor of 2. This ensures that no more than
+        25% of memory will be overcommitted on average.
+      */
+
+      uint concat_len= res->length() + sep_str->length() + res2->length();
+
+      if (tmp_value.alloced_length() < concat_len)
+      {
+        if (tmp_value.alloced_length() == 0)
+        {
+          if (tmp_value.alloc(concat_len))
+            goto null;
+        }
+        else
+        {
+          uint new_len = MY_MAX(tmp_value.alloced_length() * 2, concat_len);
+
+          if (tmp_value.alloc(new_len))
+            goto null;
+        }
+      }
+
+      if (tmp_value.copy(*res) ||
+	  tmp_value.append(*sep_str) ||
+	  tmp_value.append(*res2))
+	goto null;
+      res= &tmp_value;
+      use_as_buff=str;
+    }
+  }
+  res->set_charset(collation.collation);
+  return res;
+
+null:
+  null_value=1;
+  return 0;
+}
+
+
+bool Item_func_concat_ws::fix_length_and_dec(THD *thd)
+{
+  ulonglong char_length;
+
+  if (agg_arg_charsets_for_string_result(collation, args, arg_count))
+    return TRUE;
+
+  /*
+     arg_count cannot be less than 2,
+     it is done on parser level in sql_yacc.yy
+     so, (arg_count - 2) is safe here.
+  */
+  char_length= (ulonglong) args[0]->max_char_length() * (arg_count - 2);
+  for (uint i=1 ; i < arg_count ; i++)
+    char_length+= args[i]->max_char_length();
+
+  fix_char_length_ulonglong(char_length);
+  return FALSE;
+}
+
+
+String *Item_func_reverse::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *res= args[0]->val_str(&tmp_value);
+  const char *ptr, *end;
+  char *tmp;
+
+  if ((null_value=args[0]->null_value))
+    return 0;
+  /* An empty string is a special case as the string pointer may be null */
+  if (!res->length())
+    return make_empty_result(str);
+  if (str->alloc(res->length()))
+  {
+    null_value= 1;
+    return 0;
+  }
+  str->length(res->length());
+  str->set_charset(res->charset());
+  ptr= res->ptr();
+  end= res->end();
+  tmp= (char *) str->end();
+#ifdef USE_MB
+  if (res->use_mb())
+  {
+    uint32 l;
+    while (ptr < end)
+    {
+      if ((l= my_ismbchar(res->charset(),ptr,end)))
+      {
+        tmp-= l;
+        DBUG_ASSERT(tmp >= str->ptr());
+        memcpy(tmp,ptr,l);
+        ptr+= l;
+      }
+      else
+        *--tmp= *ptr++;
+    }
+  }
+  else
+#endif /* USE_MB */
+  {
+    while (ptr < end)
+      *--tmp= *ptr++;
+  }
+  return str;
+}
+
+
+bool Item_func_reverse::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result(collation, args, 1))
+    return TRUE;
+  DBUG_ASSERT(collation.collation != NULL);
+  fix_char_length(args[0]->max_char_length());
+  return FALSE;
+}
+
+/**
+  Replace all occurrences of string2 in string1 with string3.
+
+  Don't reallocate val_str() if not needed.
+
+  @todo
+    Fix that this works with binary strings when using USE_MB 
+*/
+
+String *Item_func_replace::val_str_internal(String *str,
+                                            String *empty_string_for_null)
+{
+  DBUG_ASSERT(fixed());
+  String *res,*res2,*res3;
+  int offset;
+  uint from_length,to_length;
+  bool alloced=0;
+#ifdef USE_MB
+  const char *ptr,*end,*strend,*search,*search_end;
+  uint32 l;
+  bool binary_cmp;
+#endif
+  THD *thd= 0;
+
+  null_value=0;
+  res=args[0]->val_str(str);
+  if (args[0]->null_value)
+    goto null;
+  res2=args[1]->val_str(&tmp_value);
+  if (args[1]->null_value)
+  {
+    if (!empty_string_for_null)
+      goto null;
+    res2= empty_string_for_null;
+  }
+  res->set_charset(collation.collation);
+
+#ifdef USE_MB
+  binary_cmp = ((res->charset()->state & MY_CS_BINSORT) || !res->use_mb());
+#endif
+
+  if (res2->length() == 0)
+    return res;
+#ifndef USE_MB
+  if ((offset=res->strstr(*res2)) < 0)
+    return res;
+#else
+  offset=0;
+  if (binary_cmp && (offset=res->strstr(*res2)) < 0)
+    return res;
+#endif
+  if (!(res3=args[2]->val_str(&tmp_value2)))
+  {
+    if (!empty_string_for_null)
+      goto null;
+    res3= empty_string_for_null;
+  }
+  from_length= res2->length();
+  to_length=   res3->length();
+
+#ifdef USE_MB
+  if (!binary_cmp)
+  {
+    search=res2->ptr();
+    search_end=search+from_length;
+redo:
+    DBUG_ASSERT(res->ptr() || !offset);
+    ptr=res->ptr()+offset;
+    strend=res->ptr()+res->length();
+    /*
+      In some cases val_str() can return empty string
+      with ptr() == NULL and length() == 0.
+      Let's check strend to avoid overflow.
+    */
+    end= strend ? strend - from_length + 1 : NULL;
+    while (ptr < end)
+    {
+      if (*ptr == *search)
+      {
+        char *i,*j;
+        i=(char*) ptr+1; j=(char*) search+1;
+        while (j != search_end)
+          if (*i++ != *j++) goto skip;
+        offset= (int) (ptr-res->ptr());
+
+        if (!thd)
+          thd= current_thd;
+
+        if (res->length()-from_length + to_length >
+            thd->variables.max_allowed_packet)
+        {
+          push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                              ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                              ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                              func_name(),
+                              thd->variables.max_allowed_packet);
+
+          goto null;
+        }
+        if (!alloced)
+        {
+          alloced=1;
+          res=copy_if_not_alloced(str,res,res->length()+to_length);
+        }
+        res->replace((uint) offset,from_length,*res3);
+        offset+=(int) to_length;
+        goto redo;
+      }
+  skip:
+      if ((l=my_ismbchar(res->charset(), ptr,strend))) ptr+=l;
+      else ++ptr;
+    }
+  }
+  else
+#endif /* USE_MB */
+  {
+    thd= current_thd;
+    do
+    {
+      if (res->length()-from_length + to_length >
+	  thd->variables.max_allowed_packet)
+      {
+	push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+			    ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+			    ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                            func_name(),
+			    thd->variables.max_allowed_packet);
+        goto null;
+      }
+      if (!alloced)
+      {
+        alloced=1;
+        res=copy_if_not_alloced(str,res,res->length()+to_length);
+      }
+      res->replace((uint) offset,from_length,*res3);
+      offset+=(int) to_length;
+    }
+    while ((offset=res->strstr(*res2,(uint) offset)) >= 0);
+  }
+  if (empty_string_for_null && !res->length())
+    goto null;
+
+  return res;
+
+null:
+  null_value=1;
+  return 0;
+}
+
+
+bool Item_func_replace::fix_length_and_dec(THD *thd)
+{
+  ulonglong char_length= (ulonglong) args[0]->max_char_length();
+  int diff=(int) (args[2]->max_char_length() - 1);
+  if (diff > 0)
+  {						// Calculate of maxreplaces
+    ulonglong max_substrs= char_length;
+    char_length+= max_substrs * (uint) diff;
+  }
+
+  if (agg_arg_charsets_for_string_result_with_comparison(collation, args, 3))
+    return TRUE;
+  fix_char_length_ulonglong(char_length);
+  return FALSE;
+}
+
+/*
+  this is done in the constructor to be in the same memroot as
+  the item itself
+*/
+Item_func_sformat::Item_func_sformat(THD *thd, List<Item> &list)
+  : Item_str_func(thd, list)
+{
+  val_arg= new (thd->mem_root) String[arg_count];
+}
+
+
+bool Item_func_sformat::fix_length_and_dec(THD *thd)
+{
+  if (!val_arg)
+    return TRUE;
+
+  ulonglong char_length= 0;
+
+  uint flags= MY_COLL_ALLOW_SUPERSET_CONV |
+              MY_COLL_ALLOW_COERCIBLE_CONV |
+              MY_COLL_ALLOW_NUMERIC_CONV;
+
+  if (Type_std_attributes::agg_item_collations(collation, func_name_cstring(),
+        args, arg_count, flags, 1))
+    return TRUE;
+
+  DTCollation c= collation;
+  if (c.collation->mbminlen > 1)
+    c.collation= &my_charset_utf8mb4_bin;
+
+  for (uint i=0 ; i < arg_count ; i++)
+  {
+    if (args[i]->result_type() == STRING_RESULT &&
+        Type_std_attributes::agg_item_set_converter(c, func_name_cstring(),
+                                                    args+i, 1, flags, 1))
+      return TRUE;
+  }
+
+  char_length= MAX_BLOB_WIDTH;
+  fix_char_length_ulonglong(char_length);
+  return FALSE;
+}
+
+/*
+  allow fmt to take String arguments directly.
+  Inherit from string_view, so all string formatting works.
+  but {:p} doesn't, because it's not char*, not a pointer.
+*/
+namespace fmt {
+  template <> struct formatter<String>: formatter<string_view> {
+    template <typename FormatContext>
+    auto format(String c, FormatContext& ctx) -> decltype(ctx.out()) {
+      string_view name = { c.ptr(), c.length() };
+      return formatter<string_view>::format(name, ctx);
+    };
+  };
+};
+
+/*
+  SFORMAT(format_string, ...)
+  This function receives a formatting specification string and N parameters
+  (N >= 0), and it returns string formatted using the rules the user passed
+  in the specification. It uses fmtlib (https://fmt.dev/).
+*/
+String *Item_func_sformat::val_str(String *res)
+{
+  /*
+    A union that stores a numeric format arg value.
+    fmt::detail::make_arg does not accept temporaries, so all of its numeric
+    args are temporarily stored in the fmt_args array.
+    See: https://github.com/fmtlib/fmt/issues/3596
+  */
+  union Format_arg_store {
+    longlong val_int;
+    float    val_float;
+    double   val_double;
+  };
+
+  DBUG_ASSERT(fixed());
+  using                         ctx=      fmt::format_context;
+  String                       *fmt_arg=  NULL;
+  String                       *parg=     NULL;
+  fmt::format_args::format_arg *vargs=    NULL;
+  Format_arg_store             *fmt_args= NULL;
+
+  null_value= true;
+  if (!(fmt_arg= args[0]->val_str(res)))
+    return NULL;
+
+  if (!(vargs= new fmt::format_args::format_arg[arg_count - 1]))
+    return NULL;
+
+  if (!(fmt_args= new Format_arg_store[arg_count - 1]))
+  {
+    delete [] vargs;
+    return NULL;
+  }
+
+  /* Creates the array of arguments for vformat */
+  for (uint carg= 1; carg < arg_count; carg++)
+  {
+    switch (args[carg]->result_type())
+    {
+    case INT_RESULT:
+      fmt_args[carg-1].val_int= args[carg]->val_int();
+      vargs[carg-1]= fmt::detail::make_arg<ctx>(fmt_args[carg-1].val_int);
+      break;
+    case DECIMAL_RESULT: // TODO
+    case REAL_RESULT:
+      if (args[carg]->field_type() == MYSQL_TYPE_FLOAT)
+      {
+        fmt_args[carg-1].val_float= (float)args[carg]->val_real();
+        vargs[carg-1]= fmt::detail::make_arg<ctx>(fmt_args[carg-1].val_float);
+      }
+      else
+      {
+        fmt_args[carg-1].val_double= args[carg]->val_real();
+        vargs[carg-1]= fmt::detail::make_arg<ctx>(fmt_args[carg-1].val_double);
+      }
+      break;
+    case STRING_RESULT:
+      if (!(parg= args[carg]->val_str(&val_arg[carg-1])))
+      {
+        delete [] vargs;
+        delete [] fmt_args;
+        return NULL;
+      }
+      vargs[carg-1]= fmt::detail::make_arg<ctx>(*parg);
+      break;
+    case TIME_RESULT: // TODO
+    case ROW_RESULT: // TODO
+    default:
+      DBUG_ASSERT(0);
+      delete [] vargs;
+      delete [] fmt_args;
+      return NULL;
+    }
+  }
+
+  null_value= false;
+  /* Create the string output  */
+  try
+  {
+    auto text = fmt::vformat(fmt_arg->c_ptr_safe(),
+                             fmt::format_args(vargs, arg_count-1));
+    res->length(0);
+    res->set_charset(collation.collation);
+    res->append(text.c_str(), text.size(), fmt_arg->charset());
+  }
+  catch (const fmt::format_error &ex)
+  {
+    THD *thd= current_thd;
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                        WARN_SFORMAT_ERROR,
+                        ER_THD(thd, WARN_SFORMAT_ERROR), ex.what());
+    null_value= true;
+  }
+  delete [] vargs;
+  delete [] fmt_args;
+  return null_value ? NULL : res;
+}
+
+#include"my_global.h"
+#include <openssl/rand.h>
+#include <openssl/err.h>
+
+bool Item_func_random_bytes::fix_length_and_dec(THD *thd)
+{
+  used_tables_cache|= RAND_TABLE_BIT;
+  if (args[0]->can_eval_in_optimize())
+  {
+    int32 v= (int32) args[0]->val_int();
+    max_length= MY_MAX(0, MY_MIN(v, MAX_RANDOM_BYTES));
+    return false;
+  }
+  max_length= MAX_RANDOM_BYTES;
+  return false;
+}
+
+
+void Item_func_random_bytes::update_used_tables()
+{
+  Item_str_func::update_used_tables();
+  used_tables_cache|= RAND_TABLE_BIT;
+}
+
+
+String *Item_func_random_bytes::val_str(String *str)
+{
+  longlong count= args[0]->val_int();
+
+  if (args[0]->null_value)
+    goto err;
+  null_value= 0;
+
+  if (count < 0 || count > MAX_RANDOM_BYTES)
+    goto err;
+
+  if (count == 0)
+    return make_empty_result(str);
+
+  if (str->alloc((uint) count))
+    goto err;
+
+  str->length(count);
+  str->set_charset(&my_charset_bin);
+  if (my_random_bytes((unsigned char *) str->ptr(), (int32) count))
+  {
+    ulong ssl_err;
+    while ((ssl_err= ERR_get_error()))
+    {
+      char buf[256];
+      ERR_error_string_n(ssl_err, buf, sizeof(buf));
+      sql_print_warning("SSL error: %s", buf);
+    }
+    goto err;
+  }
+
+  return str;
+
+err:
+  null_value= 1;
+  return 0;
+}
+
+
+/*********************************************************************/
+bool Item_func_regexp_replace::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result_with_comparison(collation, args, 3))
+    return TRUE;
+  max_length= MAX_BLOB_WIDTH;
+  re.init(collation.collation, 0);
+  re.fix_owner(this, args[0], args[1]);
+  return FALSE;
+}
+
+
+/*
+  Traverse through the replacement string and append to "str".
+  Sub-pattern references \0 .. \9 are recognized, which are replaced
+  to the chunks of the source string.
+*/
+bool Item_func_regexp_replace::append_replacement(String *str,
+                                                  const LEX_CSTRING *source,
+                                                  const LEX_CSTRING *replace)
+{
+  const char *beg= replace->str;
+  const char *end= beg + replace->length;
+  CHARSET_INFO *cs= re.library_charset();
+
+  for ( ; ; )
+  {
+    my_wc_t wc;
+    int cnv, n;
+
+    if ((cnv= cs->mb_wc(&wc, (const uchar *) beg,
+                             (const uchar *) end)) < 1)
+      break; /* End of line */
+    beg+= cnv;
+
+    if (wc != '\\')
+    {
+      if (str->append(beg - cnv, cnv, cs))
+        return true;
+      continue;
+    }
+
+    if ((cnv= cs->mb_wc(&wc, (const uchar *) beg,
+                             (const uchar *) end)) < 1)
+      break; /* End of line */
+    beg+= cnv;
+
+    if ((n= ((int) wc) - '0') >= 0 && n <= 9)
+    {
+      if (n < re.nsubpatterns())
+      {
+        /* A valid sub-pattern reference found */
+        size_t pbeg= re.subpattern_start(n), plength= re.subpattern_end(n) - pbeg;
+        if (str->append(source->str + pbeg, plength, cs))
+          return true;
+      }
+    }
+    else
+    {
+      /*
+         A non-digit character following after '\'.
+         Just add the character itself.
+       */
+      if (str->append(beg - cnv, cnv, cs))
+        return false;
+    }
+  }
+  return false;
+}
+
+
+String *Item_func_regexp_replace::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  char buff0[MAX_FIELD_WIDTH];
+  char buff2[MAX_FIELD_WIDTH];
+  String tmp0(buff0,sizeof(buff0),&my_charset_bin);
+  String tmp2(buff2,sizeof(buff2),&my_charset_bin);
+  String *source= args[0]->val_str(&tmp0);
+  String *replace= args[2]->val_str(&tmp2);
+  LEX_CSTRING src, rpl;
+  size_t startoffset= 0;
+
+  if ((null_value= (args[0]->null_value || args[2]->null_value ||
+                    re.recompile(args[1]))))
+    return (String *) 0;
+
+  if (!(source= re.convert_if_needed(source, &re.subject_converter)) ||
+      !(replace= re.convert_if_needed(replace, &re.replace_converter)))
+    goto err;
+
+  source->get_value(&src);
+  replace->get_value(&rpl);
+
+  str->length(0);
+  str->set_charset(collation.collation);
+
+  for ( ; ; ) // Iterate through all matches
+  {
+
+    if (re.exec(src.str, src.length, startoffset))
+      goto err;
+
+    if (!re.match() || re.subpattern_length(0) == 0)
+    {
+      /* 
+        No match or an empty match.
+        Append the rest of the source string
+        starting from startoffset until the end of the source.
+      */
+      if (str->append(src.str + startoffset, src.length - startoffset,
+                      re.library_charset()))
+        goto err;
+      return str;
+    }
+
+    /*
+      Append prefix, the part before the matching pattern.
+      starting from startoffset until the next match
+    */
+    if (str->append(src.str + startoffset,
+          re.subpattern_start(0) - startoffset, re.library_charset()))
+      goto err;
+
+    // Append replacement
+    if (append_replacement(str, &src, &rpl))
+      goto err;
+
+    // Set the new start point as the end of previous match
+    startoffset= re.subpattern_end(0);
+  }
+  return str;
+
+err:
+  null_value= true;
+  return (String *) 0;
+}
+
+
+bool Item_func_regexp_substr::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result_with_comparison(collation, args, 2))
+    return TRUE;
+  fix_char_length(args[0]->max_char_length());
+  re.init(collation.collation, 0);
+  re.fix_owner(this, args[0], args[1]);
+  return FALSE;
+}
+
+
+String *Item_func_regexp_substr::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  char buff0[MAX_FIELD_WIDTH];
+  String tmp0(buff0,sizeof(buff0),&my_charset_bin);
+  String *source= args[0]->val_str(&tmp0);
+
+  if ((null_value= (args[0]->null_value || re.recompile(args[1]))))
+    return (String *) 0;
+
+  if (!(source= re.convert_if_needed(source, &re.subject_converter)))
+    goto err;
+
+  str->length(0);
+  str->set_charset(collation.collation);
+
+  if (re.exec(source->ptr(), source->length(), 0))
+    goto err;
+
+  if (!re.match())
+    return str;
+
+  if (str->append(source->ptr() + re.subpattern_start(0),
+                  re.subpattern_length(0), re.library_charset()))
+    goto err;
+
+  return str;
+
+err:
+  null_value= true;
+  return (String *) 0;
+}
+
+
+/************************************************************************/
+
+
+String *Item_func_insert::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *res,*res2;
+  longlong start, length;  /* must be longlong to avoid truncation */
+
+  null_value=0;
+  res=args[0]->val_str(str);
+  res2=args[3]->val_str(&tmp_value);
+  start= args[1]->val_int();
+  length= args[2]->val_int();
+
+  if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
+      args[3]->null_value)
+    goto null; /* purecov: inspected */
+
+  if ((start <= 0) || (start > res->length()))
+    return res;                                 // Wrong param; skip insert
+  if ((length < 0) || (length > res->length()))
+    length= res->length();
+  start--;
+
+  /*
+    There is one exception not handled (intentionally) by the character set
+    aggregation code. If one string is strong side and is binary, and
+    another one is weak side and is a multi-byte character string,
+    then we need to operate on the second string in terms on bytes when
+    calling ::numchars() and ::charpos(), rather than in terms of characters.
+    Lets substitute its character set to binary.
+  */
+  if (collation.collation == &my_charset_bin)
+  {
+    res->set_charset(&my_charset_bin);
+    res2->set_charset(&my_charset_bin);
+  }
+
+  /* start and length are now sufficiently valid to pass to charpos function */
+   start= res->charpos((int) start);
+   length= res->charpos((int) length, (uint32) start);
+
+  /* Re-testing with corrected params */
+  if (start + 1 > res->length()) // remember, start = args[1].val_int() - 1
+    return res; /* purecov: inspected */        // Wrong param; skip insert
+  if (length > res->length() - start)
+    length= res->length() - start;
+
+  {
+    THD *thd= current_thd;
+    if ((ulonglong) (res->length() - length + res2->length()) >
+        (ulonglong) thd->variables.max_allowed_packet)
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                          ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                          func_name(), thd->variables.max_allowed_packet);
+      goto null;
+    }
+  }
+  res=copy_if_not_alloced(str,res,res->length());
+  res->replace((uint32) start,(uint32) length,*res2);
+  return res;
+null:
+  null_value=1;
+  return 0;
+}
+
+
+bool Item_func_insert::fix_length_and_dec(THD *thd)
+{
+  ulonglong char_length;
+
+  // Handle character set for args[0] and args[3].
+  if (agg_arg_charsets_for_string_result(collation, args, 2, 3))
+    return TRUE;
+  char_length= ((ulonglong) args[0]->max_char_length() +
+                (ulonglong) args[3]->max_char_length());
+  fix_char_length_ulonglong(char_length);
+  return FALSE;
+}
+
+
+String *Item_str_conv::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *res;
+  size_t alloced_length, len;
+
+  if ((null_value= (!(res= args[0]->val_str(&tmp_value)) ||
+                    str->alloc((alloced_length= res->length() * multiply)))))
+    return 0;
+
+  len= converter(collation.collation, (char*) res->ptr(), res->length(),
+                                      (char*) str->ptr(), alloced_length);
+  DBUG_ASSERT(len <= alloced_length);
+  str->set_charset(collation.collation);
+  str->length(len);
+  return str;
+}
+
+
+bool Item_func_lcase::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result(collation, args, 1))
+    return TRUE;
+  DBUG_ASSERT(collation.collation != NULL);
+  multiply= collation.collation->casedn_multiply();
+  converter= collation.collation->cset->casedn;
+  fix_char_length_ulonglong((ulonglong) args[0]->max_char_length() * multiply);
+  return FALSE;
+}
+
+bool Item_func_ucase::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result(collation, args, 1))
+    return TRUE;
+  DBUG_ASSERT(collation.collation != NULL);
+  multiply= collation.collation->caseup_multiply();
+  converter= collation.collation->cset->caseup;
+  fix_char_length_ulonglong((ulonglong) args[0]->max_char_length() * multiply);
+  return FALSE;
+}
+
+
+bool Item_func_left::hash_not_null(Hasher *hasher)
+{
+  StringBuffer<STRING_BUFFER_USUAL_SIZE> buf;
+  String *str= val_str(&buf);
+  DBUG_ASSERT((str == NULL) == null_value);
+  if (!str)
+    return true;
+  hasher->add(collation.collation, str->ptr(), str->length());
+  return false;
+}
+
+
+String *Item_func_left::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *res= args[0]->val_str(str);
+
+  /* must be longlong to avoid truncation */
+  longlong length= args[1]->val_int();
+  uint char_pos;
+
+  if ((null_value=(args[0]->null_value || args[1]->null_value)))
+    return 0;
+
+  /* if "unsigned_flag" is set, we have a *huge* positive number. */
+  if ((length <= 0) && (!args[1]->unsigned_flag))
+    return make_empty_result(str);
+  if ((res->length() <= (ulonglong) length) ||
+      (res->length() <= (char_pos= res->charpos((int) length))))
+    return res;
+
+  tmp_value.set(*res, 0, char_pos);
+  return &tmp_value;
+}
+
+
+void Item_str_func::left_right_max_length()
+{
+  uint32 char_length= args[0]->max_char_length();
+  if (args[1]->can_eval_in_optimize())
+  {
+    uint32 length= max_length_for_string(args[1]);
+    set_if_smaller(char_length, length);
+  }
+  fix_char_length(char_length);
+}
+
+
+bool Item_func_left::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result(collation, args, 1))
+    return TRUE;
+  DBUG_ASSERT(collation.collation != NULL);
+  left_right_max_length();
+  return FALSE;
+}
+
+
+String *Item_func_right::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *res= args[0]->val_str(str);
+  /* must be longlong to avoid truncation */
+  longlong length= args[1]->val_int();
+
+  if ((null_value=(args[0]->null_value || args[1]->null_value)))
+    return 0; /* purecov: inspected */
+
+  /* if "unsigned_flag" is set, we have a *huge* positive number. */
+  if ((length <= 0) && (!args[1]->unsigned_flag))
+    return make_empty_result(str); /* purecov: inspected */
+
+  if (res->length() <= (ulonglong) length)
+    return res; /* purecov: inspected */
+
+  uint start=res->numchars();
+  if (start <= (uint) length)
+    return res;
+  start=res->charpos(start - (uint) length);
+  tmp_value.set(*res,start,res->length()-start);
+  return &tmp_value;
+}
+
+
+bool Item_func_right::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result(collation, args, 1))
+    return TRUE;
+  DBUG_ASSERT(collation.collation != NULL);
+  left_right_max_length();
+  return FALSE;
+}
+
+
+String *Item_func_substr::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *res  = args[0]->val_str(str);
+  /* must be longlong to avoid truncation */
+  longlong start= get_position();
+  /* Assumes that the maximum length of a String is < INT_MAX32. */
+  /* Limit so that code sees out-of-bound value properly. */
+  longlong length= arg_count == 3 ? args[2]->val_int() : INT_MAX32;
+  longlong tmp_length;
+
+  if ((null_value=(args[0]->null_value || args[1]->null_value ||
+		   (arg_count == 3 && args[2]->null_value))))
+    return 0; /* purecov: inspected */
+
+  /* Negative or zero length, will return empty string. */
+  if ((arg_count == 3) && (length <= 0) && 
+      (length == 0 || !args[2]->unsigned_flag))
+    return make_empty_result(str);
+
+  /* Assumes that the maximum length of a String is < INT_MAX32. */
+  /* Set here so that rest of code sees out-of-bound value as such. */
+  if ((length <= 0) || (length > INT_MAX32))
+    length= INT_MAX32;
+
+  /* if "unsigned_flag" is set, we have a *huge* positive number. */
+  /* Assumes that the maximum length of a String is < INT_MAX32. */
+  if ((!args[1]->unsigned_flag && (start < INT_MIN32 || start > INT_MAX32)) ||
+      (args[1]->unsigned_flag && ((ulonglong) start > INT_MAX32)))
+    return make_empty_result(str);
+
+  start= ((start < 0) ? res->numchars() + start : start - 1);
+  start= res->charpos((int) start);
+  if ((start < 0) || ((uint) start + 1 > res->length()))
+    return make_empty_result(str);
+
+  length= res->charpos((int) length, (uint32) start);
+  tmp_length= res->length() - start;
+  length= MY_MIN(length, tmp_length);
+
+  if (!start && (longlong) res->length() == length)
+    return res;
+  tmp_value.set(*res, (uint32) start, (uint32) length);
+  return &tmp_value;
+}
+
+
+bool Item_func_substr::fix_length_and_dec(THD *thd)
+{
+  max_length=args[0]->max_length;
+
+  if (agg_arg_charsets_for_string_result(collation, args, 1))
+    return TRUE;
+  DBUG_ASSERT(collation.collation != NULL);
+  if (args[1]->const_item())
+  {
+    int32 start= (int32) get_position();
+    if (args[1]->null_value)
+      max_length= 0;
+    else if (start < 0)
+      max_length= ((uint)(-start) > max_length) ? 0 : (uint)(-start);
+    else
+      max_length-= MY_MIN((uint)(start - 1), max_length);
+  }
+  if (arg_count == 3 && args[2]->const_item())
+  {
+    int32 length= (int32) args[2]->val_int();
+    if (args[2]->null_value || length <= 0)
+      max_length=0; /* purecov: inspected */
+    else
+      set_if_smaller(max_length,(uint) length);
+  }
+  max_length*= collation.collation->mbmaxlen;
+  return FALSE;
+}
+
+
+bool Item_func_substr_index::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result_with_comparison(collation, args, 2))
+    return TRUE;
+  fix_char_length(args[0]->max_char_length());
+  return FALSE;
+}
+
+
+String *Item_func_substr_index::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  char buff[MAX_FIELD_WIDTH];
+  String tmp(buff,sizeof(buff),system_charset_info);
+  String *res= args[0]->val_str(&tmp_value);
+  String *delimiter= args[1]->val_str(&tmp);
+  int32 count= (int32) args[2]->val_int();
+  uint offset;
+
+  if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
+  {					// string and/or delim are null
+    null_value=1;
+    return 0;
+  }
+  null_value=0;
+  uint delimiter_length= delimiter->length();
+  if (!res->length() || !delimiter_length || !count)
+    return make_empty_result(str);      // Wrong parameters
+
+  res->set_charset(collation.collation);
+
+#ifdef USE_MB
+  if (res->use_mb())
+  {
+    const char *ptr= res->ptr();
+    const char *strend= ptr+res->length();
+    const char *end= strend-delimiter_length+1;
+    const char *search= delimiter->ptr();
+    const char *search_end= search+delimiter_length;
+    int32 n=0,c=count,pass;
+    uint32 l;
+    for (pass=(count>0);pass<2;++pass)
+    {
+      while (ptr < end)
+      {
+        if (*ptr == *search)
+        {
+	  char *i,*j;
+	  i=(char*) ptr+1; j=(char*) search+1;
+	  while (j != search_end)
+	    if (*i++ != *j++) goto skip;
+	  if (pass==0) ++n;
+	  else if (!--c) break;
+	  ptr+= delimiter_length;
+	  continue;
+	}
+    skip:
+        if ((l=my_ismbchar(res->charset(), ptr,strend))) ptr+=l;
+        else ++ptr;
+      } /* either not found or got total number when count<0 */
+      if (pass == 0) /* count<0 */
+      {
+        c+=n+1;
+        if (c<=0)
+        {
+          str->copy(res->ptr(), res->length(), collation.collation);
+          return str; // not found, return the original string
+        }
+        ptr=res->ptr();
+      }
+      else
+      {
+        if (c)
+        {
+          str->copy(res->ptr(), res->length(), collation.collation);
+          return str; // not found, return the original string
+        }
+        if (count>0) /* return left part */
+        {
+          str->copy(res->ptr(), (uint32) (ptr-res->ptr()), collation.collation);
+          return str;
+        }
+        else /* return right part */
+        {
+          ptr+= delimiter_length;
+          str->copy(res->ptr() + (ptr-res->ptr()), (uint32) (strend - ptr),
+                    collation.collation);
+          return str;
+        }
+      }
+    }
+  }
+  else
+#endif /* USE_MB */
+  {
+    if (count > 0)
+    {					// start counting from the beginning
+      for (offset=0; ; offset+= delimiter_length)
+      {
+        if ((int) (offset= res->strstr(*delimiter, offset)) < 0)
+        {
+          str->copy(res->ptr(), res->length(), collation.collation);
+          return str; // not found, return the original string
+        }
+        if (!--count)
+        {
+          str->copy(res->ptr(), offset, collation.collation);
+          return str;
+        }
+      }
+    }
+    else
+    {
+      /*
+        Negative index, start counting at the end
+      */
+      for (offset=res->length(); offset ;)
+      {
+        /* 
+          this call will result in finding the position pointing to one 
+          address space less than where the found substring is located
+          in res
+        */
+        if ((int) (offset= res->strrstr(*delimiter, offset)) < 0)
+        {
+          str->copy(res->ptr(), res->length(), collation.collation);
+          return str; // not found, return the original string
+        }
+        /*
+          At this point, we've searched for the substring
+          the number of times as supplied by the index value
+        */
+        if (!++count)
+        {
+          offset+= delimiter_length;
+          str->copy(res->ptr() + offset, res->length() - offset,
+                    collation.collation);
+          return str;
+        }
+      }
+      if (count)
+      {
+        str->copy(res->ptr(), res->length(), collation.collation);
+        return str; // not found, return the original string
+      }
+    }
+  }
+  DBUG_ASSERT(0);
+  return NULL;
+}
+
+/*
+** The trim functions are extension to ANSI SQL because they trim substrings
+** They ltrim() and rtrim() functions are optimized for 1 byte strings
+** They also return the original string if possible, else they return
+** a substring that points at the original string.
+*/
+
+
+String *Item_func_ltrim::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  char buff[MAX_FIELD_WIDTH], *ptr, *end;
+  String tmp(buff,sizeof(buff),system_charset_info);
+  String *res, *remove_str;
+  uint UNINIT_VAR(remove_length);
+
+  res= args[0]->val_str(str);
+  if ((null_value=args[0]->null_value))
+    return 0;
+  remove_str= &remove;                          /* Default value. */
+  if (arg_count == 2)
+  {
+    remove_str= args[1]->val_str(&tmp);
+    if ((null_value= args[1]->null_value))
+      return 0;
+  }
+
+  if ((remove_length= remove_str->length()) == 0 ||
+      remove_length > res->length())
+    return non_trimmed_value(res);
+
+  ptr= (char*) res->ptr();
+  end= ptr+res->length();
+  if (remove_length == 1)
+  {
+    char chr=(*remove_str)[0];
+    while (ptr != end && *ptr == chr)
+      ptr++;
+  }
+  else
+  {
+    const char *r_ptr=remove_str->ptr();
+    end-=remove_length;
+    while (ptr <= end && !memcmp(ptr, r_ptr, remove_length))
+      ptr+=remove_length;
+    end+=remove_length;
+  }
+  if (ptr == res->ptr())
+    return non_trimmed_value(res);
+  return trimmed_value(res, (uint32) (ptr - res->ptr()), (uint32) (end - ptr));
+}
+
+
+String *Item_func_rtrim::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  char buff[MAX_FIELD_WIDTH], *ptr, *end;
+  String tmp(buff, sizeof(buff), system_charset_info);
+  String *res, *remove_str;
+  uint UNINIT_VAR(remove_length);
+
+  res= args[0]->val_str(str);
+  if ((null_value=args[0]->null_value))
+    return 0;
+  remove_str= &remove;                          /* Default value. */
+  if (arg_count == 2)
+  {
+    remove_str= args[1]->val_str(&tmp);
+    if ((null_value= args[1]->null_value))
+      return 0;
+  }
+
+  if ((remove_length= remove_str->length()) == 0 ||
+      remove_length > res->length())
+    return non_trimmed_value(res);
+
+  ptr= (char*) res->ptr();
+  end= ptr+res->length();
+#ifdef USE_MB
+  char *p=ptr;
+  uint32 l;
+#endif
+  if (remove_length == 1)
+  {
+    char chr=(*remove_str)[0];
+#ifdef USE_MB
+    if (collation.collation->use_mb())
+    {
+      while (ptr < end)
+      {
+	if ((l= my_ismbchar(collation.collation, ptr, end))) ptr+= l, p=ptr;
+	else ++ptr;
+      }
+      ptr=p;
+    }
+#endif
+    while (ptr != end  && end[-1] == chr)
+      end--;
+  }
+  else
+  {
+    const char *r_ptr=remove_str->ptr();
+#ifdef USE_MB
+    if (collation.collation->use_mb())
+    {
+  loop:
+      while (ptr + remove_length < end)
+      {
+	if ((l= my_ismbchar(collation.collation, ptr, end))) ptr+= l;
+	else ++ptr;
+      }
+      if (ptr + remove_length == end && !memcmp(ptr,r_ptr,remove_length))
+      {
+	end-=remove_length;
+	ptr=p;
+	goto loop;
+      }
+    }
+    else
+#endif /* USE_MB */
+    {
+      while (ptr + remove_length <= end &&
+	     !memcmp(end-remove_length, r_ptr, remove_length))
+	end-=remove_length;
+    }
+  }
+  if (end == res->ptr()+res->length())
+    return non_trimmed_value(res);
+  return trimmed_value(res, 0, (uint32) (end - res->ptr()));
+}
+
+
+String *Item_func_trim::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  char buff[MAX_FIELD_WIDTH], *ptr, *end;
+  const char *r_ptr;
+  String tmp(buff, sizeof(buff), system_charset_info);
+  String *res, *remove_str;
+  uint UNINIT_VAR(remove_length);
+
+  res= args[0]->val_str(str);
+  if ((null_value=args[0]->null_value))
+    return 0;
+  remove_str= &remove;                          /* Default value. */
+  if (arg_count == 2)
+  {
+    remove_str= args[1]->val_str(&tmp);
+    if ((null_value= args[1]->null_value))
+      return 0;
+  }
+
+  if ((remove_length= remove_str->length()) == 0 ||
+      remove_length > res->length())
+    return non_trimmed_value(res);
+
+  ptr= (char*) res->ptr();
+  end= ptr+res->length();
+  r_ptr= remove_str->ptr();
+  while (ptr+remove_length <= end && !memcmp(ptr,r_ptr,remove_length))
+    ptr+=remove_length;
+#ifdef USE_MB
+  if (collation.collation->use_mb())
+  {
+    char *p=ptr;
+    uint32 l;
+ loop:
+    while (ptr + remove_length < end)
+    {
+      if ((l= my_ismbchar(collation.collation, ptr, end)))
+        ptr+= l;
+      else
+        ++ptr;
+    }
+    if (ptr + remove_length == end && !memcmp(ptr,r_ptr,remove_length))
+    {
+      end-=remove_length;
+      ptr=p;
+      goto loop;
+    }
+    ptr=p;
+  }
+  else
+#endif /* USE_MB */
+  {
+    while (ptr + remove_length <= end &&
+	   !memcmp(end-remove_length,r_ptr,remove_length))
+      end-=remove_length;
+  }
+  if (ptr == res->ptr() && end == ptr+res->length())
+    return non_trimmed_value(res);
+  return trimmed_value(res, (uint32) (ptr - res->ptr()), (uint32) (end - ptr));
+}
+
+bool Item_func_trim::fix_length_and_dec(THD *thd)
+{
+  if (arg_count == 1)
+  {
+    if (agg_arg_charsets_for_string_result(collation, args, 1))
+      return TRUE;
+    DBUG_ASSERT(collation.collation != NULL);
+    remove.set_charset(collation.collation);
+    remove.set_ascii(" ",1);
+  }
+  else
+  {
+    // Handle character set for args[1] and args[0].
+    // Note that we pass args[1] as the first item, and args[0] as the second.
+    if (agg_arg_charsets_for_string_result_with_comparison(collation,
+                                                           &args[1], 2, -1))
+      return TRUE;
+  }
+  fix_char_length(args[0]->max_char_length());
+  return FALSE;
+}
+
+void Item_func_trim::print(String *str, enum_query_type query_type)
+{
+  if (arg_count == 1)
+  {
+    Item_func::print(str, query_type);
+    return;
+  }
+  str->append(Item_func_trim::func_name_cstring());
+  str->append(func_name_ext());
+  str->append('(');
+  str->append(mode_name());
+  str->append(' ');
+  args[1]->print(str, query_type);
+  str->append(STRING_WITH_LEN(" from "));
+  args[0]->print(str, query_type);
+  str->append(')');
+}
+
+
+/*
+  RTRIM(expr)
+  TRIM(TRAILING ' ' FROM expr)
+  remove argument's soft dependency on PAD_CHAR_TO_FULL_LENGTH:
+*/
+Sql_mode_dependency Item_func_trim::value_depends_on_sql_mode() const
+{
+  DBUG_ASSERT(fixed());
+  if (arg_count == 1) // RTRIM(expr)
+    return (args[0]->value_depends_on_sql_mode() &
+            Sql_mode_dependency(~0, ~MODE_PAD_CHAR_TO_FULL_LENGTH)).
+           soft_to_hard();
+  // TRIM(... FROM expr)
+  DBUG_ASSERT(arg_count == 2);
+  if (!args[1]->value_depends_on_sql_mode_const_item())
+    return Item_func::value_depends_on_sql_mode();
+  StringBuffer<64> trimstrbuf;
+  String *trimstr= args[1]->val_str(&trimstrbuf);
+  if (!trimstr)
+    return Sql_mode_dependency();                  // will return NULL
+  if (trimstr->length() == 0)
+    return Item_func::value_depends_on_sql_mode(); // will trim nothing
+  if (trimstr->lengthsp() != 0)
+    return Item_func::value_depends_on_sql_mode(); // will trim not only spaces
+  if (trimstr->length() > trimstr->charset()->mbminlen ||
+      trimstr->numchars() > 1)
+    return Item_func::value_depends_on_sql_mode(); // more than one space
+  // TRIM(TRAILING ' ' FROM expr)
+  return ((args[0]->value_depends_on_sql_mode() |
+           args[1]->value_depends_on_sql_mode()) &
+          Sql_mode_dependency(~0, ~MODE_PAD_CHAR_TO_FULL_LENGTH)).
+         soft_to_hard();
+}
+
+
+/* Item_func_password */
+
+bool Item_func_password::fix_fields(THD *thd, Item **ref)
+{
+  if (deflt)
+    alg= (thd->variables.old_passwords ? OLD : NEW);
+  return Item_str_ascii_func::fix_fields(thd, ref);
+}
+
+String *Item_func_password::val_str_ascii(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *res= args[0]->val_str(str); 
+  switch (alg){
+  case NEW:
+    if (args[0]->null_value || res->length() == 0)
+      return make_empty_result(str);
+    my_make_scrambled_password(tmp_value, res->ptr(), res->length());
+    str->set(tmp_value, SCRAMBLED_PASSWORD_CHAR_LENGTH, &my_charset_latin1);
+    break;
+  case OLD:
+    if ((null_value=args[0]->null_value))
+      return 0;
+    if (res->length() == 0)
+      return make_empty_result(str);
+    my_make_scrambled_password_323(tmp_value, res->ptr(), res->length());
+    str->set(tmp_value, SCRAMBLED_PASSWORD_CHAR_LENGTH_323, &my_charset_latin1);
+    break;
+  default:
+    DBUG_ASSERT(0);
+  }
+  return str;
+}
+
+char *Item_func_password::alloc(THD *thd, const char *password,
+                                size_t pass_len, enum PW_Alg al)
+{
+  char *buff= (char *) thd->alloc((al==NEW)?
+                                  SCRAMBLED_PASSWORD_CHAR_LENGTH + 1:
+                                  SCRAMBLED_PASSWORD_CHAR_LENGTH_323 + 1);
+  if (!buff)
+    return NULL;
+
+  switch (al) {
+  case NEW:
+    my_make_scrambled_password(buff, password, pass_len);
+    break;
+  case OLD:
+    my_make_scrambled_password_323(buff, password, pass_len);
+    break;
+  default:
+    DBUG_ASSERT(0);
+  }
+  return buff;
+}
+
+
+
+#define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
+
+String *Item_func_encrypt::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+
+#ifdef HAVE_CRYPT
+  String *res  =args[0]->val_str(str);
+
+  char salt[3],*salt_ptr;
+  if ((null_value=args[0]->null_value))
+    return 0;
+  if (res->length() == 0)
+    return make_empty_result(str);
+  if (arg_count == 1)
+  {					// generate random salt
+    time_t timestamp=current_thd->query_start();
+    salt[0] = bin_to_ascii( (ulong) timestamp & 0x3f);
+    salt[1] = bin_to_ascii(( (ulong) timestamp >> 5) & 0x3f);
+    salt[2] = 0;
+    salt_ptr=salt;
+  }
+  else
+  {					// obtain salt from the first two bytes
+    String *salt_str=args[1]->val_str(&tmp_value);
+    if ((null_value= (args[1]->null_value || salt_str->length() < 2)))
+      return 0;
+    salt_ptr= salt_str->c_ptr_safe();
+  }
+  mysql_mutex_lock(&LOCK_crypt);
+  char *tmp= crypt(res->c_ptr_safe(),salt_ptr);
+  if (!tmp)
+  {
+    mysql_mutex_unlock(&LOCK_crypt);
+    null_value= 1;
+    return 0;
+  }
+  str->set(tmp, (uint) strlen(tmp), &my_charset_bin);
+  str->copy();
+  mysql_mutex_unlock(&LOCK_crypt);
+  return str;
+#else
+  null_value=1;
+  return 0;
+#endif	/* HAVE_CRYPT */
+}
+
+bool Item_func_encode::seed()
+{
+  char buf[80];
+  ulong rand_nr[2];
+  String *key, tmp(buf, sizeof(buf), system_charset_info);
+
+  if (!(key= args[1]->val_str(&tmp)))
+    return TRUE;
+
+  hash_password(rand_nr, key->ptr(), key->length());
+  sql_crypt.init(rand_nr);
+
+  return FALSE;
+}
+
+bool Item_func_encode::fix_length_and_dec(THD *thd)
+{
+  max_length=args[0]->max_length;
+  base_flags|= ((args[0]->base_flags | args[1]->base_flags) &
+                item_base_t::MAYBE_NULL);
+  collation.set(&my_charset_bin);
+  /* Precompute the seed state if the item is constant. */
+  seeded= args[1]->const_item() &&
+          (args[1]->result_type() == STRING_RESULT) && !seed();
+  return FALSE;
+}
+
+String *Item_func_encode::val_str(String *str)
+{
+  String *res;
+  DBUG_ASSERT(fixed());
+
+  if (!(res=args[0]->val_str(str)))
+  {
+    null_value= 1;
+    return NULL;
+  }
+
+  if (!seeded && seed())
+  {
+    null_value= 1;
+    return NULL;
+  }
+
+  null_value= 0;
+  res= copy_if_not_alloced(str, res, res->length());
+  crypto_transform(res);
+  sql_crypt.reinit();
+
+  return res;
+}
+
+void Item_func_encode::crypto_transform(String *res)
+{
+  sql_crypt.encode((char*) res->ptr(),res->length());
+  res->set_charset(&my_charset_bin);
+}
+
+void Item_func_decode::crypto_transform(String *res)
+{
+  sql_crypt.decode((char*) res->ptr(),res->length());
+}
+
+
+String *Item_func_database::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  THD *thd= current_thd;
+  if (thd->db.str == NULL)
+  {
+    null_value= 1;
+    return 0;
+  }
+  else
+    str->copy(thd->db.str, thd->db.length, system_charset_info);
+  null_value= 0;
+  return str;
+}
+
+
+String *Item_func_sqlerrm::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  DBUG_ASSERT(!null_value);
+  Diagnostics_area::Sql_condition_iterator it=
+    current_thd->get_stmt_da()->sql_conditions();
+  const Sql_condition *err;
+  if ((err= it++))
+  {
+    str->copy(err->get_message_text(), err->get_message_octet_length(),
+              system_charset_info);
+    return str;
+  }
+  str->copy(STRING_WITH_LEN("normal, successful completion"),
+            system_charset_info);
+  return str;
+}
+
+
+/**
+  @note USER() is replicated correctly if binlog_format=ROW or (as of
+  BUG#28086) binlog_format=MIXED, but is incorrectly replicated to ''
+  if binlog_format=STATEMENT.
+*/
+bool Item_func_user::init(const char *user, const char *host)
+{
+  DBUG_ASSERT(fixed());
+
+  // For system threads (e.g. replication SQL thread) user may be empty
+  if (user)
+  {
+    CHARSET_INFO *cs= str_value.charset();
+    size_t res_length= (strlen(user)+strlen(host)+2) * cs->mbmaxlen;
+
+    if (str_value.alloc((uint) res_length))
+    {
+      null_value=1;
+      return TRUE;
+    }
+
+    res_length=cs->cset->snprintf(cs, (char*)str_value.ptr(), (uint) res_length,
+                                  "%s@%s", user, host);
+    str_value.length((uint) res_length);
+    str_value.mark_as_const();
+  }
+  return FALSE;
+}
+
+
+Item *Item_func_sysconst::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
+{
+  /*
+   During view or prepared statement creation, the item should not
+   make use of const_charset_converter as it would imply substitution
+   with constant items which is not correct. Functions can have different
+   values during view creation and view execution based on context.
+
+   Return the identical item during view creation and prepare.
+  */
+  if (thd->lex->is_ps_or_view_context_analysis())
+    return this;
+  return const_charset_converter(thd, tocs, true, fully_qualified_func_name());
+}
+
+bool Item_func_sysconst::const_item() const
+{
+  if (current_thd->lex->is_ps_or_view_context_analysis())
+    return false;
+  return true;
+}
+
+bool Item_func_user::fix_fields(THD *thd, Item **ref)
+{
+  return (Item_func_sysconst::fix_fields(thd, ref) ||
+          init(thd->main_security_ctx.user,
+               thd->main_security_ctx.host_or_ip));
+}
+
+
+bool Item_func_current_user::fix_fields(THD *thd, Item **ref)
+{
+  if (Item_func_sysconst::fix_fields(thd, ref))
+    return TRUE;
+
+  Security_context *ctx= context && context->security_ctx
+                          ? context->security_ctx : thd->security_ctx;
+  return init(ctx->priv_user, ctx->priv_host);
+}
+
+bool Item_func_current_role::fix_fields(THD *thd, Item **ref)
+{
+  if (Item_func_sysconst::fix_fields(thd, ref))
+    return 1;
+
+  Security_context *ctx= context && context->security_ctx
+                          ? context->security_ctx : thd->security_ctx;
+  if (ctx->priv_role[0])
+  {
+    if (str_value.copy(ctx->priv_role, strlen(ctx->priv_role),
+                       system_charset_info))
+      return 1;
+    str_value.mark_as_const();
+    null_value= 0;
+    base_flags&= ~item_base_t::MAYBE_NULL;
+    return 0;
+  }
+  null_value= 1;
+  set_maybe_null();
+  return 0;
+}
+
+bool Item_func_soundex::fix_length_and_dec(THD *thd)
+{
+  uint32 char_length= args[0]->max_char_length();
+  if (agg_arg_charsets_for_string_result(collation, args, 1))
+    return TRUE;
+  DBUG_ASSERT(collation.collation != NULL);
+  set_if_bigger(char_length, 4);
+  fix_char_length(char_length);
+  return FALSE;
+}
+
+
+/**
+  If alpha, map input letter to soundex code.
+  If not alpha and remove_garbage is set then skip to next char
+  else return 0
+*/
+
+static int soundex_toupper(int ch)
+{
+  return (ch >= 'a' && ch <= 'z') ? ch - 'a' + 'A' : ch;
+}
+
+
+static char get_scode(int wc)
+{
+  int ch= soundex_toupper(wc);
+  if (ch < 'A' || ch > 'Z')
+  {
+					// Thread extended alfa (country spec)
+    return '0';				// as vokal
+  }
+  return(soundex_map[ch-'A']);
+}
+
+
+static bool my_uni_isalpha(int wc)
+{
+  /*
+    Return true for all Basic Latin letters: a..z A..Z.
+    Return true for all Unicode characters with code higher than U+00C0:
+    - characters between 'z' and U+00C0 are controls and punctuations.
+    - "U+00C0 LATIN CAPITAL LETTER A WITH GRAVE" is the first letter after 'z'.
+  */
+  return (wc >= 'a' && wc <= 'z') ||
+         (wc >= 'A' && wc <= 'Z') ||
+         (wc >= 0xC0);
+}
+
+
+String *Item_func_soundex::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *res= args[0]->val_str(&tmp_value);
+  char last_ch,ch;
+  CHARSET_INFO *cs= collation.collation;
+  my_wc_t wc;
+  uint nchars;
+  int rc;
+
+  if ((null_value= args[0]->null_value))
+    return 0; /* purecov: inspected */
+
+  if (str->alloc(MY_MAX(res->length(), 4 * cs->mbminlen)))
+    return &tmp_value; /* purecov: inspected */
+  str->set_charset(collation.collation);
+  char *to= (char *) str->ptr();
+  char *to_end= to + str->alloced_length();
+  char *from= (char *) res->ptr(), *end= from + res->length();
+  
+  for ( ; ; ) /* Skip pre-space */
+  {
+    if ((rc= cs->mb_wc(&wc, (uchar*) from, (uchar*) end)) <= 0)
+      return make_empty_result(str); /* EOL or invalid byte sequence */
+
+    if (rc == 1 && cs->m_ctype)
+    {
+      /* Single byte letter found */
+      if (my_isalpha(cs, *from))
+      {
+        last_ch= get_scode(*from);       // Code of the first letter
+        *to++= soundex_toupper(*from++); // Copy first letter
+        break;
+      }
+      from++;
+    }
+    else
+    {
+      from+= rc;
+      if (my_uni_isalpha(wc))
+      {
+        /* Multibyte letter found */
+        wc= soundex_toupper(wc);
+        last_ch= get_scode(wc);     // Code of the first letter
+        if ((rc= cs->wc_mb(wc, (uchar*) to, (uchar*) to_end)) <= 0)
+        {
+          /* Extra safety - should not really happen */
+          DBUG_ASSERT(false);
+          return make_empty_result(str);
+        }
+        to+= rc;
+        break;
+      }
+    }
+  }
+  
+  /*
+     last_ch is now set to the first 'double-letter' check.
+     loop on input letters until end of input
+  */
+  for (nchars= 1 ; ; )
+  {
+    if ((rc= cs->mb_wc(&wc, (uchar*) from, (uchar*) end)) <= 0)
+      break; /* EOL or invalid byte sequence */
+
+    if (rc == 1 && cs->m_ctype)
+    {
+      if (!my_isalpha(cs, *from++))
+        continue;
+    }
+    else
+    {
+      from+= rc;
+      if (!my_uni_isalpha(wc))
+        continue;
+    }
+    
+    ch= get_scode(wc);
+    if ((ch != '0') && (ch != last_ch)) // if not skipped or double
+    {
+      // letter, copy to output
+      if ((rc= cs->wc_mb((my_wc_t) ch, (uchar*) to, (uchar*) to_end)) <= 0)
+      {
+        // Extra safety - should not really happen
+        DBUG_ASSERT(false);
+        break;
+      }
+      to+= rc;
+      nchars++;
+      last_ch= ch;  // save code of last input letter
+    }               // for next double-letter check
+  }
+  
+  /* Pad up to 4 characters with DIGIT ZERO, if the string is shorter */
+  if (nchars < 4) 
+  {
+    uint nbytes= (4 - nchars) * cs->mbminlen;
+    cs->fill(to, nbytes, '0');
+    to+= nbytes;
+  }
+
+  str->length((uint) (to - str->ptr()));
+  return str;
+}
+
+
+/**
+  Change a number to format '3,333,333,333.000'.
+
+  This should be 'internationalized' sometimes.
+*/
+
+/*
+  The maximum supported decimal scale:
+  38 - starting from 10.2.1
+  30 - before 10.2.1
+*/
+const int FORMAT_MAX_DECIMALS= 38;
+
+
+bool Item_func_format::fix_length_and_dec(THD *thd)
+{
+  uint32 char_length= args[0]->type_handler()->Item_decimal_notation_int_digits(args[0]);
+  uint dec= FORMAT_MAX_DECIMALS;
+  /*
+    Format can require one more integer digit if rounding happens:
+      FORMAT(9.9,0) -> '10'
+    Set need_extra_digit_for_rounding to true by default
+    if args[0] has some decimals: if args[1] is not
+    a constant, then format can potentially reduce
+    the number of decimals and round to the next integer.
+  */
+  bool need_extra_digit_for_rounding= args[0]->decimals > 0;
+  if (args[1]->can_eval_in_optimize())
+  {
+    Longlong_hybrid tmp= args[1]->to_longlong_hybrid();
+    if (!args[1]->null_value)
+    {
+      dec= tmp.to_uint(FORMAT_MAX_DECIMALS);
+      need_extra_digit_for_rounding= (dec < args[0]->decimals);
+    }
+  }
+  /*
+    In case of a data type with zero integer digits, e.g. DECIMAL(4,4),
+    we'll print at least one integer digit.
+  */
+  if (need_extra_digit_for_rounding || !char_length)
+    char_length++;
+  uint32 max_sep_count= (char_length / 3) + (dec ? 1 : 0) + /*sign*/1;
+  collation.set(default_charset());
+  fix_char_length(char_length + max_sep_count + dec);
+  if (arg_count == 3)
+    locale= args[2]->basic_const_item() ? args[2]->locale_from_val_str() : NULL;
+  else
+    locale= &my_locale_en_US; /* Two arguments */
+  return FALSE;
+}
+
+
+/**
+  @todo
+  This needs to be fixed for multi-byte character set where numbers
+  are stored in more than one byte
+*/
+
+String *Item_func_format::val_str_ascii(String *str)
+{
+  uint32 str_length;
+  /* Number of decimal digits */
+  int dec;
+  /* Number of characters used to represent the decimals, including '.' */
+  uint32 dec_length;
+  const MY_LOCALE *lc;
+  DBUG_ASSERT(fixed());
+
+  dec= (int) args[1]->val_int();
+  if (args[1]->null_value)
+  {
+    null_value=1;
+    return NULL;
+  }
+
+  lc= locale ? locale : args[2]->locale_from_val_str();
+
+  dec= set_zone(dec, 0, FORMAT_MAX_DECIMALS);
+  dec_length= dec ? dec+1 : 0;
+  null_value=0;
+
+  if (args[0]->result_type() == DECIMAL_RESULT ||
+      args[0]->result_type() == INT_RESULT)
+  {
+    VDec res(args[0]);
+    if ((null_value= res.is_null()))
+      return 0; /* purecov: inspected */
+    res.to_string_round(str, dec);
+    str_length= str->length();
+  }
+  else
+  {
+    double nr= args[0]->val_real();
+    if ((null_value=args[0]->null_value))
+      return 0; /* purecov: inspected */
+    nr= my_double_round(nr, (longlong) dec, FALSE, FALSE);
+    str->set_fcvt(nr, dec);
+    if (!std::isfinite(nr))
+      return str;
+    str_length=str->length();
+  }
+  /* We need this test to handle 'nan' and short values */
+  if (lc->grouping[0] > 0 &&
+      str_length >= dec_length + 1 + lc->grouping[0])
+  {
+    /* We need space for ',' between each group of digits as well. */
+    char buf[2 * FLOATING_POINT_BUFFER];
+    int count;
+    const char *grouping= lc->grouping;
+    char sign_length= *str->ptr() == '-' ? 1 : 0;
+    const char *src= str->ptr() + str_length - dec_length - 1;
+    const char *src_begin= str->ptr() + sign_length;
+    char *dst= buf + sizeof(buf);
+    
+    /* Put the fractional part */
+    if (dec)
+    {
+      dst-= (dec + 1);
+      *dst= lc->decimal_point;
+      memcpy(dst + 1, src + 2, dec);
+    }
+    
+    /* Put the integer part with grouping */
+    for (count= *grouping; src >= src_begin; count--)
+    {
+      /*
+        When *grouping==0x80 (which means "end of grouping")
+        count will be initialized to -1 and
+        we'll never get into this "if" anymore.
+      */
+      if (count == 0)
+      {
+        *--dst= lc->thousand_sep;
+        if (grouping[1])
+          grouping++;
+        count= *grouping;
+      }
+      DBUG_ASSERT(dst > buf);
+      *--dst= *src--;
+    }
+    
+    if (sign_length) /* Put '-' */
+      *--dst= *str->ptr();
+    
+    /* Put the rest of the integer part without grouping */
+    str->copy(dst, buf + sizeof(buf) - dst, &my_charset_latin1);
+  }
+  else if (dec_length && lc->decimal_point != '.')
+  {
+    /*
+      For short values without thousands (<1000)
+      replace decimal point to localized value.
+    */
+    DBUG_ASSERT(dec_length <= str_length);
+    ((char*) str->ptr())[str_length - dec_length]= lc->decimal_point;
+  }
+  return str;
+}
+
+
+bool Item_func_elt::fix_length_and_dec(THD *thd)
+{
+  uint32 char_length= 0;
+  decimals=0;
+
+  if (agg_arg_charsets_for_string_result(collation, args + 1, arg_count - 1))
+    return TRUE;
+
+  for (uint i= 1 ; i < arg_count ; i++)
+  {
+    set_if_bigger(char_length, args[i]->max_char_length());
+    set_if_bigger(decimals,args[i]->decimals);
+  }
+  fix_char_length(char_length);
+  set_maybe_null(); // NULL if wrong first arg
+  return FALSE;
+}
+
+
+double Item_func_elt::val_real()
+{
+  DBUG_ASSERT(fixed());
+  uint tmp;
+  null_value=1;
+  if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
+    return 0.0;
+  double result= args[tmp]->val_real();
+  null_value= args[tmp]->null_value;
+  return result;
+}
+
+
+longlong Item_func_elt::val_int()
+{
+  DBUG_ASSERT(fixed());
+  uint tmp;
+  null_value=1;
+  if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
+    return 0;
+
+  longlong result= args[tmp]->val_int();
+  null_value= args[tmp]->null_value;
+  return result;
+}
+
+
+String *Item_func_elt::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  uint tmp;
+  null_value=1;
+  if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
+    return NULL;
+
+  String *result= args[tmp]->val_str(str);
+  if (result)
+    result->set_charset(collation.collation);
+  null_value= args[tmp]->null_value;
+  return result;
+}
+
+
+bool Item_func_make_set::fix_length_and_dec(THD *thd)
+{
+  uint32 char_length= arg_count - 2; /* Separators */
+
+  if (agg_arg_charsets_for_string_result(collation, args + 1, arg_count - 1))
+    return TRUE;
+  
+  for (uint i=1 ; i < arg_count ; i++)
+    char_length+= args[i]->max_char_length();
+  fix_char_length(char_length);
+  return FALSE;
+}
+
+
+String *Item_func_make_set::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  ulonglong bits;
+  bool first_found=0;
+  Item **ptr=args+1;
+  String *result= make_empty_result(str);
+
+  bits=args[0]->val_int();
+  if ((null_value=args[0]->null_value))
+    return NULL;
+
+  if (arg_count < 65)
+    bits &= ((ulonglong) 1 << (arg_count-1))-1;
+
+  for (; bits; bits >>= 1, ptr++)
+  {
+    if (bits & 1)
+    {
+      String *res= (*ptr)->val_str(str);
+      if (res)					// Skip nulls
+      {
+	if (!first_found)
+	{					// First argument
+	  first_found=1;
+	  if (res != str)
+	    result=res;				// Use original string
+	  else
+	  {
+	    if (tmp_str.copy(*res))		// Don't use 'str'
+              return make_empty_result(str);
+	    result= &tmp_str;
+	  }
+	}
+	else
+	{
+	  if (result != &tmp_str)
+	  {					// Copy data to tmp_str
+	    if (tmp_str.alloc(result->length()+res->length()+1) ||
+		tmp_str.copy(*result))
+              return make_empty_result(str);
+	    result= &tmp_str;
+	  }
+	  if (tmp_str.append(STRING_WITH_LEN(","), &my_charset_bin) || tmp_str.append(*res))
+            return make_empty_result(str);
+	}
+      }
+    }
+  }
+  return result;
+}
+
+
+void Item_func_char::print(String *str, enum_query_type query_type)
+{
+  str->append(Item_func_char::func_name_cstring());
+  str->append('(');
+  print_args(str, 0, query_type);
+  if (collation.collation != &my_charset_bin)
+  {
+    str->append(STRING_WITH_LEN(" using "));
+    str->append(collation.collation->cs_name);
+  }
+  str->append(')');
+}
+
+
+String *Item_func_char::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  str->length(0);
+  str->set_charset(collation.collation);
+  for (uint i=0 ; i < arg_count ; i++)
+  {
+    int32 num=(int32) args[i]->val_int();
+    if (!args[i]->null_value)
+      append_char(str, num);
+  }
+  str->realloc(str->length());			// Add end 0 (for Purify)
+  return check_well_formed_result(str);
+}
+
+
+void Item_func_char::append_char(String *str, int32 num)
+{
+  char tmp[4];
+  if (num & 0xFF000000L)
+  {
+    mi_int4store(tmp, num);
+    str->append(tmp, 4, &my_charset_bin);
+  }
+  else if (num & 0xFF0000L)
+  {
+    mi_int3store(tmp, num);
+    str->append(tmp, 3, &my_charset_bin);
+  }
+  else if (num & 0xFF00L)
+  {
+    mi_int2store(tmp, num);
+    str->append(tmp, 2, &my_charset_bin);
+  }
+  else
+  {
+    tmp[0]= (char) num;
+    str->append(tmp, 1, &my_charset_bin);
+  }
+}
+
+
+String *Item_func_chr::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  str->length(0);
+  str->set_charset(collation.collation);
+  int32 num=(int32) args[0]->val_int();
+  if (!args[0]->null_value)
+    append_char(str, num);
+  else
+  {
+    null_value= 1;
+    return 0;
+  }
+  str->realloc(str->length());			// Add end 0 (for Purify)
+  return check_well_formed_result(str);
+}
+
+
+inline String* alloc_buffer(String *res,String *str,String *tmp_value,
+			    ulong length)
+{
+  if (res->alloced_length() < length)
+  {
+    if (str->alloced_length() >= length)
+    {
+      (void) str->copy(*res);
+      str->length(length);
+      return str;
+    }
+    if (tmp_value->alloc(length))
+      return 0;
+    (void) tmp_value->copy(*res);
+    tmp_value->length(length);
+    return tmp_value;
+  }
+  res->length(length);
+  return res;
+}
+
+
+bool Item_func_repeat::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result(collation, args, 1))
+    return TRUE;
+  DBUG_ASSERT(collation.collation != NULL);
+  if (args[1]->can_eval_in_optimize())
+  {
+    uint32 length= max_length_for_string(args[1]);
+    ulonglong char_length= (ulonglong) args[0]->max_char_length() * length;
+    fix_char_length_ulonglong(char_length);
+    return false;
+  }
+  max_length= MAX_BLOB_WIDTH;
+  set_maybe_null();
+  return false;
+}
+
+/**
+  Item_func_repeat::str is carefully written to avoid reallocs
+  as much as possible at the cost of a local buffer
+*/
+
+String *Item_func_repeat::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  uint length,tot_length;
+  char *to;
+  /* must be longlong to avoid truncation */
+  longlong count= args[1]->val_int();
+  String *res= args[0]->val_str(str);
+
+  if (args[0]->null_value || args[1]->null_value)
+    goto err;				// string and/or delim are null
+  null_value= 0;
+
+  if (count <= 0 && (count == 0 || !args[1]->unsigned_flag))
+    return make_empty_result(str);
+
+  /* Assumes that the maximum length of a String is < INT_MAX32. */
+  /* Bounds check on count:  If this is triggered, we will error. */
+  if ((ulonglong) count > INT_MAX32)
+    count= INT_MAX32;
+  if (count == 1)			// To avoid reallocs
+    return res;
+  length=res->length();
+
+  // Safe length check
+  {
+    THD *thd= current_thd;
+    if (length > thd->variables.max_allowed_packet / (uint) count)
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                          ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                          func_name(), thd->variables.max_allowed_packet);
+      goto err;
+    }
+  }
+  tot_length= length*(uint) count;
+  if (!(res= alloc_buffer(res,str,&tmp_value,tot_length)))
+    goto err;
+
+  to=(char*) res->ptr()+length;
+  while (--count)
+  {
+    memcpy(to,res->ptr(),length);
+    to+=length;
+  }
+  return (res);
+
+err:
+  null_value=1;
+  return 0;
+}
+
+
+bool Item_func_space::fix_length_and_dec(THD *thd)
+{
+  collation.set(default_charset(), DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII);
+  if (args[0]->can_eval_in_optimize())
+  {
+    fix_char_length_ulonglong(max_length_for_string(args[0]));
+    return false;
+  }
+  max_length= MAX_BLOB_WIDTH;
+  set_maybe_null();
+  return false;
+}
+
+
+String *Item_func_space::val_str(String *str)
+{
+  uint tot_length;
+  longlong count= args[0]->val_int();
+  CHARSET_INFO *cs= collation.collation;
+
+  if (args[0]->null_value)
+    goto err;				// string and/or delim are null
+  null_value= 0;
+
+  if (count <= 0 && (count == 0 || !args[0]->unsigned_flag))
+    return make_empty_result(str);
+  /*
+   Assumes that the maximum length of a String is < INT_MAX32.
+   Bounds check on count:  If this is triggered, we will error.
+  */
+  if ((ulonglong) count > INT_MAX32)
+    count= INT_MAX32;
+
+  // Safe length check
+  tot_length= (uint) count * cs->mbminlen;
+  {
+    THD *thd= current_thd;
+    if (tot_length > thd->variables.max_allowed_packet)
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                          ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                          func_name(),
+                          thd->variables.max_allowed_packet);
+      goto err;
+    }
+  }
+  if (str->alloc(tot_length))
+    goto err;
+  str->length(tot_length);
+  str->set_charset(cs);
+  cs->fill((char*) str->ptr(), tot_length, ' ');
+  return str;
+
+err:
+  null_value= 1;
+  return 0;
+}
+
+
+bool Item_func_binlog_gtid_pos::fix_length_and_dec(THD *thd)
+{
+  collation.set(system_charset_info);
+  max_length= MAX_BLOB_WIDTH;
+  set_maybe_null();
+  return FALSE;
+}
+
+
+String *Item_func_binlog_gtid_pos::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+#ifndef HAVE_REPLICATION
+  null_value= 0;
+  str->copy("", 0, system_charset_info);
+  return str;
+#else
+  String name_str, *name;
+  longlong pos;
+
+  if (args[0]->null_value || args[1]->null_value)
+    goto err;
+
+  name= args[0]->val_str(&name_str);
+  pos= args[1]->val_int();
+
+  if (pos < 0 || pos > UINT_MAX32)
+    goto err;
+
+  if (gtid_state_from_binlog_pos(name->c_ptr_safe(), (uint32)pos, str))
+    goto err;
+  null_value= 0;
+  return str;
+
+err:
+  null_value= 1;
+  return NULL;
+#endif  /* !HAVE_REPLICATION */
+}
+
+
+static String *default_pad_str(String *pad_str, CHARSET_INFO *collation)
+{
+  pad_str->set_charset(collation);
+  pad_str->length(0);
+  pad_str->append(" ", 1);
+  return pad_str;
+}
+
+bool Item_func_pad::fix_length_and_dec(THD *thd)
+{
+  if (arg_count == 3)
+  {
+    String *str;
+    if (!args[2]->basic_const_item() || !(str= args[2]->val_str(&pad_str)) ||
+        !str->length())
+      set_maybe_null();
+    // Handle character set for args[0] and args[2].
+    if (agg_arg_charsets_for_string_result(collation, &args[0], 2, 2))
+      return TRUE;
+  }
+  else
+  {
+    if (agg_arg_charsets_for_string_result(collation, &args[0], 1, 1))
+      return TRUE;
+    default_pad_str(&pad_str, collation.collation);
+  }
+
+  DBUG_ASSERT(collation.collation->mbmaxlen > 0);
+  if (args[1]->can_eval_in_optimize())
+  {
+    fix_char_length_ulonglong(max_length_for_string(args[1]));
+    return false;
+  }
+  max_length= MAX_BLOB_WIDTH;
+  set_maybe_null();
+  return false;
+}
+
+
+/*
+  PAD(expr,length,' ')
+  removes argument's soft dependency on PAD_CHAR_TO_FULL_LENGTH if the result
+  is longer than the argument's maximim possible length.
+*/
+Sql_mode_dependency Item_func_rpad::value_depends_on_sql_mode() const
+{
+  DBUG_ASSERT(fixed());
+  DBUG_ASSERT(arg_count >= 2);
+  if (!args[1]->value_depends_on_sql_mode_const_item() ||
+          (arg_count == 3 && !args[2]->value_depends_on_sql_mode_const_item()))
+    return Item_func::value_depends_on_sql_mode();
+  Longlong_hybrid len= args[1]->to_longlong_hybrid();
+  if (args[1]->null_value || len.neg())
+    return Sql_mode_dependency();                  // will return NULL
+  if (len.abs() > 0 && len.abs() < args[0]->max_char_length())
+    return Item_func::value_depends_on_sql_mode();
+  StringBuffer<64> padstrbuf;
+  String *padstr= arg_count == 3 ? args[2]->val_str(&padstrbuf) :
+                               default_pad_str(&padstrbuf, collation.collation);
+  if (!padstr || !padstr->length())
+    return Sql_mode_dependency();                  // will return NULL
+  if (padstr->lengthsp() != 0)
+    return Item_func::value_depends_on_sql_mode(); // will pad not only spaces
+  // RPAD(expr, length, ' ')  -- with a long enough length
+  return ((args[0]->value_depends_on_sql_mode() |
+           args[1]->value_depends_on_sql_mode()) &
+          Sql_mode_dependency(~0, ~MODE_PAD_CHAR_TO_FULL_LENGTH)).
+         soft_to_hard();
+}
+
+
+
+String *Item_func_rpad::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  uint32 res_byte_length,res_char_length,pad_char_length,pad_byte_length;
+  char *to;
+  const char *ptr_pad;
+  /* must be longlong to avoid truncation */
+  longlong count= args[1]->val_int();
+  longlong byte_count;
+  String *res= args[0]->val_str(str);
+  String *rpad= arg_count == 2 ? &pad_str : args[2]->val_str(&pad_str);
+
+  if (!res || args[1]->null_value || !rpad || 
+      ((count < 0) && !args[1]->unsigned_flag))
+    goto err;
+
+  null_value=0;
+
+  if (count == 0)
+    return make_empty_result(str);
+
+  /* Assumes that the maximum length of a String is < INT_MAX32. */
+  /* Set here so that rest of code sees out-of-bound value as such. */
+  if ((ulonglong) count > INT_MAX32)
+    count= INT_MAX32;
+  /*
+    There is one exception not handled (intentionally) by the character set
+    aggregation code. If one string is strong side and is binary, and
+    another one is weak side and is a multi-byte character string,
+    then we need to operate on the second string in terms on bytes when
+    calling ::numchars() and ::charpos(), rather than in terms of characters.
+    Lets substitute its character set to binary.
+  */
+  if (collation.collation == &my_charset_bin)
+  {
+    res->set_charset(&my_charset_bin);
+    rpad->set_charset(&my_charset_bin);
+  }
+
+  if (count <= (res_char_length= res->numchars()))
+  {						// String to pad is big enough
+    res->length(res->charpos((int) count));	// Shorten result if longer
+    return (res);
+  }
+
+  byte_count= count * collation.collation->mbmaxlen;
+  {
+    THD *thd= current_thd;
+    if ((ulonglong) byte_count > thd->variables.max_allowed_packet)
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                          ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                          func_name(), thd->variables.max_allowed_packet);
+      goto err;
+    }
+  }
+
+  if (arg_count == 3)
+  {
+    if (args[2]->null_value || !(pad_char_length= rpad->numchars()))
+      goto err;
+  }
+  else
+    pad_char_length= 1; // Implicit space
+
+  res_byte_length= res->length();	/* Must be done before alloc_buffer */
+  if (!(res= alloc_buffer(res,str,&tmp_value, (ulong) byte_count)))
+    goto err;
+
+  to= (char*) res->ptr()+res_byte_length;
+  ptr_pad=rpad->ptr();
+  pad_byte_length= rpad->length();
+  count-= res_char_length;
+  for ( ; (uint32) count > pad_char_length; count-= pad_char_length)
+  {
+    memcpy(to,ptr_pad,pad_byte_length);
+    to+= pad_byte_length;
+  }
+  if (count)
+  {
+    pad_byte_length= rpad->charpos((int) count);
+    memcpy(to,ptr_pad,(size_t) pad_byte_length);
+    to+= pad_byte_length;
+  }
+  res->length((uint) (to- (char*) res->ptr()));
+  return (res);
+
+ err:
+  null_value=1;
+  return 0;
+}
+
+
+String *Item_func_lpad::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  uint32 res_char_length,pad_char_length;
+  /* must be longlong to avoid truncation */
+  longlong count= args[1]->val_int();
+  longlong byte_count;
+  String *res= args[0]->val_str(&tmp_value);
+  String *pad= arg_count == 2 ? &pad_str : args[2]->val_str(&pad_str);
+
+  if (!res || args[1]->null_value || !pad ||  
+      ((count < 0) && !args[1]->unsigned_flag))
+    goto err;  
+
+  null_value=0;
+
+  if (count == 0)
+    return make_empty_result(str);
+
+  /* Assumes that the maximum length of a String is < INT_MAX32. */
+  /* Set here so that rest of code sees out-of-bound value as such. */
+  if ((ulonglong) count > INT_MAX32)
+    count= INT_MAX32;
+
+  /*
+    There is one exception not handled (intentionally) by the character set
+    aggregation code. If one string is strong side and is binary, and
+    another one is weak side and is a multi-byte character string,
+    then we need to operate on the second string in terms on bytes when
+    calling ::numchars() and ::charpos(), rather than in terms of characters.
+    Lets substitute its character set to binary.
+  */
+  if (collation.collation == &my_charset_bin)
+  {
+    res->set_charset(&my_charset_bin);
+    pad->set_charset(&my_charset_bin);
+  }
+
+  res_char_length= res->numchars();
+
+  if (count <= res_char_length)
+  {
+    res->length(res->charpos((int) count));
+    return res;
+  }
+  
+  byte_count= count * collation.collation->mbmaxlen;
+  
+  {
+    THD *thd= current_thd;
+    if ((ulonglong) byte_count > thd->variables.max_allowed_packet)
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                          ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                          func_name(), thd->variables.max_allowed_packet);
+      goto err;
+    }
+  }
+
+  if (str->alloc((uint32) byte_count))
+    goto err;
+
+  if (arg_count == 3)
+  {
+    if (args[2]->null_value || !(pad_char_length= pad->numchars()))
+      goto err;
+  }
+  else
+    pad_char_length= 1; // Implicit space
+  
+  str->length(0);
+  str->set_charset(collation.collation);
+  count-= res_char_length;
+  while (count >= pad_char_length)
+  {
+    str->append(*pad);
+    count-= pad_char_length;
+  }
+  if (count > 0)
+    str->append(pad->ptr(), pad->charpos((int) count), collation.collation);
+
+  str->append(*res);
+  null_value= 0;
+  return str;
+
+err:
+  null_value= 1;
+  return 0;
+}
+
+
+String *Item_func_conv::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *res= args[0]->val_str(str);
+  char *endptr,ans[65],*ptr;
+  longlong dec;
+  int from_base= (int) args[1]->val_int();
+  int to_base= (int) args[2]->val_int();
+  int err;
+
+  // Note that abs(INT_MIN) is undefined.
+  if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
+      from_base == INT_MIN || to_base == INT_MIN ||
+      abs(to_base) > 36 || abs(to_base) < 2 ||
+      abs(from_base) > 36 || abs(from_base) < 2 || !(res->length()))
+  {
+    null_value= 1;
+    return NULL;
+  }
+  null_value= 0;
+  unsigned_flag= !(from_base < 0);
+
+  if (args[0]->field_type() == MYSQL_TYPE_BIT) 
+  {
+    /* 
+     Special case: The string representation of BIT doesn't resemble the
+     decimal representation, so we shouldn't change it to string and then to
+     decimal. 
+    */
+    dec= args[0]->val_int();
+  }
+  else
+  {
+    if (from_base < 0)
+      dec= res->charset()->strntoll(res->ptr(), res->length(),
+                                    -from_base, &endptr, &err);
+    else
+      dec= (longlong) res->charset()->strntoull(res->ptr(), res->length(),
+                                                from_base, &endptr, &err);
+  }
+
+  uint dummy_errors;
+  if (!(ptr= longlong2str(dec, ans, to_base)) ||
+      (collation.collation->state & MY_CS_NONASCII) ?
+       str->copy(ans, (uint32)  (ptr - ans), &my_charset_latin1,
+                 collation.collation, &dummy_errors) :
+       str->copy(ans, (uint32) (ptr - ans), collation.collation))
+  {
+    null_value= 1;
+    return NULL;
+  }
+  return str;
+}
+
+
+/*
+  This function is needed as Item_func_conc_charset stores cached values
+  in str_value.
+*/
+
+int Item_func_conv_charset::save_in_field(Field *field, bool no_conversions)
+{
+  String *result;
+  CHARSET_INFO *cs= collation.collation;
+
+  result= val_str(&str_value);
+  if (null_value)
+    return set_field_to_null_with_conversions(field, no_conversions);
+
+  /* NOTE: If null_value == FALSE, "result" must be not NULL.  */
+  field->set_notnull();
+  int error= field->store(result->ptr(),result->length(),cs);
+  return error;
+}
+
+
+String *Item_func_conv_charset::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  if (use_cached_value)
+    return null_value ? 0 : &str_value;
+  String *arg= args[0]->val_str(&tmp_value);
+  String_copier_for_item copier(current_thd);
+  return ((null_value= args[0]->null_value ||
+                       copier.copy_with_warn(collation.collation, str,
+                                             arg->charset(), arg->ptr(),
+                                             arg->length(), arg->length()))) ?
+    0 : str;
+}
+
+bool Item_func_conv_charset::fix_length_and_dec(THD *thd)
+{
+  DBUG_ASSERT(collation.derivation == DERIVATION_IMPLICIT);
+  fix_char_length(args[0]->max_char_length());
+  return FALSE;
+}
+
+void Item_func_conv_charset::print(String *str, enum_query_type query_type)
+{
+  str->append(STRING_WITH_LEN("convert("));
+  args[0]->print(str, query_type);
+  str->append(STRING_WITH_LEN(" using "));
+  str->append(collation.collation->cs_name);
+  str->append(')');
+}
+
+String *Item_func_set_collation::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  str=args[0]->val_str(str);
+  if ((null_value=args[0]->null_value))
+    return 0;
+  str->set_charset(collation.collation);
+  return str;
+}
+
+bool Item_func_set_collation::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result(collation, args, 1))
+    return true;
+  Lex_exact_charset_opt_extended_collate cl(collation.collation, true);
+  if (cl.merge_collation_override(m_set_collation))
+    return true;
+  collation.set(cl.collation().charset_info(), DERIVATION_EXPLICIT,
+                args[0]->collation.repertoire);
+  max_length= args[0]->max_length;
+  return FALSE;
+}
+
+
+bool Item_func_set_collation::eq(const Item *item, bool binary_cmp) const
+{
+  return Item_func::eq(item, binary_cmp) &&
+         collation.collation == item->collation.collation;
+}
+
+
+void Item_func_set_collation::print(String *str, enum_query_type query_type)
+{
+  args[0]->print_parenthesised(str, query_type, precedence());
+  str->append(STRING_WITH_LEN(" collate "));
+  str->append(m_set_collation.collation_name_for_show());
+}
+
+String *Item_func_charset::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  uint dummy_errors;
+
+  CHARSET_INFO *cs= args[0]->charset_for_protocol(); 
+  null_value= 0;
+  str->copy(cs->cs_name.str, cs->cs_name.length,
+	    &my_charset_latin1, collation.collation, &dummy_errors);
+  return str;
+}
+
+String *Item_func_collation::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  uint dummy_errors;
+  CHARSET_INFO *cs= args[0]->charset_for_protocol(); 
+
+  null_value= 0;
+  str->copy(cs->coll_name.str, cs->coll_name.length, &my_charset_latin1,
+            collation.collation, &dummy_errors);
+  return str;
+}
+
+
+bool Item_func_weight_string::fix_length_and_dec(THD *thd)
+{
+  CHARSET_INFO *cs= args[0]->collation.collation;
+  collation.set(&my_charset_bin, args[0]->collation.derivation);
+  weigth_flags= my_strxfrm_flag_normalize(cs, weigth_flags);
+  /* 
+    Use result_length if it was given explicitly in constructor,
+    otherwise calculate max_length using argument's max_length
+    and "nweights".
+  */
+  if (!(max_length= result_length))
+  {
+    size_t char_length;
+    char_length= ((cs->state & MY_CS_STRNXFRM_BAD_NWEIGHTS) || !nweights) ?
+                 args[0]->max_char_length() : nweights *
+                 my_count_bits_uint32(cs->levels_for_order);
+    max_length= (uint32) cs->strnxfrmlen(char_length * cs->mbmaxlen);
+  }
+  set_maybe_null();
+  return FALSE;
+}
+
+
+/* Return a weight_string according to collation */
+String *Item_func_weight_string::val_str(String *str)
+{
+  String *res;
+  CHARSET_INFO *cs= args[0]->collation.collation;
+  size_t tmp_length, frm_length;
+  DBUG_ASSERT(fixed());
+
+  if (args[0]->result_type() != STRING_RESULT ||
+      !(res= args[0]->val_str(&tmp_value)))
+    goto nl;
+  
+  /*
+    Use result_length if it was given in constructor
+    explicitly, otherwise calculate result length
+    from argument and "nweights".
+  */
+  if (!(tmp_length= result_length))
+  {
+    size_t char_length;
+    if (cs->state & MY_CS_STRNXFRM_BAD_NWEIGHTS)
+    {
+      /*
+        latin2_czech_cs and cp1250_czech_cs do not support
+        the "nweights" limit in strnxfrm(). Use the full length.
+      */
+      char_length= res->length();
+    }
+    else
+    {
+      /*
+        If we don't need to pad the result with spaces, then it should be
+        OK to calculate character length of the argument approximately:
+        "res->length() / cs->mbminlen" can return a number that is 
+        bigger than the real number of characters in the string, so
+        we'll allocate a little bit more memory but avoid calling
+        the slow res->numchars().
+        In case if we do need to pad with spaces, we call res->numchars()
+        to know the true number of characters.
+      */
+      if (!(char_length= nweights))
+        char_length= (weigth_flags & MY_STRXFRM_PAD_WITH_SPACE) ?
+                      res->numchars() : (res->length() / cs->mbminlen);
+    }
+    tmp_length= cs->strnxfrmlen(char_length * cs->mbmaxlen);
+  }
+
+  {
+    THD *thd= current_thd;
+    if (tmp_length > current_thd->variables.max_allowed_packet)
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                          ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                          func_name(),
+                          thd->variables.max_allowed_packet);
+      goto nl;
+    }
+  }
+
+  if (str->alloc(tmp_length))
+    goto nl;
+
+  frm_length= cs->strnxfrm((char*) str->ptr(), tmp_length,
+                           nweights ? nweights : (uint) tmp_length,
+                           res->ptr(), res->length(),
+                           weigth_flags);
+  DBUG_ASSERT(frm_length <= tmp_length);
+
+  str->set_charset(&my_charset_bin);
+  str->length(frm_length);
+  null_value= 0;
+  return str;
+
+nl:
+  null_value= 1;
+  return 0;
+}
+
+
+void Item_func_weight_string::print(String *str, enum_query_type query_type)
+{
+  str->append(func_name_cstring());
+  str->append('(');
+  args[0]->print(str, query_type);
+  str->append(',');
+  str->append_ulonglong(result_length);
+  str->append(',');
+  str->append_ulonglong(nweights);
+  str->append(',');
+  str->append_ulonglong(weigth_flags);
+  str->append(')');
+}
+
+
+String *Item_func_hex::val_str_ascii_from_val_real(String *str)
+{
+  ulonglong dec;
+  double val= args[0]->val_real();
+  if ((null_value= args[0]->null_value))
+    return 0;
+  if ((val <= (double) LONGLONG_MIN) ||
+      (val >= (double) (ulonglong) ULONGLONG_MAX))
+    dec= ~(longlong) 0;
+  else
+    dec= (ulonglong) (val + (val > 0 ? 0.5 : -0.5));
+  return str->set_hex(dec) ? make_empty_result(str) : str;
+}
+
+
+String *Item_func_hex::val_str_ascii_from_val_str(String *str)
+{
+  DBUG_ASSERT(&tmp_value != str);
+  String *res= args[0]->val_str(&tmp_value);
+  DBUG_ASSERT(res != str);
+  if ((null_value= (res == NULL)))
+    return NULL;
+  return str->set_hex(res->ptr(), res->length()) ? make_empty_result(str) : str;
+}
+
+
+String *Item_func_hex::val_str_ascii_from_val_int(String *str)
+{
+  ulonglong dec= (ulonglong) args[0]->val_int();
+  if ((null_value= args[0]->null_value))
+    return 0;
+  return str->set_hex(dec) ? make_empty_result(str) : str;
+}
+
+
+  /** Convert given hex string to a binary string. */
+
+String *Item_func_unhex::val_str(String *str)
+{
+  const char *from, *end;
+  char *to;
+  String *res;
+  uint length;
+  DBUG_ASSERT(fixed());
+
+  res= args[0]->val_str(&tmp_value);
+  if (!res || str->alloc(length= (1+res->length())/2))
+  {
+    null_value=1;
+    return 0;
+  }
+
+  from= res->ptr();
+  null_value= 0;
+  str->set_charset(&my_charset_bin);
+  str->length(length);
+  to= (char*) str->ptr();
+  if (res->length() % 2)
+  {
+    int hex_char;
+    *to++= hex_char= hexchar_to_int(*from++);
+    if ((null_value= (hex_char == -1)))
+      return 0;
+  }
+  for (end=res->ptr()+res->length(); from < end ; from+=2, to++)
+  {
+    int hex_char1, hex_char2;
+    hex_char1= hexchar_to_int(from[0]);
+    hex_char2= hexchar_to_int(from[1]);
+    if ((null_value= (hex_char1 == -1 || hex_char2 == -1)))
+      return 0;
+    *to= (char) ((hex_char1 << 4) | hex_char2);
+  }
+  return str;
+}
+
+
+#ifndef DBUG_OFF
+String *Item_func_like_range::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  longlong nbytes= args[1]->val_int();
+  String *res= args[0]->val_str(str);
+  size_t min_len, max_len;
+  CHARSET_INFO *cs= collation.collation;
+
+  if (!res || args[0]->null_value || args[1]->null_value ||
+      nbytes < 0 || nbytes > MAX_BLOB_WIDTH ||
+      min_str.alloc((size_t)nbytes) || max_str.alloc((size_t)nbytes))
+    goto err;
+  null_value=0;
+
+  if (cs->like_range(res->ptr(), res->length(),
+                     '\\', '_', '%', (size_t)nbytes,
+                     (char*) min_str.ptr(), (char*) max_str.ptr(),
+                     &min_len, &max_len))
+    goto err;
+
+  min_str.set_charset(collation.collation);
+  max_str.set_charset(collation.collation);
+  min_str.length(min_len);
+  max_str.length(max_len);
+
+  return is_min ? &min_str : &max_str;
+
+err:
+  null_value= 1;
+  return 0;
+}
+#endif
+
+
+void Item_func_binary::print(String *str, enum_query_type query_type)
+{
+  str->append(STRING_WITH_LEN("cast("));
+  args[0]->print(str, query_type);
+  str->append(STRING_WITH_LEN(" as binary)"));
+}
+
+
+#include <my_dir.h>				// For my_stat
+
+String *Item_load_file::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *file_name;
+  File file;
+  MY_STAT stat_info;
+  char path[FN_REFLEN];
+  ulonglong file_size;
+  DBUG_ENTER("load_file");
+
+  if (!(file_name= args[0]->val_str(str))
+#ifndef NO_EMBEDDED_ACCESS_CHECKS
+      || !(current_thd->security_ctx->master_access & FILE_ACL)
+#endif
+      )
+    goto err;
+
+  (void) fn_format(path, file_name->c_ptr_safe(), mysql_real_data_home, "",
+		   MY_RELATIVE_PATH | MY_UNPACK_FILENAME);
+
+  /* Read only allowed from within dir specified by secure_file_priv */
+  if (!is_secure_file_path(path))
+    goto err;
+
+  if (!mysql_file_stat(key_file_loadfile, path, &stat_info, MYF(0)))
+    goto err;
+
+  if (!(stat_info.st_mode & S_IROTH))
+  {
+    /* my_error(ER_TEXTFILE_NOT_READABLE, MYF(0), file_name->c_ptr()); */
+    goto err;
+  }
+  file_size= stat_info.st_size;
+
+  {
+    THD *thd= current_thd;
+    if (file_size >= thd->variables.max_allowed_packet)
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                          ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                          func_name(), thd->variables.max_allowed_packet);
+      goto err;
+    }
+  }
+  if (tmp_value.alloc((ulong)file_size))
+    goto err;
+  if ((file= mysql_file_open(key_file_loadfile,
+                             file_name->ptr(), O_RDONLY, MYF(0))) < 0)
+    goto err;
+  if (mysql_file_read(file, (uchar*) tmp_value.ptr(), (size_t)stat_info.st_size,
+                      MYF(MY_NABP)))
+  {
+    mysql_file_close(file, MYF(0));
+    goto err;
+  }
+  tmp_value.length((uint32)stat_info.st_size);
+  mysql_file_close(file, MYF(0));
+  null_value = 0;
+  DBUG_RETURN(&tmp_value);
+
+err:
+  null_value = 1;
+  DBUG_RETURN(0);
+}
+
+
+String* Item_func_export_set::val_str(String* str)
+{
+  DBUG_ASSERT(fixed());
+  String yes_buf, no_buf, sep_buf;
+  const ulonglong the_set = (ulonglong) args[0]->val_int();
+  const String *yes= args[1]->val_str(&yes_buf);
+  const String *no= args[2]->val_str(&no_buf);
+  const String *sep= NULL;
+
+  uint num_set_values = 64;
+  str->length(0);
+  str->set_charset(collation.collation);
+
+  /* Check if some argument is a NULL value */
+  if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
+  {
+    null_value= true;
+    return NULL;
+  }
+  /*
+    Arg count can only be 3, 4 or 5 here. This is guaranteed from the
+    grammar for EXPORT_SET()
+  */
+  switch(arg_count) {
+  case 5:
+    num_set_values = (uint) args[4]->val_int();
+    if (num_set_values > 64)
+      num_set_values=64;
+    if (args[4]->null_value)
+    {
+      null_value= true;
+      return NULL;
+    }
+    /* Fall through */
+  case 4:
+    if (!(sep = args[3]->val_str(&sep_buf)))	// Only true if NULL
+    {
+      null_value= true;
+      return NULL;
+    }
+    break;
+  case 3:
+    {
+      /* errors is not checked - assume "," can always be converted */
+      uint errors;
+      sep_buf.copy(STRING_WITH_LEN(","), &my_charset_bin,
+                   collation.collation, &errors);
+      sep = &sep_buf;
+    }
+    break;
+  default:
+    DBUG_ASSERT(0); // cannot happen
+  }
+  null_value= false;
+
+  THD *thd= current_thd;
+  const ulong max_allowed_packet= thd->variables.max_allowed_packet;
+  const uint num_separators= num_set_values > 0 ? num_set_values - 1 : 0;
+  const ulonglong max_total_length=
+    num_set_values * MY_MAX(yes->length(), no->length()) +
+    num_separators * sep->length();
+
+  if (unlikely(max_total_length > max_allowed_packet))
+  {
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                        ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                        ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                        func_name(), max_allowed_packet);
+    null_value= true;
+    return NULL;
+  }
+
+  uint ix;
+  ulonglong mask;
+  for (ix= 0, mask=0x1; ix < num_set_values; ++ix, mask = (mask << 1))
+  {
+    if (the_set & mask)
+      str->append(*yes);
+    else
+      str->append(*no);
+    if (ix != num_separators)
+      str->append(*sep);
+  }
+  return str;
+}
+
+bool Item_func_export_set::fix_length_and_dec(THD *thd)
+{
+  uint32 length= MY_MAX(args[1]->max_char_length(), args[2]->max_char_length());
+  uint32 sep_length= (arg_count > 3 ? args[3]->max_char_length() : 1);
+
+  if (agg_arg_charsets_for_string_result(collation,
+                                         args + 1, MY_MIN(4, arg_count) - 1))
+    return TRUE;
+  fix_char_length(length * 64 + sep_length * 63);
+  return FALSE;
+}
+
+
+#define get_esc_bit(mask, num) (1 & (*((mask) + ((num) >> 3))) >> ((num) & 7))
+
+/**
+  QUOTE() function returns argument string in single quotes suitable for
+  using in a SQL statement.
+
+  Adds a \\ before all characters that needs to be escaped in a SQL string.
+  We also escape '^Z' (END-OF-FILE in windows) to avoid problems when
+  running commands from a file in windows.
+
+  This function is very useful when you want to generate SQL statements.
+
+  @note
+    QUOTE(NULL) returns the string 'NULL' (4 letters, without quotes).
+
+  @retval
+    str	   Quoted string
+  @retval
+    NULL	   Out of memory.
+*/
+
+String *Item_func_quote::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  /*
+    Bit mask that has 1 for set for the position of the following characters:
+    0, \, ' and ^Z
+  */
+
+  static uchar escmask[32]=
+  {
+    0x01, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+  };
+
+  ulong max_allowed_packet= current_thd->variables.max_allowed_packet;
+  char *from, *to, *end, *start;
+  String *arg= args[0]->val_str(&tmp_value);
+  uint arg_length, new_length;
+  if (!arg)					// Null argument
+  {
+    /* Return the string 'NULL' */
+    str->copy(STRING_WITH_LEN("NULL"), collation.collation);
+    null_value= 0;
+    return str;
+  }
+
+  arg_length= arg->length();
+
+  if (collation.collation->mbmaxlen == 1)
+  {
+    new_length= arg_length + 2; /* for beginning and ending ' signs */
+    for (from= (char*) arg->ptr(), end= from + arg_length; from < end; from++)
+      new_length+= get_esc_bit(escmask, (uchar) *from);
+    if (new_length > max_allowed_packet)
+      goto toolong;
+  }
+  else
+  {
+    new_length= (arg_length * 2) +  /* For string characters */
+                (2 * collation.collation->mbmaxlen); /* For quotes */
+    set_if_smaller(new_length, max_allowed_packet);
+  }
+
+  if (str->alloc(new_length))
+    goto null;
+
+  if (collation.collation->mbmaxlen > 1)
+  {
+    CHARSET_INFO *cs= collation.collation;
+    int mblen;
+    uchar *to_end;
+    to= (char*) str->ptr();
+    to_end= (uchar*) to + new_length;
+
+    /* Put leading quote */
+    if ((mblen= cs->wc_mb('\'', (uchar *) to, to_end)) <= 0)
+      goto toolong;
+    to+= mblen;
+
+    for (start= (char*) arg->ptr(), end= start + arg_length; start < end; )
+    {
+      my_wc_t wc;
+      bool escape;
+      if ((mblen= cs->mb_wc(&wc, (uchar*) start, (uchar*) end)) <= 0)
+        goto null;
+      start+= mblen;
+      switch (wc) {
+        case 0:      escape= 1; wc= '0'; break;
+        case '\032': escape= 1; wc= 'Z'; break;
+        case '\'':   escape= 1; break;
+        case '\\':   escape= 1; break;
+        default:     escape= 0; break;
+      }
+      if (escape)
+      {
+        if ((mblen= cs->wc_mb('\\', (uchar*) to, to_end)) <= 0)
+          goto toolong;
+        to+= mblen;
+      }
+      if ((mblen= cs->wc_mb(wc, (uchar*) to, to_end)) <= 0)
+        goto toolong;
+      to+= mblen;
+    }
+
+    /* Put trailing quote */
+    if ((mblen= cs->wc_mb('\'', (uchar *) to, to_end)) <= 0)
+      goto toolong;
+    to+= mblen;
+    new_length= (uint)(to - str->ptr());
+    goto ret;
+  }
+
+  /*
+    We replace characters from the end to the beginning
+  */
+  to= (char*) str->ptr() + new_length - 1;
+  *to--= '\'';
+  for (start= (char*) arg->ptr(),end= start + arg_length; end-- != start; to--)
+  {
+    /*
+      We can't use the bitmask here as we want to replace \O and ^Z with 0
+      and Z
+    */
+    switch (*end)  {
+    case 0:
+      *to--= '0';
+      *to=   '\\';
+      break;
+    case '\032':
+      *to--= 'Z';
+      *to=   '\\';
+      break;
+    case '\'':
+    case '\\':
+      *to--= *end;
+      *to=   '\\';
+      break;
+    default:
+      *to= *end;
+      break;
+    }
+  }
+  *to= '\'';
+
+ret:
+  str->length(new_length);
+  str->set_charset(collation.collation);
+  null_value= 0;
+  return str;
+
+toolong:
+  push_warning_printf(current_thd, Sql_condition::WARN_LEVEL_WARN,
+                      ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                      ER_THD(current_thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
+                      func_name(), max_allowed_packet);
+null:
+  null_value= 1;
+  return 0;
+}
+
+longlong Item_func_uncompressed_length::val_int()
+{
+  DBUG_ASSERT(fixed());
+  String *res= args[0]->val_str(&value);
+  if (!res)
+  {
+    null_value=1;
+    return 0; /* purecov: inspected */
+  }
+  null_value=0;
+  if (res->is_empty()) return 0;
+
+  /*
+    If length is <= 4 bytes, data is corrupt. This is the best we can do
+    to detect garbage input without decompressing it.
+  */
+  if (res->length() <= 4)
+  {
+    THD *thd= current_thd;
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                        ER_ZLIB_Z_DATA_ERROR,
+                        ER_THD(thd, ER_ZLIB_Z_DATA_ERROR));
+    null_value= 1;
+    return 0;
+  }
+
+ /*
+    res->ptr() using is safe because we have tested that string is at least
+    5 bytes long.
+    res->c_ptr() is not used because:
+      - we do not need \0 terminated string to get first 4 bytes
+      - c_ptr() tests simbol after string end (uninitialized memory) which
+        confuse valgrind
+  */
+  return uint4korr(res->ptr()) & 0x3FFFFFFF;
+}
+
+longlong Item_func_crc32::val_int()
+{
+  DBUG_ASSERT(fixed());
+  DBUG_ASSERT(arg_count == 1 || arg_count == 2);
+  String *res;
+  longlong crc;
+  if (arg_count > 1)
+  {
+    crc= args[0]->val_int();
+    null_value= args[0]->null_value;
+    if (null_value)
+      return 0;
+    res= args[1]->val_str(&value);
+  }
+  else
+  {
+    crc= 0;
+    null_value= 0;
+    res= args[0]->val_str(&value);
+  }
+
+  if (!res)
+  {
+    null_value=1;
+    return 0; /* purecov: inspected */
+  }
+
+  return static_cast<longlong>
+    (ulonglong{crc_func(uint32_t(crc), res->ptr(), res->length())});
+}
+
+#ifdef HAVE_COMPRESS
+#include "zlib.h"
+
+String *Item_func_compress::val_str(String *str)
+{
+  int err= Z_OK, code;
+  size_t new_size;
+  String *res;
+  Byte *body;
+  char *tmp, *last_char;
+  DBUG_ASSERT(fixed());
+
+  if (!(res= args[0]->val_str(&tmp_value)))
+  {
+    null_value= 1;
+    return 0;
+  }
+  null_value= 0;
+  if (res->is_empty()) return res;
+
+  /*
+    Citation from zlib.h (comment for compress function):
+
+    Compresses the source buffer into the destination buffer.  sourceLen is
+    the byte length of the source buffer. Upon entry, destLen is the total
+    size of the destination buffer, which must be at least 0.1% larger than
+    sourceLen plus 12 bytes.
+    We assume here that the buffer can't grow more than .25 %.
+  */
+  new_size= res->length() + res->length() / 5 + 12;
+
+  // Check new_size overflow: new_size <= res->length()
+  if (((uint32) (new_size+5) <= res->length()) || 
+      str->alloc((uint32) new_size + 4 + 1))
+  {
+    null_value= 1;
+    return 0;
+  }
+
+  body= ((Byte*)str->ptr()) + 4;
+
+  // As far as we have checked res->is_empty() we can use ptr()
+  if ((err= my_compress_buffer(body, &new_size, (const uchar *)res->ptr(),
+                               res->length())) != Z_OK)
+  {
+    THD *thd= current_thd;
+    code= err==Z_MEM_ERROR ? ER_ZLIB_Z_MEM_ERROR : ER_ZLIB_Z_BUF_ERROR;
+    push_warning(thd, Sql_condition::WARN_LEVEL_WARN, code,
+                 ER_THD(thd, code));
+    null_value= 1;
+    return 0;
+  }
+
+  tmp= (char*) str->ptr(); // int4store is a macro; avoid side effects
+  int4store(tmp, res->length() & 0x3FFFFFFF);
+
+  /* This is to ensure that things works for CHAR fields, which trim ' ': */
+  last_char= ((char*)body)+new_size-1;
+  if (*last_char == ' ')
+  {
+    *++last_char= '.';
+    new_size++;
+  }
+
+  str->length((uint32)new_size + 4);
+  str->set_charset(&my_charset_bin);
+  return str;
+}
+
+
+String *Item_func_uncompress::val_str(String *str)
+{
+  DBUG_ASSERT(fixed());
+  String *res= args[0]->val_str(&tmp_value);
+  ulong new_size;
+  int err;
+  uint code;
+
+  if (!res)
+    goto err;
+  null_value= 0;
+  if (res->is_empty())
+    return res;
+
+  /* If length is less than 4 bytes, data is corrupt */
+  if (res->length() <= 4)
+  {
+    THD *thd= current_thd;
+    push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+			ER_ZLIB_Z_DATA_ERROR,
+			ER_THD(thd, ER_ZLIB_Z_DATA_ERROR));
+    goto err;
+  }
+
+  /* Size of uncompressed data is stored as first 4 bytes of field */
+  new_size= uint4korr(res->ptr()) & 0x3FFFFFFF;
+  if (new_size > current_thd->variables.max_allowed_packet)
+  {
+    THD *thd= current_thd;
+    push_warning_printf(thd,Sql_condition::WARN_LEVEL_WARN,
+			ER_TOO_BIG_FOR_UNCOMPRESS,
+			ER_THD(thd, ER_TOO_BIG_FOR_UNCOMPRESS),
+                        static_cast<int>(thd->variables.
+                                         max_allowed_packet));
+    goto err;
+  }
+  if (str->alloc((uint32)new_size))
+    goto err;
+
+  if ((err= uncompress((Byte*)str->ptr(), &new_size,
+		       ((const Bytef*)res->ptr())+4,res->length()-4)) == Z_OK)
+  {
+    str->length((uint32) new_size);
+    return str;
+  }
+
+  code= ((err == Z_BUF_ERROR) ? ER_ZLIB_Z_BUF_ERROR :
+	 ((err == Z_MEM_ERROR) ? ER_ZLIB_Z_MEM_ERROR : ER_ZLIB_Z_DATA_ERROR));
+  {
+    THD *thd= current_thd;
+    push_warning(thd, Sql_condition::WARN_LEVEL_WARN, code, ER_THD(thd, code));
+  }
+
+err:
+  null_value= 1;
+  return 0;
+}
+#endif
+
+
+Item_func_dyncol_create::Item_func_dyncol_create(THD *thd, List<Item> &args,
+                                                 DYNCALL_CREATE_DEF *dfs):
+  Item_str_func(thd, args), defs(dfs), vals(0), keys_num(NULL), keys_str(NULL),
+  names(FALSE), force_names(FALSE)
+{
+  DBUG_ASSERT((args.elements & 0x1) == 0); // even number of arguments
+}
+
+
+bool Item_func_dyncol_create::fix_fields(THD *thd, Item **ref)
+{
+  uint i;
+  bool res= Item_func::fix_fields(thd, ref); // no need Item_str_func here
+  if (!res)
+  {
+    vals= (DYNAMIC_COLUMN_VALUE *) alloc_root(thd->mem_root,
+                                              sizeof(DYNAMIC_COLUMN_VALUE) *
+                                              (arg_count / 2));
+    for (i= 0;
+         i + 1 < arg_count && args[i]->result_type() == INT_RESULT;
+         i+= 2)
+      ;
+    if (i + 1 < arg_count)
+    {
+      names= TRUE;
+    }
+
+    keys_num= (uint *) alloc_root(thd->mem_root,
+                               (sizeof(LEX_STRING) > sizeof(uint) ?
+                                sizeof(LEX_STRING) :
+                                sizeof(uint)) *
+                               (arg_count / 2));
+    keys_str= (LEX_STRING *) keys_num;
+    status_var_increment(thd->status_var.feature_dynamic_columns);
+  }
+  return res || vals == 0 || keys_num == 0;
+}
+
+
+bool Item_func_dyncol_create::fix_length_and_dec(THD *thd)
+{
+  max_length= MAX_BLOB_WIDTH;
+  set_maybe_null();
+  collation.set(&my_charset_bin);
+  decimals= 0;
+  return FALSE;
+}
+
+bool Item_func_dyncol_create::prepare_arguments(THD *thd, bool force_names_arg)
+{
+  char buff[STRING_BUFFER_USUAL_SIZE];
+  String *res, tmp(buff, sizeof(buff), &my_charset_bin);
+  uint column_count= (arg_count / 2);
+  uint i;
+  my_decimal dtmp, *dres;
+  force_names= force_names_arg;
+
+  if (!(names || force_names))
+  {
+    for (i= 0; i < column_count; i++)
+    {
+      uint valpos= i * 2 + 1;
+      DYNAMIC_COLUMN_TYPE type= defs[i].type;
+      if (type == DYN_COL_NULL)
+        type= args[valpos]->type_handler()->dyncol_type(args[valpos]);
+      if (type == DYN_COL_STRING &&
+          args[valpos]->type() == Item::FUNC_ITEM &&
+          ((Item_func *)args[valpos])->functype() == DYNCOL_FUNC)
+      {
+        force_names= 1;
+        break;
+      }
+    }
+  }
+
+  /* get values */
+  for (i= 0; i < column_count; i++)
+  {
+    uint valpos= i * 2 + 1;
+    DYNAMIC_COLUMN_TYPE type= defs[i].type;
+    if (type == DYN_COL_NULL) // auto detect
+      type= args[valpos]->type_handler()->dyncol_type(args[valpos]);
+    if (type == DYN_COL_STRING &&
+        args[valpos]->type() == Item::FUNC_ITEM &&
+        ((Item_func *)args[valpos])->functype() == DYNCOL_FUNC)
+    {
+      DBUG_ASSERT(names || force_names);
+      type= DYN_COL_DYNCOL;
+    }
+    if (names || force_names)
+    {
+      res= args[i * 2]->val_str(&tmp);
+      if (res)
+      {
+        // guaranty UTF-8 string for names
+        if (my_charset_same(res->charset(), DYNCOL_UTF))
+        {
+          keys_str[i].length= res->length();
+          keys_str[i].str= thd->strmake(res->ptr(), res->length());
+        }
+        else
+        {
+          uint strlen= res->length() * DYNCOL_UTF->mbmaxlen + 1;
+          uint dummy_errors;
+          if (char *str= (char *) thd->alloc(strlen))
+          {
+            keys_str[i].length=
+              copy_and_convert(str, strlen, DYNCOL_UTF,
+                               res->ptr(), res->length(), res->charset(),
+                               &dummy_errors);
+              keys_str[i].str= str;
+          }
+          else
+            keys_str[i].length= 0;
+
+        }
+      }
+      else
+      {
+        keys_str[i].length= 0;
+        keys_str[i].str= NULL;
+      }
+    }
+    else
+      keys_num[i]= (uint) args[i * 2]->val_int();
+    if (args[i * 2]->null_value)
+    {
+      /* to make cleanup possible */
+      for (; i < column_count; i++)
+        vals[i].type= DYN_COL_NULL;
+      return 1;
+    }
+    vals[i].type= type;
+    switch (type) {
+    case DYN_COL_NULL:
+      DBUG_ASSERT(args[valpos]->field_type() == MYSQL_TYPE_NULL);
+      break;
+    case DYN_COL_INT:
+      vals[i].x.long_value= args[valpos]->val_int();
+      break;
+    case DYN_COL_UINT:
+      vals[i].x.ulong_value= args[valpos]->val_int();
+      break;
+    case DYN_COL_DOUBLE:
+      vals[i].x.double_value= args[valpos]->val_real();
+      break;
+    case DYN_COL_DYNCOL:
+    case DYN_COL_STRING:
+      res= args[valpos]->val_str(&tmp);
+      if (res && defs[i].cs)
+        res->set_charset(defs[i].cs);
+      if (res &&
+          (vals[i].x.string.value.str= thd->strmake(res->ptr(), res->length())))
+      {
+	vals[i].x.string.value.length= res->length();
+	vals[i].x.string.charset= res->charset();
+      }
+      else
+      {
+        args[valpos]->null_value= 1;            // In case of out of memory
+        vals[i].x.string.value.str= NULL;
+        vals[i].x.string.value.length= 0;         // just to be safe
+      }
+      break;
+    case DYN_COL_DECIMAL:
+      if ((dres= args[valpos]->val_decimal(&dtmp)))
+      {
+	mariadb_dyncol_prepare_decimal(&vals[i]);
+        DBUG_ASSERT(vals[i].x.decimal.value.len == dres->len);
+        vals[i].x.decimal.value.intg= dres->intg;
+        vals[i].x.decimal.value.frac= dres->frac;
+        vals[i].x.decimal.value.sign= dres->sign();
+        memcpy(vals[i].x.decimal.buffer, dres->buf,
+               sizeof(vals[i].x.decimal.buffer));
+      }
+      else
+      {
+	mariadb_dyncol_prepare_decimal(&vals[i]); // just to be safe
+        DBUG_ASSERT(args[valpos]->null_value);
+      }
+      break;
+    case DYN_COL_DATETIME:
+    case DYN_COL_DATE:
+      args[valpos]->get_date(thd, &vals[i].x.time_value,
+                             Datetime::Options(thd));
+      break;
+    case DYN_COL_TIME:
+      args[valpos]->get_time(thd, &vals[i].x.time_value);
+      break;
+    default:
+      DBUG_ASSERT(0);
+      vals[i].type= DYN_COL_NULL;
+    }
+    if (vals[i].type != DYN_COL_NULL && args[valpos]->null_value)
+    {
+      vals[i].type= DYN_COL_NULL;
+    }
+  }
+  return FALSE;
+}
+
+
+String *Item_func_dyncol_create::val_str(String *str)
+{
+  DYNAMIC_COLUMN col;
+  String *res;
+  uint column_count= (arg_count / 2);
+  enum enum_dyncol_func_result rc;
+  DBUG_ASSERT((arg_count & 0x1) == 0); // even number of arguments
+
+  /* FIXME: add thd argument to Item::val_str() */
+  if (prepare_arguments(current_thd, FALSE))
+  {
+    res= NULL;
+    null_value= 1;
+  }
+  else
+  {
+    if ((rc= ((names || force_names) ?
+              mariadb_dyncol_create_many_named(&col, column_count, keys_str,
+                                               vals, TRUE) :
+              mariadb_dyncol_create_many_num(&col, column_count, keys_num,
+                                             vals, TRUE))))
+    {
+      dynamic_column_error_message(rc);
+      mariadb_dyncol_free(&col);
+      res= NULL;
+      null_value= TRUE;
+    }
+    else
+    {
+      /* Move result from DYNAMIC_COLUMN to str_value */
+      char *ptr;
+      size_t length, alloc_length;
+      dynstr_reassociate(&col, &ptr, &length, &alloc_length);
+      str_value.reset(ptr, length, alloc_length, &my_charset_bin);
+      res= &str_value;
+      null_value= FALSE;
+    }
+  }
+
+  return res;
+}
+
+void Item_func_dyncol_create::print_arguments(String *str,
+                                              enum_query_type query_type)
+{
+  uint i;
+  uint column_count= (arg_count / 2);
+  for (i= 0; i < column_count; i++)
+  {
+    args[i*2]->print(str, query_type);
+    str->append(',');
+    args[i*2 + 1]->print(str, query_type);
+    switch (defs[i].type) {
+    case DYN_COL_NULL: // automatic type => write nothing
+      break;
+    case DYN_COL_INT:
+      str->append(STRING_WITH_LEN(" AS int"));
+      break;
+    case DYN_COL_UINT:
+      str->append(STRING_WITH_LEN(" AS unsigned int"));
+      break;
+    case DYN_COL_DOUBLE:
+      str->append(STRING_WITH_LEN(" AS double"));
+      break;
+    case DYN_COL_DYNCOL:
+    case DYN_COL_STRING:
+      str->append(STRING_WITH_LEN(" AS char"));
+      if (defs[i].cs)
+      {
+        str->append(STRING_WITH_LEN(" charset "));
+        str->append(defs[i].cs->cs_name);
+        str->append(' ');
+      }
+      break;
+    case DYN_COL_DECIMAL:
+      str->append(STRING_WITH_LEN(" AS decimal"));
+      break;
+    case DYN_COL_DATETIME:
+      str->append(STRING_WITH_LEN(" AS datetime"));
+      break;
+    case DYN_COL_DATE:
+      str->append(STRING_WITH_LEN(" AS date"));
+      break;
+    case DYN_COL_TIME:
+      str->append(STRING_WITH_LEN(" AS time"));
+      break;
+    }
+    if (i < column_count - 1)
+      str->append(',');
+  }
+}
+
+
+void Item_func_dyncol_create::print(String *str,
+                                    enum_query_type query_type)
+{
+  DBUG_ASSERT((arg_count & 0x1) == 0); // even number of arguments
+  str->append(STRING_WITH_LEN("column_create("));
+  print_arguments(str, query_type);
+  str->append(')');
+}
+
+String *Item_func_dyncol_json::val_str(String *str)
+{
+  DYNAMIC_STRING json, col;
+  String *res;
+  enum enum_dyncol_func_result rc;
+
+  res= args[0]->val_str(str);
+  if (args[0]->null_value)
+    goto null;
+
+  col.str= (char *)res->ptr();
+  col.length= res->length();
+  if ((rc= mariadb_dyncol_json(&col, &json)))
+  {
+    dynamic_column_error_message(rc);
+    goto null;
+  }
+  bzero(&col, sizeof(col));
+  {
+    /* Move result from DYNAMIC_COLUMN to str */
+    char *ptr;
+    size_t length, alloc_length;
+    dynstr_reassociate(&json, &ptr, &length, &alloc_length);
+    str->reset(ptr, length, alloc_length, DYNCOL_UTF);
+    null_value= FALSE;
+  }
+  str->set_charset(DYNCOL_UTF);
+  return str;
+
+null:
+  bzero(&col, sizeof(col));
+  null_value= TRUE;
+  return NULL;
+}
+
+String *Item_func_dyncol_add::val_str(String *str)
+{
+  DYNAMIC_COLUMN col;
+  String *res;
+  uint column_count=  (arg_count / 2);
+  enum enum_dyncol_func_result rc;
+  DBUG_ASSERT((arg_count & 0x1) == 1); // odd number of arguments
+
+  /* We store the packed data last */
+  res= args[arg_count - 1]->val_str(str);
+  if (args[arg_count - 1]->null_value ||
+      init_dynamic_string(&col, NULL, res->length() + STRING_BUFFER_USUAL_SIZE,
+                          STRING_BUFFER_USUAL_SIZE))
+    goto null;
+
+  col.length= res->length();
+  memcpy(col.str, res->ptr(), col.length);
+
+  /* FIXME: add thd argument to Item::val_str() */
+  if (prepare_arguments(current_thd, mariadb_dyncol_has_names(&col)))
+    goto null;
+
+  if ((rc= ((names || force_names) ?
+            mariadb_dyncol_update_many_named(&col, column_count,
+                                             keys_str, vals) :
+            mariadb_dyncol_update_many_num(&col, column_count,
+                                           keys_num, vals))))
+  {
+    dynamic_column_error_message(rc);
+    mariadb_dyncol_free(&col);
+    goto null;
+  }
+
+  {
+    /* Move result from DYNAMIC_COLUMN to str */
+    char *ptr;
+    size_t length, alloc_length;
+    dynstr_reassociate(&col, &ptr, &length, &alloc_length);
+    str->reset(ptr, length, alloc_length, &my_charset_bin);
+    null_value= FALSE;
+  }
+
+  return str;
+
+null:
+  null_value= TRUE;
+  return NULL;
+}
+
+
+void Item_func_dyncol_add::print(String *str,
+                                 enum_query_type query_type)
+{
+  DBUG_ASSERT((arg_count & 0x1) == 1); // odd number of arguments
+  str->append(STRING_WITH_LEN("column_add("));
+  args[arg_count - 1]->print(str, query_type);
+  str->append(',');
+  print_arguments(str, query_type);
+  str->append(')');
+}
+
+
+/**
+  Get value for a column stored in a dynamic column
+
+  @notes
+  This function ensures that null_value is set correctly
+*/
+
+bool Item_dyncol_get::get_dyn_value(THD *thd, DYNAMIC_COLUMN_VALUE *val,
+                                    String *tmp)
+{
+  DYNAMIC_COLUMN dyn_str;
+  String *res;
+  longlong num= 0;
+  LEX_STRING buf, *name= NULL;
+  char nmstrbuf[11];
+  String nmbuf(nmstrbuf, sizeof(nmstrbuf), system_charset_info);
+  enum enum_dyncol_func_result rc;
+
+  if (args[1]->result_type() == INT_RESULT)
+    num= args[1]->val_int();
+  else
+  {
+    String *nm= args[1]->val_str(&nmbuf);
+    if (!nm || args[1]->null_value)
+    {
+      null_value= 1;
+      return 1;
+    }
+
+    if (my_charset_same(nm->charset(), DYNCOL_UTF))
+    {
+      buf.str= (char *) nm->ptr();
+      buf.length= nm->length();
+    }
+    else
+    {
+      uint strlen= nm->length() * DYNCOL_UTF->mbmaxlen + 1;
+      uint dummy_errors;
+      buf.str= (char *) thd->alloc(strlen);
+      if (buf.str)
+      {
+        buf.length=
+          copy_and_convert(buf.str, strlen, DYNCOL_UTF,
+                           nm->ptr(), nm->length(), nm->charset(),
+                           &dummy_errors);
+      }
+      else
+        buf.length= 0;
+    }
+    name= &buf;
+  }
+
+
+  if (args[1]->null_value || num < 0 || num > INT_MAX)
+  {
+    null_value= 1;
+    return 1;
+  }
+
+  res= args[0]->val_str(tmp);
+  if (args[0]->null_value)
+  {
+    null_value= 1;
+    return 1;
+  }
+
+  dyn_str.str=   (char*) res->ptr();
+  dyn_str.length= res->length();
+  if ((rc= ((name == NULL) ?
+            mariadb_dyncol_get_num(&dyn_str, (uint) num, val) :
+            mariadb_dyncol_get_named(&dyn_str, name, val))))
+  {
+    dynamic_column_error_message(rc);
+    null_value= 1;
+    return 1;
+  }
+
+  null_value= 0;
+  return 0;                                     // ok
+}
+
+
+String *Item_dyncol_get::val_str(String *str_result)
+{
+  DYNAMIC_COLUMN_VALUE val;
+  char buff[STRING_BUFFER_USUAL_SIZE];
+  String tmp(buff, sizeof(buff), &my_charset_bin);
+
+  if (get_dyn_value(current_thd, &val, &tmp))
+    return NULL;
+
+  switch (val.type) {
+  case DYN_COL_NULL:
+    goto null;
+  case DYN_COL_INT:
+  case DYN_COL_UINT:
+    str_result->set_int(val.x.long_value, MY_TEST(val.type == DYN_COL_UINT),
+                       &my_charset_latin1);
+    break;
+  case DYN_COL_DOUBLE:
+    str_result->set_real(val.x.double_value, NOT_FIXED_DEC, &my_charset_latin1);
+    break;
+  case DYN_COL_DYNCOL:
+  case DYN_COL_STRING:
+    if ((char*) tmp.ptr() <= val.x.string.value.str &&
+        (char*) tmp.ptr() + tmp.length() >= val.x.string.value.str)
+    {
+      /* value is allocated in tmp buffer; We have to make a copy */
+      str_result->copy(val.x.string.value.str, val.x.string.value.length,
+                      val.x.string.charset);
+    }
+    else
+    {
+      /*
+        It's safe to use the current value because it's either pointing
+        into a field or in a buffer for another item and this buffer
+        is not going to be deleted during expression evaluation
+      */
+      str_result->set(val.x.string.value.str, val.x.string.value.length,
+                      val.x.string.charset);
+    }
+    break;
+  case DYN_COL_DECIMAL:
+  {
+    int res;
+    int length= decimal_string_size(&val.x.decimal.value);
+    if (str_result->alloc(length))
+      goto null;
+    if ((res= decimal2string(&val.x.decimal.value, (char*) str_result->ptr(),
+                             &length, 0, 0, ' ')) != E_DEC_OK)
+    {
+      char buff[40];
+      int len= sizeof(buff);
+      DBUG_ASSERT(length < (int)sizeof(buff));
+      decimal2string(&val.x.decimal.value, buff, &len, 0, 0, ' ');
+      decimal_operation_results(res, buff, "CHAR");
+    }
+    str_result->set_charset(&my_charset_latin1);
+    str_result->length(length);
+    break;
+  }
+  case DYN_COL_DATETIME:
+  case DYN_COL_DATE:
+  case DYN_COL_TIME:
+  {
+    int length;
+    /*
+      We use AUTO_SEC_PART_DIGITS here to ensure that we do not loose
+      any microseconds from the data. This is safe to do as we are
+      asked to return the time argument as a string.
+    */
+    if (str_result->alloc(MAX_DATE_STRING_REP_LENGTH) ||
+        !(length= my_TIME_to_str(&val.x.time_value, (char*) str_result->ptr(),
+                                 AUTO_SEC_PART_DIGITS)))
+      goto null;
+    str_result->set_charset(&my_charset_latin1);
+    str_result->length(length);
+    break;
+  }
+  }
+  return str_result;
+
+null:
+  null_value= TRUE;
+  return 0;
+}
+
+
+longlong Item_dyncol_get::val_int()
+{
+  THD *thd= current_thd;
+  DYNAMIC_COLUMN_VALUE val;
+  char buff[STRING_BUFFER_USUAL_SIZE];
+  String tmp(buff, sizeof(buff), &my_charset_bin);
+
+  if (get_dyn_value(thd, &val, &tmp))
+    return 0;
+
+  switch (val.type) {
+  case DYN_COL_DYNCOL:
+  case DYN_COL_NULL:
+    goto null;
+  case DYN_COL_UINT:
+    unsigned_flag= 1;            // Make it possible for caller to detect sign
+    return val.x.long_value;
+  case DYN_COL_INT:
+    unsigned_flag= 0;            // Make it possible for caller to detect sign
+    return val.x.long_value;
+  case DYN_COL_DOUBLE:
+    return Converter_double_to_longlong_with_warn(thd, val.x.double_value,
+                                                  unsigned_flag).result();
+  case DYN_COL_STRING:
+  {
+    int error;
+    longlong num;
+    char *end= val.x.string.value.str + val.x.string.value.length, *org_end= end;
+
+    num= my_strtoll10(val.x.string.value.str, &end, &error);
+    if (unlikely(end != org_end || error > 0))
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_BAD_DATA,
+                          ER_THD(thd, ER_BAD_DATA),
+                          ErrConvString(val.x.string.value.str,
+                                        val.x.string.value.length,
+                                        val.x.string.charset).ptr(),
+                          unsigned_flag ? "UNSIGNED INT" : "INT");
+    }
+    unsigned_flag= error >= 0;
+    return num;
+  }
+  case DYN_COL_DECIMAL:
+  {
+    longlong num;
+    my_decimal2int(E_DEC_FATAL_ERROR, &val.x.decimal.value, unsigned_flag,
+                   &num);
+    return num;
+  }
+  case DYN_COL_DATETIME:
+  case DYN_COL_DATE:
+  case DYN_COL_TIME:
+    unsigned_flag= !val.x.time_value.neg;
+    if (unsigned_flag)
+      return TIME_to_ulonglong(&val.x.time_value);
+    else
+      return -(longlong)TIME_to_ulonglong(&val.x.time_value);
+  }
+
+null:
+  null_value= TRUE;
+  return 0;
+}
+
+
+double Item_dyncol_get::val_real()
+{
+  THD *thd= current_thd;
+  DYNAMIC_COLUMN_VALUE val;
+  char buff[STRING_BUFFER_USUAL_SIZE];
+  String tmp(buff, sizeof(buff), &my_charset_bin);
+
+  if (get_dyn_value(thd, &val, &tmp))
+    return 0.0;
+
+  switch (val.type) {
+  case DYN_COL_DYNCOL:
+  case DYN_COL_NULL:
+    goto null;
+  case DYN_COL_UINT:
+    return ulonglong2double(val.x.ulong_value);
+  case DYN_COL_INT:
+    return (double) val.x.long_value;
+  case DYN_COL_DOUBLE:
+    return (double) val.x.double_value;
+  case DYN_COL_STRING:
+  {
+    int error;
+    char *end;
+    double res= val.x.string.charset->strntod((char*) val.x.string.value.str,
+                                              val.x.string.value.length, &end, &error);
+
+    if (end != (char*) val.x.string.value.str + val.x.string.value.length ||
+        error)
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_BAD_DATA,
+                          ER_THD(thd, ER_BAD_DATA),
+                          ErrConvString(val.x.string.value.str,
+                                        val.x.string.value.length,
+                                        val.x.string.charset).ptr(),
+                          "DOUBLE");
+    }
+    return res;
+  }
+  case DYN_COL_DECIMAL:
+  {
+    double res;
+    /* This will always succeed */
+    decimal2double(&val.x.decimal.value, &res);
+    return res;
+  }
+  case DYN_COL_DATETIME:
+  case DYN_COL_DATE:
+  case DYN_COL_TIME:
+    return TIME_to_double(&val.x.time_value);
+  }
+
+null:
+  null_value= TRUE;
+  return 0.0;
+}
+
+
+my_decimal *Item_dyncol_get::val_decimal(my_decimal *decimal_value)
+{
+  THD *thd= current_thd;
+  DYNAMIC_COLUMN_VALUE val;
+  char buff[STRING_BUFFER_USUAL_SIZE];
+  String tmp(buff, sizeof(buff), &my_charset_bin);
+
+  if (get_dyn_value(thd, &val, &tmp))
+    return NULL;
+
+  switch (val.type) {
+  case DYN_COL_DYNCOL:
+  case DYN_COL_NULL:
+    goto null;
+  case DYN_COL_UINT:
+    int2my_decimal(E_DEC_FATAL_ERROR, val.x.long_value, TRUE, decimal_value);
+    break;
+  case DYN_COL_INT:
+    int2my_decimal(E_DEC_FATAL_ERROR, val.x.long_value, FALSE, decimal_value);
+    break;
+  case DYN_COL_DOUBLE:
+    double2my_decimal(E_DEC_FATAL_ERROR, val.x.double_value, decimal_value);
+    break;
+  case DYN_COL_STRING:
+  {
+    const char *end;
+    int rc;
+    rc= str2my_decimal(0, val.x.string.value.str, val.x.string.value.length,
+                       val.x.string.charset, decimal_value, &end);
+    if (rc != E_DEC_OK ||
+        end != val.x.string.value.str + val.x.string.value.length)
+    {
+      push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_BAD_DATA,
+                          ER_THD(thd, ER_BAD_DATA),
+                          ErrConvString(val.x.string.value.str,
+                                        val.x.string.value.length,
+                                        val.x.string.charset).ptr(),
+                          "DECIMAL");
+    }
+    break;
+  }
+  case DYN_COL_DECIMAL:
+    decimal2my_decimal(&val.x.decimal.value, decimal_value);
+    break;
+  case DYN_COL_DATETIME:
+  case DYN_COL_DATE:
+  case DYN_COL_TIME:
+    decimal_value= TIME_to_my_decimal(&val.x.time_value, decimal_value);
+    break;
+  }
+  return decimal_value;
+
+null:
+  null_value= TRUE;
+  return 0;
+}
+
+
+bool Item_dyncol_get::get_date(THD *thd, MYSQL_TIME *ltime, date_mode_t fuzzydate)
+{
+  DYNAMIC_COLUMN_VALUE val;
+  char buff[STRING_BUFFER_USUAL_SIZE];
+  String tmp(buff, sizeof(buff), &my_charset_bin);
+  bool signed_value= 0;
+
+  if (get_dyn_value(current_thd, &val, &tmp))
+    return 1;                                   // Error
+
+  switch (val.type) {
+  case DYN_COL_DYNCOL:
+  case DYN_COL_NULL:
+    goto null;
+  case DYN_COL_INT:
+    signed_value= 1;                                  // For error message
+    /* fall through */
+  case DYN_COL_UINT:
+    if (signed_value || val.x.ulong_value <= LONGLONG_MAX)
+    {
+      longlong llval = (longlong)val.x.ulong_value;
+      if (int_to_datetime_with_warn(thd, Longlong_hybrid(llval, !signed_value),
+                                    ltime, fuzzydate, 0, 0 /* TODO */))
+        goto null;
+      return 0;
+    }
+    /* let double_to_datetime_with_warn() issue the warning message */
+    val.x.double_value= static_cast<double>(ULONGLONG_MAX);
+    /* fall through */
+  case DYN_COL_DOUBLE:
+    if (double_to_datetime_with_warn(thd, val.x.double_value, ltime, fuzzydate,
+                                     0, 0 /* TODO */))
+      goto null;
+    return 0;
+  case DYN_COL_DECIMAL:
+    if (decimal_to_datetime_with_warn(thd, (my_decimal*)&val.x.decimal.value,
+                                      ltime, fuzzydate, 0, 0 /* TODO */))
+      goto null;
+    return 0;
+  case DYN_COL_STRING:
+    if (str_to_datetime_with_warn(thd, &my_charset_numeric,
+                                  val.x.string.value.str,
+                                  val.x.string.value.length,
+                                  ltime, fuzzydate))
+      goto null;
+    return 0;
+  case DYN_COL_DATETIME:
+  case DYN_COL_DATE:
+  case DYN_COL_TIME:
+    *ltime= val.x.time_value;
+    return 0;
+  }
+
+null:
+  null_value= TRUE;
+  return 1;
+}
+
+void Item_dyncol_get::print(String *str, enum_query_type query_type)
+{
+  /*
+    Parent cast doesn't exist yet, only print dynamic column name. This happens
+    when called from create_func_cast() / wrong_precision_error().
+  */
+  if (!str->length())
+  {
+    args[1]->print(str, query_type);
+    return;
+  }
+
+  /* see create_func_dyncol_get */
+  DBUG_ASSERT(str->length() >= 5);
+  DBUG_ASSERT(strncmp(str->ptr() + str->length() - 5, "cast(", 5) == 0);
+
+  str->length(str->length() - 5);    // removing "cast("
+  str->append(STRING_WITH_LEN("column_get("));
+  args[0]->print(str, query_type);
+  str->append(',');
+  args[1]->print(str, query_type);
+  /* let the parent cast item add " as <type>)" */
+}
+
+
+String *Item_func_dyncol_list::val_str(String *str)
+{
+  uint i;
+  enum enum_dyncol_func_result rc;
+  LEX_STRING *names= 0;
+  uint count;
+  DYNAMIC_COLUMN col;
+  String *res= args[0]->val_str(str);
+
+  if (args[0]->null_value)
+    goto null;
+  col.length= res->length();
+  /* We do not change the string, so could do this trick */
+  col.str= (char *)res->ptr();
+  if ((rc= mariadb_dyncol_list_named(&col, &count, &names)))
+  {
+    bzero(&col, sizeof(col));
+    dynamic_column_error_message(rc);
+    goto null;
+  }
+  bzero(&col, sizeof(col));
+
+  /*
+    We estimate average name length as 10
+  */
+  if (str->alloc(count * 13))
+    goto null;
+
+  str->length(0);
+  for (i= 0; i < count; i++)
+  {
+    append_identifier(current_thd, str, names[i].str, names[i].length);
+    if (i < count - 1)
+      str->qs_append(',');
+  }
+  null_value= FALSE;
+  if (names)
+    my_free(names);
+  str->set_charset(DYNCOL_UTF);
+  return str;
+
+null:
+  null_value= TRUE;
+  if (names)
+    my_free(names);
+  return NULL;
+}
+
+Item_temptable_rowid::Item_temptable_rowid(TABLE *table_arg)
+  : Item_str_func(table_arg->in_use), table(table_arg)
+{
+  max_length= table->file->ref_length;
+}
+
+bool Item_temptable_rowid::fix_length_and_dec(THD *thd)
+{
+  used_tables_cache= table->map;
+  const_item_cache= false;
+  return FALSE;
+}
+
+String *Item_temptable_rowid::val_str(String *str)
+{
+  if (!((null_value= table->null_row)))
+    table->file->position(table->record[0]);
+  str_value.set((char*)(table->file->ref), max_length, &my_charset_bin);
+  return &str_value;
+}
+
+/**
+  Helper routine to encode length prefix
+  in natsort_encode_numeric_string().
+
+  The idea is so that bigger input numbers correspond
+  lexicographically bigger output strings.
+
+  Note, that in real use the number would typically
+  small, as it only computes variable *length prefixes*.
+
+  @param[in] n - the number
+  @param[in] s - output string
+
+  @return - length of encoding
+
+  Here is how encoding works
+
+  - n is from 0 to 8
+   Output string calculated as '0'+n (range '0' - '8')
+
+  - n is from 9 to 17
+    Output calculated as concat('9', '0' + n -9)'
+    Output range: '90'-'98'
+
+   -n is from 18 to 26
+    Output calculated as concat('99', '0' + n -18)'
+    Output range '990'-'998'
+
+  - n is from 27 to SIZE_T_MAX
+    Output starts with '999',
+    then log10(n) is encoded as 2-digit decimal number
+    then the number itself is added.
+    Example : for 28 key is concat('999', '01' , '28')
+    i.e '9990128'
+
+    Key length is 5 + ceil(log10(n))
+
+   Output range is
+     (64bit)'9990128' - '9991918446744073709551615'
+     (32bit)'9990128' - '999094294967295'
+*/
+
+/* Largest length of encoded string.*/
+static size_t natsort_encode_length_max(size_t n)
+{
+  return (n < 27) ? n/9+1 : 26;
+}
+
+static void natsort_encode_length(size_t n, String* out)
+{
+  if (n < 27)
+  {
+    if (n >= 9)
+      out->fill(out->length() + n/9,'9');
+    out->append(char(n % 9 + '0'));
+    return;
+  }
+
+  size_t log10n= 0;
+  for (size_t tmp= n / 10; tmp; tmp/= 10)
+    log10n++;
+  out->fill(out->length() + 3, '9');
+  out->append('0' + (char) (log10n / 10));
+  out->append('0' + (char) (log10n % 10));
+  out->append_ulonglong(n);
+}
+
+enum class NATSORT_ERR
+{
+  SUCCESS= 0,
+  KEY_TOO_LARGE= 1,
+  ALLOC_ERROR= 2
+};
+
+/*
+   Encode numeric string for natural sorting.
+
+   @param[in] in - start of the numeric string
+   skipping leading zeros
+
+   @param[in] n_digits - length of the string,
+   in characters, not counting leading zeros.
+
+   @param[out] out - String to write to. The string should
+   have enough preallocated space to fit the encoded key.
+
+   @return
+     NATSORT_ERR::SUCCESS  - success
+     NATSORT_ERR::KEY_TOO_LARGE  - out string does not have enough
+     space left to accomodate the key.
+
+
+   The resulting encoding of the numeric string is then
+
+   CONCAT(natsort_encode_length(n_digits), in)
+*/
+static NATSORT_ERR natsort_encode_numeric_string(const char *in,
+                                                 size_t n_digits,
+                                                 String *out)
+{
+  DBUG_ASSERT(in);
+  DBUG_ASSERT(n_digits);
+
+  if (out->length() + natsort_encode_length_max(n_digits - 1) + n_digits >
+      out->alloced_length())
+    return NATSORT_ERR::KEY_TOO_LARGE;
+
+  natsort_encode_length(n_digits - 1, out);
+  out->append(in, n_digits);
+  return NATSORT_ERR::SUCCESS;
+}
+
+/*
+  Calculate max size of the natsort key.
+
+  A digit in string expands to 2 chars  length_prefix , and  the digit
+
+  With even length L=2N, the largest key corresponds to input string
+  in form REPEAT(<digit><letter>,N) and the length of a key is
+  2N + N = 3N
+
+  With odd input length L=2N+1, largest key is built by appending
+  a digit at the end, with key length 3N+2
+
+*/
+static size_t natsort_max_key_size(size_t input_size)
+{
+  return input_size + (input_size + 1)/2 ;
+}
+
+/**
+  Convert a string to natural sort key.
+  @param[in]   in - input string
+  @param[out]  out - output string
+  @param[in]   max_key_size - the maximum size of the output
+               key, in bytes.
+  @return NATSORT_ERR::SUCCESS - successful completion
+          NATSORT_ERR::ALLOC_ERROR - memory allocation error
+          NATSORT_ERR::KEY_TOO_LARGE - resulting key would exceed max_key_size
+*/
+static NATSORT_ERR to_natsort_key(const String *in, String *out,
+                                  size_t max_key_size)
+{
+  size_t n_digits= 0;
+  size_t n_lead_zeros= 0;
+  size_t num_start;
+  size_t reserve_length= std::min(
+      natsort_max_key_size(in->length()) + MAX_BIGINT_WIDTH + 2, max_key_size);
+
+  out->length(0);
+  out->set_charset(in->charset());
+
+  if (out->alloc((uint32) reserve_length))
+    return NATSORT_ERR::ALLOC_ERROR;
+
+  for (size_t pos= 0;; pos++)
+  {
+    char c= pos < in->length() ? (*in)[pos] : 0;
+    bool is_digit= (c >= '0' && c <= '9');
+    if (!is_digit && (n_digits || n_lead_zeros))
+    {
+      /* Handle end of digits run.*/
+      if (!n_digits)
+      {
+        /*We only have zeros.*/
+        n_lead_zeros--;
+        num_start= pos - 1;
+        n_digits= 1;
+      }
+      NATSORT_ERR err= natsort_encode_numeric_string(
+          in->ptr() + num_start, n_digits, out);
+      if (err != NATSORT_ERR::SUCCESS)
+        return err;
+
+      /* Reset state.*/
+      n_digits= 0;
+      num_start= size_t(-1);
+      n_lead_zeros= 0;
+    }
+
+    if (pos == in->length())
+      break;
+
+    if (!is_digit)
+    {
+      if (out->length() == max_key_size)
+        return NATSORT_ERR::KEY_TOO_LARGE;
+      out->append(c);
+    }
+    else if (c == '0' && !n_digits)
+      n_lead_zeros++;
+    else if (!n_digits++)
+      num_start= pos;
+  }
+  return NATSORT_ERR::SUCCESS;
+}
+
+String *Item_func_natural_sort_key::val_str(String *out)
+{
+  String *in= args[0]->val_str();
+  if (args[0]->null_value || !in)
+  {
+    null_value= true;
+    return nullptr;
+  }
+  NATSORT_ERR err= NATSORT_ERR::SUCCESS;
+  CHARSET_INFO *cs= in->charset();
+  ulong max_allowed_packet= current_thd->variables.max_allowed_packet;
+  uint errs;
+  String tmp;
+  /*
+    to_natsort_key() only support charsets where digits are represented by
+    a single byte in range 0x30-0x39. Almost everything is OK, just utf16/32
+    won't do. Full ASCII compatibility is not required, so that SJIS and SWE7
+    are fine.
+  */
+  if (cs->mbminlen != 1)
+  {
+    if (tmp.copy(in, &my_charset_utf8mb4_bin, &errs))
+      goto error_exit;
+    in= &tmp;
+  }
+
+  err= to_natsort_key(in, out, max_allowed_packet / cs->mbminlen);
+
+  if (err != NATSORT_ERR::SUCCESS)
+  {
+    if (err == NATSORT_ERR::KEY_TOO_LARGE)
+    {
+      push_warning_printf(current_thd, Sql_condition::WARN_LEVEL_WARN,
+                          ER_WARN_ALLOWED_PACKET_OVERFLOWED,
+                          ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
+                          max_allowed_packet);
+    }
+    goto error_exit;
+  }
+
+  if (cs->mbminlen != 1)
+  {
+    /* output string is now utf8, convert to input charset.*/
+    if (tmp.copy(out, cs, &errs) || out->copy(tmp))
+      goto error_exit;
+  }
+  null_value= false;
+  return out;
+
+error_exit:
+  null_value= true;
+  return nullptr;
+}
+
+bool Item_func_natural_sort_key::fix_length_and_dec(THD *thd)
+{
+  if (agg_arg_charsets_for_string_result(collation, args, 1))
+    return true;
+  DBUG_ASSERT(collation.collation != NULL);
+  uint32 max_char_len=
+      (uint32) natsort_max_key_size(args[0]->max_char_length());
+  fix_char_length(max_char_len);
+
+  set_maybe_null(args[0]->maybe_null() ||
+                 max_char_len * collation.collation->mbmaxlen >
+                     current_thd->variables.max_allowed_packet);
+  return false;
+}
+
+/**
+  Disable use in stored virtual functions. Temporarily(?), until
+  the encoding is stable.
+*/
+bool Item_func_natural_sort_key::check_vcol_func_processor(void *arg)
+{
+  return mark_unsupported_function(func_name(), "()", arg,
+                                   VCOL_NON_DETERMINISTIC);
+}
+
+#ifdef WITH_WSREP
+#include "wsrep_mysqld.h"
+#include "wsrep_server_state.h"
+/* Format is %d-%d-%llu */
+#define WSREP_MAX_WSREP_SERVER_GTID_STR_LEN 10+1+10+1+20
+
+String *Item_func_wsrep_last_written_gtid::val_str_ascii(String *str)
+{
+  if (gtid_str.alloc(WSREP_MAX_WSREP_SERVER_GTID_STR_LEN+1))
+  {
+    my_error(ER_OUTOFMEMORY, WSREP_MAX_WSREP_SERVER_GTID_STR_LEN);
+    null_value= TRUE;
+    return 0;
+  }
+
+  ssize_t gtid_len= my_snprintf((char*)gtid_str.ptr(), 
+                                WSREP_MAX_WSREP_SERVER_GTID_STR_LEN+1,
+                                "%u-%u-%llu", wsrep_gtid_server.domain_id,
+                                wsrep_gtid_server.server_id,
+                                current_thd->wsrep_last_written_gtid_seqno);
+  if (gtid_len < 0)
+  {
+    my_error(ER_ERROR_WHEN_EXECUTING_COMMAND, MYF(0), func_name(),
+            "wsrep_gtid_print failed");
+    null_value= TRUE;
+    return 0;
+  }
+  gtid_str.length(gtid_len);
+  return &gtid_str;
+}
+
+String *Item_func_wsrep_last_seen_gtid::val_str_ascii(String *str)
+{
+  if (gtid_str.alloc(WSREP_MAX_WSREP_SERVER_GTID_STR_LEN+1))
+  {
+    my_error(ER_OUTOFMEMORY, WSREP_MAX_WSREP_SERVER_GTID_STR_LEN);
+    null_value= TRUE;
+    return 0;
+  }
+  ssize_t gtid_len= my_snprintf((char*)gtid_str.ptr(), 
+                                WSREP_MAX_WSREP_SERVER_GTID_STR_LEN+1,
+                                "%u-%u-%llu", wsrep_gtid_server.domain_id,
+                                wsrep_gtid_server.server_id,
+                                wsrep_gtid_server.seqno());
+  if (gtid_len < 0)
+  {
+    my_error(ER_ERROR_WHEN_EXECUTING_COMMAND, MYF(0), func_name(),
+             "wsrep_gtid_print failed");
+    null_value= TRUE;
+    return 0;
+  }
+  gtid_str.length(gtid_len);
+  return &gtid_str;
+}
+
+longlong Item_func_wsrep_sync_wait_upto::val_int()
+{
+  String *gtid_str __attribute__((unused)) = args[0]->val_str(&value);
+  null_value=0;
+  uint timeout;
+  rpl_gtid *gtid_list;
+  uint32 count;
+  int wait_gtid_ret= 0;
+  int ret= 1;
+
+  if (args[0]->null_value)
+  {
+    my_error(ER_WRONG_ARGUMENTS, MYF(0), func_name());
+    null_value= TRUE;
+    return 0;
+  }
+
+  if (arg_count==2 && !args[1]->null_value)
+    timeout= (uint)(args[1]->val_real());
+  else
+    timeout= (uint)-1;
+
+  if (!(gtid_list= gtid_parse_string_to_list(gtid_str->ptr(), gtid_str->length(),
+                                             &count)))
+  {
+    my_error(ER_INCORRECT_GTID_STATE, MYF(0), func_name());
+    null_value= TRUE;
+    return 0;
+  }
+  if (count == 1)
+  {
+    if (wsrep_check_gtid_seqno(gtid_list[0].domain_id, gtid_list[0].server_id,
+                               gtid_list[0].seq_no))
+    {
+      wait_gtid_ret= wsrep_gtid_server.wait_gtid_upto(gtid_list[0].seq_no, timeout);
+      if ((wait_gtid_ret == ETIMEDOUT) || (wait_gtid_ret == ETIME))
+      {
+        my_error(ER_LOCK_WAIT_TIMEOUT, MYF(0), func_name());
+        ret= 0;
+      }
+      else if (wait_gtid_ret == ENOMEM)
+      {
+        my_error(ER_OUTOFMEMORY, MYF(0), func_name());
+        ret= 0;
+      }
+    }
+  }
+  else
+  { 
+    my_error(ER_WRONG_ARGUMENTS, MYF(0), func_name());
+    null_value= TRUE;
+    ret= 0;
+  }
+  my_free(gtid_list);
+  return ret;
+}
+
+#endif /* WITH_WSREP */