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

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

1 files changed, 1280 insertions, 0 deletions

diff --git a/sql/sql_string.h b/sql/sql_string.h
new file mode 100644
index 00000000..20073592
--- /dev/null
+++ b/sql/sql_string.h
@@ -0,0 +1,1280 @@
+#ifndef SQL_STRING_INCLUDED
+#define SQL_STRING_INCLUDED
+
+/*
+   Copyright (c) 2000, 2013, Oracle and/or its affiliates.
+   Copyright (c) 2008, 2020, 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 */
+
+/* This file is originally from the mysql distribution. Coded by monty */
+
+#ifdef USE_PRAGMA_INTERFACE
+#pragma interface			/* gcc class implementation */
+#endif
+
+#include "m_ctype.h"                            /* my_charset_bin */
+#include <my_sys.h>              /* alloc_root, my_free, my_realloc */
+#include "m_string.h"                           /* TRASH */
+#include "sql_list.h"
+
+class String;
+#ifdef MYSQL_SERVER
+extern PSI_memory_key key_memory_String_value;
+#define STRING_PSI_MEMORY_KEY key_memory_String_value
+#else
+#define STRING_PSI_MEMORY_KEY PSI_NOT_INSTRUMENTED
+#endif
+
+typedef struct st_io_cache IO_CACHE;
+typedef struct st_mem_root MEM_ROOT;
+#define ASSERT_LENGTH(A) DBUG_ASSERT(str_length + (uint32) (A) <= Alloced_length)
+
+#include "pack.h"
+class Binary_string;
+int sortcmp(const Binary_string *s, const Binary_string *t, CHARSET_INFO *cs);
+int stringcmp(const Binary_string *s, const Binary_string *t);
+String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
+inline uint32 copy_and_convert(char *to, size_t to_length, CHARSET_INFO *to_cs,
+                               const char *from, size_t from_length,
+                               CHARSET_INFO *from_cs, uint *errors)
+{
+  return my_convert(to, (uint)to_length, to_cs, from, (uint)from_length,
+                    from_cs, errors);
+}
+
+
+class String_copy_status: protected MY_STRCOPY_STATUS
+{
+public:
+  const char *source_end_pos() const
+  { return m_source_end_pos; }
+  const char *well_formed_error_pos() const
+  { return m_well_formed_error_pos; }
+};
+
+
+class Well_formed_prefix_status: public String_copy_status
+{
+public:
+  Well_formed_prefix_status(CHARSET_INFO *cs,
+                            const char *str, const char *end, size_t nchars)
+  { cs->well_formed_char_length(str, end, nchars, this); }
+};
+
+
+class Well_formed_prefix: public Well_formed_prefix_status
+{
+  const char *m_str; // The beginning of the string
+public:
+  Well_formed_prefix(CHARSET_INFO *cs, const char *str, const char *end,
+                     size_t nchars)
+   :Well_formed_prefix_status(cs, str, end, nchars), m_str(str)
+  { }
+  Well_formed_prefix(CHARSET_INFO *cs, const char *str, size_t length,
+                     size_t nchars)
+   :Well_formed_prefix_status(cs, str, str + length, nchars), m_str(str)
+  { }
+  Well_formed_prefix(CHARSET_INFO *cs, const char *str, size_t length)
+   :Well_formed_prefix_status(cs, str, str + length, length), m_str(str)
+  { }
+  Well_formed_prefix(CHARSET_INFO *cs, LEX_CSTRING str, size_t nchars)
+   :Well_formed_prefix_status(cs, str.str, str.str + str.length, nchars),
+    m_str(str.str)
+  { }
+  size_t length() const { return m_source_end_pos - m_str; }
+};
+
+
+class String_copier: public String_copy_status,
+                     protected MY_STRCONV_STATUS
+{
+public:
+  const char *cannot_convert_error_pos() const
+  { return m_cannot_convert_error_pos; }
+  const char *most_important_error_pos() const
+  {
+    return well_formed_error_pos() ? well_formed_error_pos() :
+                                     cannot_convert_error_pos();
+  }
+  /*
+    Convert a string between character sets.
+    "dstcs" and "srccs" cannot be &my_charset_bin.
+  */
+  size_t convert_fix(CHARSET_INFO *dstcs, char *dst, size_t dst_length,
+                     CHARSET_INFO *srccs, const char *src, size_t src_length,
+                     size_t nchars)
+  {
+    return my_convert_fix(dstcs, dst, dst_length,
+                          srccs, src, src_length, nchars, this, this);
+  }
+  /*
+     Copy a string. Fix bad bytes/characters to '?'.
+  */
+  uint well_formed_copy(CHARSET_INFO *to_cs, char *to, size_t to_length,
+                        CHARSET_INFO *from_cs, const char *from,
+                        size_t from_length, size_t nchars);
+  // Same as above, but without the "nchars" limit.
+  uint well_formed_copy(CHARSET_INFO *to_cs, char *to, size_t to_length,
+                        CHARSET_INFO *from_cs, const char *from,
+                        size_t from_length)
+  {
+    return well_formed_copy(to_cs, to, to_length,
+                            from_cs, from, from_length,
+                            from_length /* No limit on "nchars"*/);
+  }
+};
+
+
+size_t my_copy_with_hex_escaping(CHARSET_INFO *cs,
+                                 char *dst, size_t dstlen,
+                                 const char *src, size_t srclen);
+uint convert_to_printable(char *to, size_t to_len,
+                          const char *from, size_t from_len,
+                          CHARSET_INFO *from_cs, size_t nbytes= 0);
+size_t convert_to_printable_required_length(uint len);
+
+
+class Charset
+{
+  CHARSET_INFO *m_charset;
+public:
+  Charset() :m_charset(&my_charset_bin) { }
+  Charset(CHARSET_INFO *cs) :m_charset(cs) { }
+
+  CHARSET_INFO *charset() const { return m_charset; }
+  bool use_mb() const { return m_charset->use_mb(); }
+  uint mbminlen() const { return m_charset->mbminlen; }
+  uint mbmaxlen() const { return m_charset->mbmaxlen; }
+  bool is_good_for_ft() const
+  {
+    // Binary and UCS2/UTF16/UTF32 are not supported
+    return m_charset != &my_charset_bin && m_charset->mbminlen == 1;
+  }
+
+  size_t numchars(const char *str, const char *end) const
+  {
+    return m_charset->numchars(str, end);
+  }
+  size_t lengthsp(const char *str, size_t length) const
+  {
+    return m_charset->lengthsp(str, length);
+  }
+  size_t charpos(const char *str, const char *end, size_t pos) const
+  {
+    return m_charset->charpos(str, end, pos);
+  }
+  void set_charset(CHARSET_INFO *charset_arg)
+  {
+    m_charset= charset_arg;
+  }
+  void set_charset(const Charset &other)
+  {
+    m_charset= other.m_charset;
+  }
+  void swap(Charset &other)
+  {
+    swap_variables(CHARSET_INFO*, m_charset, other.m_charset);
+  }
+  bool same_encoding(const Charset &other) const
+  {
+    return my_charset_same(m_charset, other.m_charset);
+  }
+  /*
+    Collation name without the character set name.
+    For example, in case of "latin1_swedish_ci",
+    this method returns "_swedish_ci".
+  */
+  LEX_CSTRING collation_specific_name() const;
+  bool encoding_allows_reinterpret_as(CHARSET_INFO *cs) const;
+  bool eq_collation_specific_names(CHARSET_INFO *cs) const;
+  bool can_have_collate_clause() const
+  {
+    return m_charset != &my_charset_bin;
+  }
+
+  /*
+    The MariaDB version when the last collation change happened,
+    e.g. due to a bug fix. See functions below.
+  */
+  static ulong latest_mariadb_version_with_collation_change()
+  {
+    return 110002;
+  }
+
+  /*
+    Check if the collation with the given ID changed its order
+    since the given MariaDB version.
+  */
+  static bool collation_changed_order(ulong mysql_version, uint cs_number)
+  {
+    if ((mysql_version < 50048 &&
+           (cs_number == 11 || /* ascii_general_ci - bug #29499, bug #27562 */
+            cs_number == 41 || /* latin7_general_ci - bug #29461 */
+            cs_number == 42 || /* latin7_general_cs - bug #29461 */
+            cs_number == 20 || /* latin7_estonian_cs - bug #29461 */
+            cs_number == 21 || /* latin2_hungarian_ci - bug #29461 */
+            cs_number == 22 || /* koi8u_general_ci - bug #29461 */
+            cs_number == 23 || /* cp1251_ukrainian_ci - bug #29461 */
+            cs_number == 26)) || /* cp1250_general_ci - bug #29461 */
+           (mysql_version < 50124 &&
+           (cs_number == 33 || /* utf8mb3_general_ci - bug #27877 */
+            cs_number == 35))) /* ucs2_general_ci - bug #27877 */
+        return true;
+
+    if (cs_number == 159 && /* ucs2_general_mysql500_ci - MDEV-30746 */
+        ((mysql_version >= 100400 && mysql_version < 100429) ||
+         (mysql_version >= 100500 && mysql_version < 100520) ||
+         (mysql_version >= 100600 && mysql_version < 100613) ||
+         (mysql_version >= 100700 && mysql_version < 100708) ||
+         (mysql_version >= 100800 && mysql_version < 100808) ||
+         (mysql_version >= 100900 && mysql_version < 100906) ||
+         (mysql_version >= 101000 && mysql_version < 101004) ||
+         (mysql_version >= 101100 && mysql_version < 101103) ||
+         (mysql_version >= 110000 && mysql_version < 110002)))
+      return true;
+    return false;
+  }
+
+  /**
+     Check if a collation has changed ID since the given version.
+     Return the new ID.
+
+     @param mysql_version
+     @param cs_number     - collation ID
+
+     @retval the new collation ID (or cs_number, if no change)
+  */
+
+  static uint upgrade_collation_id(ulong mysql_version, uint cs_number)
+  {
+    if (mysql_version >= 50300 && mysql_version <= 50399)
+    {
+      switch (cs_number) {
+      case 149: return MY_PAGE2_COLLATION_ID_UCS2;   // ucs2_crotian_ci
+      case 213: return MY_PAGE2_COLLATION_ID_UTF8;   // utf8_crotian_ci
+      }
+    }
+    if ((mysql_version >= 50500 && mysql_version <= 50599) ||
+        (mysql_version >= 100000 && mysql_version <= 100005))
+    {
+      switch (cs_number) {
+      case 149: return MY_PAGE2_COLLATION_ID_UCS2;   // ucs2_crotian_ci
+      case 213: return MY_PAGE2_COLLATION_ID_UTF8;   // utf8_crotian_ci
+      case 214: return MY_PAGE2_COLLATION_ID_UTF32;  // utf32_croatian_ci
+      case 215: return MY_PAGE2_COLLATION_ID_UTF16;  // utf16_croatian_ci
+      case 245: return MY_PAGE2_COLLATION_ID_UTF8MB4;// utf8mb4_croatian_ci
+      }
+    }
+    return cs_number;
+  }
+
+};
+
+
+/**
+   Storage for strings with both length and allocated length.
+   Automatically grows on demand.
+*/
+
+class Binary_string: public Sql_alloc
+{
+protected:
+  char *Ptr;
+  uint32 str_length, Alloced_length, extra_alloc;
+  bool alloced, thread_specific;
+  void init_private_data()
+  {
+    Ptr= 0;
+    Alloced_length= extra_alloc= str_length= 0;
+    alloced= thread_specific= false;
+  }
+  inline void free_buffer()
+  {
+    if (alloced)
+    {
+      alloced=0;
+      my_free(Ptr);
+    }
+  }
+public:
+  Binary_string()
+  {
+    init_private_data();
+  }
+  explicit Binary_string(size_t length_arg)
+  {
+    init_private_data();
+    (void) real_alloc(length_arg);
+  }
+  /*
+    NOTE: If one intend to use the c_ptr() method, the following two
+    contructors need the size of memory for STR to be at least LEN+1 (to make
+    room for zero termination).
+  */
+  Binary_string(const char *str, size_t len)
+  {
+    Ptr= (char*) str;
+    str_length= (uint32) len;
+    Alloced_length= 0;                          /* Memory cannot be written to */
+    extra_alloc= 0;
+    alloced= thread_specific= 0;
+  }
+  Binary_string(char *str, size_t len)
+  {
+    Ptr= str;
+    str_length= Alloced_length= (uint32) len;
+    extra_alloc= 0;
+    alloced= thread_specific= 0;
+  }
+  explicit Binary_string(const Binary_string &str)
+  {
+    Ptr= str.Ptr;
+    str_length= str.str_length;
+    Alloced_length= str.Alloced_length;
+    extra_alloc= 0;
+    alloced= thread_specific= 0;
+  }
+
+  ~Binary_string()
+  {
+    free();
+  }
+
+  inline uint32 length() const { return str_length;}
+  inline char& operator [] (size_t i) const { return Ptr[i]; }
+  inline void length(size_t len) { str_length=(uint32)len ; }
+  inline bool is_empty() const { return (str_length == 0); }
+  inline const char *ptr() const { return Ptr; }
+  inline const char *end() const { return Ptr + str_length; }
+  bool has_8bit_bytes() const
+  {
+    for (const char *c= ptr(), *c_end= end(); c < c_end; c++)
+    {
+      if (!my_isascii(*c))
+        return true;
+    }
+    return false;
+  }
+
+  bool bin_eq(const Binary_string *other) const
+  {
+    return length() == other->length() &&
+           !memcmp(ptr(), other->ptr(), length());
+  }
+
+  /*
+    PMG 2004.11.12
+    This is a method that works the same as perl's "chop". It simply
+    drops the last character of a string. This is useful in the case
+    of the federated storage handler where I'm building a unknown
+    number, list of values and fields to be used in a sql insert
+    statement to be run on the remote server, and have a comma after each.
+    When the list is complete, I "chop" off the trailing comma
+
+    ex.
+      String stringobj;
+      stringobj.append("VALUES ('foo', 'fi', 'fo',");
+      stringobj.chop();
+      stringobj.append(")");
+
+    In this case, the value of string was:
+
+    VALUES ('foo', 'fi', 'fo',
+    VALUES ('foo', 'fi', 'fo'
+    VALUES ('foo', 'fi', 'fo')
+  */
+  inline void chop()
+  {
+    if (str_length)
+    {
+      str_length--;
+      Ptr[str_length]= '\0';
+      DBUG_ASSERT(strlen(Ptr) == str_length);
+    }
+  }
+
+  // Returns offset to substring or -1
+  int strstr(const Binary_string &search, uint32 offset=0) const;
+  int strstr(const char *search, uint32 search_length, uint32 offset=0) const;
+  // Returns offset to substring or -1
+  int strrstr(const Binary_string &search, uint32 offset=0) const;
+
+  /*
+    The following append operations do not extend the strings and in production
+    mode do NOT check that alloced memory!
+    q_*** methods writes values of parameters itself
+    qs_*** methods writes string representation of value
+  */
+  void q_append(const char c)
+  {
+    ASSERT_LENGTH(1);
+    Ptr[str_length++] = c;
+  }
+  void q_append2b(const uint32 n)
+  {
+    ASSERT_LENGTH(2);
+    int2store(Ptr + str_length, n);
+    str_length += 2;
+  }
+  void q_append(const uint32 n)
+  {
+    ASSERT_LENGTH(4);
+    int4store(Ptr + str_length, n);
+    str_length += 4;
+  }
+  void q_append(double d)
+  {
+    ASSERT_LENGTH(8);
+    float8store(Ptr + str_length, d);
+    str_length += 8;
+  }
+  void q_append(double *d)
+  {
+    ASSERT_LENGTH(8);
+    float8store(Ptr + str_length, *d);
+    str_length += 8;
+  }
+  /*
+    Append a wide character.
+    The caller must have allocated at least cs->mbmaxlen bytes.
+  */
+  int q_append_wc(my_wc_t wc, CHARSET_INFO *cs)
+  {
+    int mblen;
+    if ((mblen= cs->cset->wc_mb(cs, wc,
+                                (uchar *) end(),
+                                (uchar *) end() + cs->mbmaxlen)) > 0)
+      str_length+= (uint32) mblen;
+    return mblen;
+  }
+  void q_append(const char *data, size_t data_len)
+  {
+    ASSERT_LENGTH(data_len);
+    if (data_len)
+      memcpy(Ptr + str_length, data, data_len);
+    DBUG_ASSERT(str_length <= UINT_MAX32 - data_len);
+    str_length += (uint)data_len;
+  }
+  void q_append(const LEX_CSTRING *ls)
+  {
+    DBUG_ASSERT(ls->length < UINT_MAX32 &&
+                ((ls->length == 0 && !ls->str) ||
+                 ls->length == strlen(ls->str)));
+    q_append(ls->str, (uint32) ls->length);
+  }
+
+  void write_at_position(uint32 position, uint32 value)
+  {
+    DBUG_ASSERT(str_length >= position + 4);
+    int4store(Ptr + position,value);
+  }
+
+  void qs_append(const LEX_CSTRING *ls)
+  {
+    DBUG_ASSERT(ls->length < UINT_MAX32 &&
+                ((ls->length == 0 && !ls->str) ||
+                 ls->length == strlen(ls->str)));
+    qs_append(ls->str, (uint32)ls->length);
+  }
+  void qs_append(const char *str, size_t len);
+  void qs_append_hex(const char *str, uint32 len);
+  void qs_append_hex_uint32(uint32 num);
+  void qs_append(double d);
+  void qs_append(const double *d);
+  inline void qs_append(const char c)
+  {
+    ASSERT_LENGTH(1);
+    Ptr[str_length]= c;
+    str_length++;
+  }
+  void qs_append(int i);
+  void qs_append(uint i)
+  {
+    qs_append((ulonglong)i);
+  }
+  void qs_append(ulong i)
+  {
+    qs_append((ulonglong)i);
+  }
+  void qs_append(ulonglong i);
+  void qs_append(longlong i, int radix)
+  {
+    ASSERT_LENGTH(22);
+    char *buff= Ptr + str_length;
+    char *end= ll2str(i, buff, radix, 0);
+    str_length+= (uint32) (end-buff);
+  }
+
+  /* Mark variable thread specific it it's not allocated already */
+  inline void set_thread_specific()
+  {
+    if (!alloced)
+      thread_specific= 1;
+  }
+  bool is_alloced() const { return alloced; }
+  inline uint32 alloced_length() const { return Alloced_length;}
+  inline uint32 extra_allocation() const { return extra_alloc;}
+  inline void extra_allocation(size_t len) { extra_alloc= (uint32)len; }
+  inline void mark_as_const() { Alloced_length= 0;}
+
+  inline bool uses_buffer_owned_by(const Binary_string *s) const
+  {
+    return (s->alloced && Ptr >= s->Ptr && Ptr < s->Ptr + s->Alloced_length);
+  }
+
+  /* Swap two string objects. Efficient way to exchange data without memcpy. */
+  void swap(Binary_string &s)
+  {
+    swap_variables(char *, Ptr, s.Ptr);
+    swap_variables(uint32, str_length, s.str_length);
+    swap_variables(uint32, Alloced_length, s.Alloced_length);
+    swap_variables(bool, alloced, s.alloced);
+  }
+
+  /**
+     Points the internal buffer to the supplied one. The old buffer is freed.
+     @param str Pointer to the new buffer.
+     @param arg_length Length of the new buffer in characters, excluding any
+            null character.
+     @note The new buffer will not be null terminated.
+  */
+  void set_alloced(char *str, size_t length, size_t alloced_length)
+  {
+    free_buffer();
+    Ptr= str;
+    str_length= (uint32) length;
+    DBUG_ASSERT(alloced_length < UINT_MAX32);
+    Alloced_length= (uint32) alloced_length;
+  }
+  inline void set(char *str, size_t arg_length)
+  {
+    set_alloced(str, arg_length, arg_length);
+  }
+  inline void set(const char *str, size_t length)
+  {
+    free_buffer();
+    Ptr= (char*) str;
+    str_length= (uint32) length;
+    Alloced_length= 0;
+  }
+
+  void set(Binary_string &str, size_t offset, size_t length)
+  {
+    DBUG_ASSERT(&str != this);
+    free_buffer();
+    Ptr= str.Ptr + offset;
+    str_length= (uint32) length;
+    Alloced_length= 0;
+    if (str.Alloced_length)
+      Alloced_length= (uint32) (str.Alloced_length - offset);
+  }
+  LEX_CSTRING to_lex_cstring() const
+  {
+    LEX_CSTRING tmp= {Ptr, str_length};
+    return tmp;
+  }
+  inline LEX_CSTRING *get_value(LEX_CSTRING *res)
+  {
+    res->str=    Ptr;
+    res->length= str_length;
+    return res;
+  }
+
+  /* Take over handling of buffer from some other object */
+  void reset(char *ptr_arg, size_t length_arg, size_t alloced_length_arg)
+  {
+    set_alloced(ptr_arg, length_arg, alloced_length_arg);
+    alloced= ptr_arg != 0;
+  }
+
+  /* Forget about the buffer, let some other object handle it */
+  char *release()
+  {
+    char *old= Ptr;
+    init_private_data();
+    return old;
+  }
+
+  /*
+    This is used to set a new buffer for String.
+    However if the String already has an allocated buffer, it will
+    keep that one.
+    It's not to be used to set the value or length of the string.
+  */
+  inline void set_buffer_if_not_allocated(char *str, size_t arg_length)
+  {
+    if (!alloced)
+    {
+      /*
+        Following should really set str_length= 0, but some code may
+        depend on that the String length is same as buffer length.
+      */
+      Ptr= str;
+      str_length= Alloced_length= (uint32) arg_length;
+    }
+    /* One should set str_length before using it */
+    MEM_UNDEFINED(&str_length, sizeof(str_length));
+  }
+
+  inline Binary_string& operator=(const Binary_string &s)
+  {
+    if (&s != this)
+    {
+      /*
+        It is forbidden to do assignments like
+        some_string = substring_of_that_string
+      */
+      DBUG_ASSERT(!s.uses_buffer_owned_by(this));
+      set_alloced((char *) s.Ptr, s.str_length, s.Alloced_length);
+    }
+    return *this;
+  }
+
+  bool set_hex(ulonglong num);
+  bool set_hex(const char *str, uint32 len);
+  bool set_fcvt(double num, uint decimals);
+
+  bool copy();                                  // Alloc string if not alloced
+  bool copy(const Binary_string &s);            // Allocate new string
+  bool copy(const char *s, size_t arg_length);	// Allocate new string
+  bool copy_or_move(const char *s,size_t arg_length);
+
+  /**
+    Convert a string to a printable format.
+    All non-convertable and control characters are replaced to 5-character
+    sequences '\hhhh'.
+  */
+  bool copy_printable_hhhh(CHARSET_INFO *to_cs,
+                           CHARSET_INFO *from_cs,
+                           const char *from, size_t from_length);
+
+  bool append_ulonglong(ulonglong val);
+  bool append_longlong(longlong val);
+
+  bool append(const char *s, size_t size)
+  {
+    if (!size)
+      return false;
+    if (realloc_with_extra_if_needed(str_length + size))
+      return true;
+    q_append(s, size);
+    return false;
+  }
+  bool append(const LEX_CSTRING &s)
+  {
+    return append(s.str, s.length);
+  }
+  bool append(const Binary_string &s)
+  {
+    return append(s.ptr(), s.length());
+  }
+  bool append(IO_CACHE* file, uint32 arg_length);
+
+  inline bool append_char(char chr)
+  {
+    if (str_length < Alloced_length)
+    {
+      Ptr[str_length++]= chr;
+    }
+    else
+    {
+      if (unlikely(realloc_with_extra(str_length + 1)))
+	return true;
+      Ptr[str_length++]= chr;
+    }
+    return false;
+  }
+  bool append_hex(const char *src, uint32 srclen)
+  {
+    for (const char *src_end= src + srclen ; src != src_end ; src++)
+    {
+      if (unlikely(append_char(_dig_vec_lower[((uchar) *src) >> 4])) ||
+          unlikely(append_char(_dig_vec_lower[((uchar) *src) & 0x0F])))
+        return true;
+    }
+    return false;
+  }
+  bool append_hex_uint32(uint32 num)
+  {
+    if (reserve(8))
+      return true;
+    qs_append_hex_uint32(num);
+    return false;
+  }
+  bool append_with_step(const char *s, uint32 arg_length, uint32 step_alloc)
+  {
+    uint32 new_length= arg_length + str_length;
+    if (new_length > Alloced_length &&
+        unlikely(realloc(new_length + step_alloc)))
+      return true;
+    q_append(s, arg_length);
+    return false;
+  }
+
+  inline char *c_ptr()
+  {
+    if (unlikely(!Ptr))
+      return (char*) "";
+    /*
+      Here we assume that any buffer used to initalize String has
+      an end \0 or have at least an accessable character at end.
+      This is to handle the case of String("Hello",5) and
+      String("hello",5) efficiently.
+
+      We have two options here. To test for !Alloced_length or !alloced.
+      Using "Alloced_length" is slightly safer so that we do not read
+      from potentially unintialized memory (normally not dangerous but
+      may give warnings in valgrind), but "alloced" is safer as there
+      are less change to get memory loss from code that is using
+      String((char*), length) or String.set((char*), length) and does
+      not free things properly (and there is several places in the code
+      where this happens and it is hard to find out if any of these will call
+      c_ptr().
+    */
+    if (unlikely(!alloced && !Ptr[str_length]))
+      return Ptr;
+    if (str_length < Alloced_length)
+    {
+      Ptr[str_length]=0;
+      return Ptr;
+    }
+    (void) realloc(str_length);               /* This will add end \0 */
+    return Ptr;
+  }
+  /*
+    One should use c_ptr() instead for most cases. This will be deleted soon,
+    kept for compatiblity.
+  */
+  inline char *c_ptr_quick()
+  {
+    return c_ptr_safe();
+  }
+  /*
+    This is to be used only in the case when one cannot use c_ptr().
+    The cases are:
+    - When one initializes String with an external buffer and length and
+      buffer[length] could be uninitalized when c_ptr() is called.
+    - When valgrind gives warnings about uninitialized memory with c_ptr().
+  */
+  inline char *c_ptr_safe()
+  {
+    if (Ptr && str_length < Alloced_length)
+      Ptr[str_length]=0;
+    else
+      (void) realloc(str_length);
+    return Ptr;
+  }
+
+  inline void free()
+  {
+    free_buffer();
+    /*
+      We have to clear the values as some Strings, like in Field, are
+      reused after free(). Because of this we cannot use MEM_UNDEFINED() here.
+    */
+    Ptr= 0;
+    str_length= 0;
+    Alloced_length= extra_alloc= 0;
+  }
+
+  inline bool alloc(size_t arg_length)
+  {
+    /*
+      Allocate if we need more space or if we don't have done any
+      allocation yet (we don't want to have Ptr to be NULL for empty strings).
+
+      Note that if arg_length == Alloced_length then we don't allocate.
+      This ensures we don't do any extra allocations in protocol and String:int,
+      but the string will not be automatically null terminated if c_ptr() is not
+      called.
+    */
+    if (arg_length <= Alloced_length && Alloced_length)
+      return 0;
+    return real_alloc(arg_length);
+  }
+  bool real_alloc(size_t arg_length);  // Empties old string
+  bool realloc_raw(size_t arg_length);
+  bool realloc(size_t arg_length)
+  {
+    if (realloc_raw(arg_length+1))
+      return TRUE;
+    Ptr[arg_length]= 0; // This make other funcs shorter
+    return FALSE;
+  }
+  bool realloc_with_extra(size_t arg_length)
+  {
+    if (extra_alloc < 4096)
+      extra_alloc= extra_alloc*2+128;
+    if (realloc_raw(arg_length + extra_alloc))
+      return TRUE;
+    Ptr[arg_length]=0;        // This make other funcs shorter
+    return FALSE;
+  }
+  bool realloc_with_extra_if_needed(size_t arg_length)
+  {
+    if (arg_length < Alloced_length)
+    {
+      Ptr[arg_length]=0; // behave as if realloc was called.
+      return 0;
+    }
+    return realloc_with_extra(arg_length);
+  }
+  // Shrink the buffer, but only if it is allocated on the heap.
+  void shrink(size_t arg_length);
+
+  void move(Binary_string &s)
+  {
+    set_alloced(s.Ptr, s.str_length, s.Alloced_length);
+    extra_alloc= s.extra_alloc;
+    alloced= s.alloced;
+    thread_specific= s.thread_specific;
+    s.alloced= 0;
+  }
+  bool fill(size_t max_length,char fill);
+  /*
+    Replace substring with string
+    If wrong parameter or not enough memory, do nothing
+  */
+  bool replace(uint32 offset,uint32 arg_length, const char *to, uint32 length);
+  bool replace(uint32 offset,uint32 arg_length, const Binary_string &to)
+  {
+    return replace(offset,arg_length,to.ptr(),to.length());
+  }
+
+  int reserve(size_t space_needed)
+  {
+    DBUG_ASSERT((ulonglong) str_length + space_needed < UINT_MAX32);
+    return realloc(str_length + space_needed);
+  }
+  int reserve(size_t space_needed, size_t grow_by);
+
+  inline char *prep_append(uint32 arg_length, uint32 step_alloc)
+  {
+    uint32 new_length= arg_length + str_length;
+    if (new_length > Alloced_length)
+    {
+      if (unlikely(realloc(new_length + step_alloc)))
+        return 0;
+    }
+    uint32 old_length= str_length;
+    str_length+= arg_length;
+    return Ptr + old_length;                  // Area to use
+  }
+
+
+  void q_net_store_length(ulonglong length)
+  {
+    DBUG_ASSERT(Alloced_length >= (str_length + net_length_size(length)));
+    char *pos= (char *) net_store_length((uchar *)(Ptr + str_length), length);
+    str_length= uint32(pos - Ptr);
+  }
+  void q_net_store_data(const uchar *from, size_t length)
+  {
+    DBUG_ASSERT(length < UINT_MAX32);
+    DBUG_ASSERT(Alloced_length >= (str_length + length +
+                                   net_length_size(length)));
+    q_net_store_length(length);
+    q_append((const char *)from, (uint32) length);
+  }
+};
+
+
+class String: public Charset, public Binary_string
+{
+public:
+  String() = default;
+  String(size_t length_arg) :Binary_string(length_arg)
+  { }
+  /*
+    NOTE: If one intend to use the c_ptr() method, the following two
+    contructors need the size of memory for STR to be at least LEN+1 (to make
+    room for zero termination).
+  */
+  String(const char *str, size_t len, CHARSET_INFO *cs)
+   :Charset(cs), Binary_string(str, len)
+  { }
+  String(char *str, size_t len, CHARSET_INFO *cs)
+   :Charset(cs), Binary_string(str, len)
+  { }
+  String(const String &str) = default;
+
+  void set(String &str,size_t offset,size_t arg_length)
+  {
+    Binary_string::set(str, offset, arg_length);
+    set_charset(str);
+  }
+  inline void set(char *str,size_t arg_length, CHARSET_INFO *cs)
+  {
+    Binary_string::set(str, arg_length);
+    set_charset(cs);
+  }
+  inline void set(const char *str,size_t arg_length, CHARSET_INFO *cs)
+  {
+    Binary_string::set(str, arg_length);
+    set_charset(cs);
+  }
+  bool set_ascii(const char *str, size_t arg_length);
+  inline void set_buffer_if_not_allocated(char *str,size_t arg_length,
+                                          CHARSET_INFO *cs)
+  {
+    Binary_string::set_buffer_if_not_allocated(str, arg_length);
+    set_charset(cs);
+  }
+  bool set_int(longlong num, bool unsigned_flag, CHARSET_INFO *cs);
+  bool set(int num, CHARSET_INFO *cs) { return set_int(num, false, cs); }
+  bool set(uint num, CHARSET_INFO *cs) { return set_int(num, true, cs); }
+  bool set(long num, CHARSET_INFO *cs) { return set_int(num, false, cs); }
+  bool set(ulong num, CHARSET_INFO *cs) { return set_int(num, true, cs); }
+  bool set(longlong num, CHARSET_INFO *cs) { return set_int(num, false, cs); }
+  bool set(ulonglong num, CHARSET_INFO *cs) { return set_int((longlong)num, true, cs); }
+  bool set_real(double num,uint decimals, CHARSET_INFO *cs);
+  bool set_fcvt(double num, uint decimals)
+  {
+    set_charset(&my_charset_latin1);
+    return Binary_string::set_fcvt(num, decimals);
+  }
+
+  bool set_hex(ulonglong num)
+  {
+    set_charset(&my_charset_latin1);
+    return Binary_string::set_hex(num);
+  }
+  bool set_hex(const char *str, uint32 len)
+  {
+    set_charset(&my_charset_latin1);
+    return Binary_string::set_hex(str, len);
+  }
+
+  /* Take over handling of buffer from some other object */
+  void reset(char *ptr_arg, size_t length_arg, size_t alloced_length_arg,
+             CHARSET_INFO *cs)
+  {
+    Binary_string::reset(ptr_arg, length_arg, alloced_length_arg);
+    set_charset(cs);
+  }
+
+  inline String& operator = (const String &s)
+  {
+    if (&s != this)
+    {
+      set_charset(s);
+      Binary_string::operator=(s);
+    }
+    return *this;
+  }
+
+  bool copy()
+  {
+    return Binary_string::copy();
+  }
+  bool copy(const String &s)
+  {
+    set_charset(s);
+    return Binary_string::copy(s);
+  }
+  bool copy(const char *s, size_t arg_length, CHARSET_INFO *cs)
+  {
+    set_charset(cs);
+    return Binary_string::copy(s, arg_length);
+  }
+  bool copy_or_move(const char *s, size_t arg_length, CHARSET_INFO *cs)
+  {
+    set_charset(cs);
+    return Binary_string::copy_or_move(s, arg_length);
+  }
+  static bool needs_conversion(size_t arg_length,
+  			       CHARSET_INFO *cs_from, CHARSET_INFO *cs_to,
+			       uint32 *offset);
+  static bool needs_conversion_on_storage(size_t arg_length,
+                                          CHARSET_INFO *cs_from,
+                                          CHARSET_INFO *cs_to);
+  bool copy_aligned(const char *s, size_t arg_length, size_t offset,
+		    CHARSET_INFO *cs);
+  bool set_or_copy_aligned(const char *s, size_t arg_length, CHARSET_INFO *cs);
+  bool can_be_safely_converted_to(CHARSET_INFO *tocs) const
+  {
+    if (charset() == &my_charset_bin)
+      return Well_formed_prefix(tocs, ptr(), length()).length() == length();
+    String try_val;
+    uint try_conv_error= 0;
+    try_val.copy(ptr(), length(), charset(), tocs, &try_conv_error);
+    return try_conv_error == 0;
+  }
+  bool copy(const char*s, size_t arg_length, CHARSET_INFO *csfrom,
+	    CHARSET_INFO *csto, uint *errors);
+  bool copy(const String *str, CHARSET_INFO *tocs, uint *errors)
+  {
+    return copy(str->ptr(), str->length(), str->charset(), tocs, errors);
+  }
+  bool copy(CHARSET_INFO *tocs,
+            CHARSET_INFO *fromcs, const char *src, size_t src_length,
+            size_t nchars, String_copier *copier)
+  {
+    if (unlikely(alloc(tocs->mbmaxlen * src_length)))
+      return true;
+    str_length= copier->well_formed_copy(tocs, Ptr, alloced_length(),
+                                         fromcs, src, (uint) src_length,
+                                         (uint) nchars);
+    set_charset(tocs);
+    return false;
+  }
+  // Append without character set conversion
+  bool append(const String &s)
+  {
+    return Binary_string::append(s);
+  }
+  inline bool append(char chr)
+  {
+    return Binary_string::append_char(chr);
+  }
+  bool append_hex(const char *src, uint32 srclen)
+  {
+    return Binary_string::append_hex(src, srclen);
+  }
+  bool append_hex(const uchar *src, uint32 srclen)
+  {
+    return Binary_string::append_hex((const char*)src, srclen);
+  }
+  bool append_introducer_and_hex(const String *str)
+  {
+    return
+      append('_')   ||
+      append(str->charset()->cs_name) ||
+      append(STRING_WITH_LEN(" 0x")) ||
+      append_hex(str->ptr(), (uint32) str->length());
+  }
+  bool append(IO_CACHE* file, uint32 arg_length)
+  {
+    return Binary_string::append(file, arg_length);
+  }
+  inline bool append(const char *s, uint32 arg_length, uint32 step_alloc)
+  {
+    return append_with_step(s, arg_length, step_alloc);
+  }
+
+  // Append with optional character set conversion from ASCII (e.g. to UCS2)
+  bool append(const LEX_STRING *ls)
+  {
+    DBUG_ASSERT(ls->length < UINT_MAX32 &&
+                ((ls->length == 0 && !ls->str) ||
+                 ls->length == strlen(ls->str)));
+    return append(ls->str, (uint32) ls->length);
+  }
+  bool append(const LEX_CSTRING *ls)
+  {
+    DBUG_ASSERT(ls->length < UINT_MAX32 &&
+                ((ls->length == 0 && !ls->str) ||
+                 ls->length == strlen(ls->str)));
+    return append(ls->str, (uint32) ls->length);
+  }
+  bool append(const LEX_CSTRING &ls)
+  {
+    return append(&ls);
+  }
+  bool append_name_value(const LEX_CSTRING &name,
+                         const LEX_CSTRING &value,
+                         uchar quot= '\0')
+  {
+    return
+      append(name) ||
+      append('=') ||
+      (quot && append(quot)) ||
+      append(value) ||
+      (quot && append(quot));
+  }
+  bool append(const char *s, size_t size);
+  bool append_parenthesized(long nr, int radix= 10);
+
+  // Append with optional character set conversion from cs to charset()
+  bool append(const char *s, size_t arg_length, CHARSET_INFO *cs);
+  bool append(const LEX_CSTRING &s, CHARSET_INFO *cs)
+  {
+    return append(s.str, s.length, cs);
+  }
+
+  // Append a wide character
+  bool append_wc(my_wc_t wc)
+  {
+    if (reserve(mbmaxlen()))
+      return true;
+    int mblen= q_append_wc(wc, charset());
+    if (mblen > 0)
+      return false;
+    else if (mblen == MY_CS_ILUNI && wc != '?')
+      return q_append_wc('?', charset()) <= 0;
+    return true;
+  }
+
+  // Append a number with zero prefilling
+  bool append_zerofill(uint num, uint width)
+  {
+    static const char zeros[15]= "00000000000000";
+    char intbuff[15];
+    uint length= (uint) (int10_to_str(num, intbuff, 10) - intbuff);
+    if (length < width &&
+        append(zeros, width - length, &my_charset_latin1))
+      return true;
+    return append(intbuff, length, &my_charset_latin1);
+  }
+
+  /*
+    Append a bitmask in an uint32 with a translation into a
+    C-style human readable representation, e.g.:
+      0x05 -> "(flag04|flag01)"
+
+    @param flags  - the flags to translate
+    @param names  - an array of flag names
+    @param count  - the number of available elements in "names"
+  */
+  bool append_flag32_names(uint32 flags, LEX_CSTRING names[], size_t count)
+  {
+    bool added= false;
+    if (flags && append('('))
+      return true;
+    for (ulong i= 0; i <= 31; i++)
+    {
+      ulong bit= 31 - i;
+      if (flags & (1 << bit))
+      {
+        if (added && append('|'))
+          return true;
+        if (bit < count ? append(names[bit]) : append('?'))
+          return true;
+        added= true;
+      }
+    }
+    if (flags && append(')'))
+      return true;
+    return false;
+  }
+
+  void strip_sp();
+  friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
+  friend class Field;
+  uint32 numchars() const
+  {
+    return (uint32) Charset::numchars(ptr(), end());
+  }
+  int charpos(longlong i, uint32 offset=0)
+  {
+    if (i <= 0)
+      return (int) i;
+    return (int) Charset::charpos(ptr() + offset, end(), (size_t) i);
+  }
+  size_t lengthsp() const
+  {
+    return Charset::lengthsp(Ptr, str_length);
+  }
+
+  void print(String *to) const;
+  void print_with_conversion(String *to, CHARSET_INFO *cs) const;
+  void print(String *to, CHARSET_INFO *cs) const
+  {
+    if (my_charset_same(charset(), cs))
+      print(to);
+    else
+      print_with_conversion(to, cs);
+  }
+
+  bool append_for_single_quote(const char *st, size_t len);
+  bool append_for_single_quote(const String *s)
+  {
+    return append_for_single_quote(s->ptr(), s->length());
+  }
+
+  void swap(String &s)
+  {
+    Charset::swap(s);
+    Binary_string::swap(s);
+  }
+
+  uint well_formed_length() const
+  {
+    return (uint) Well_formed_prefix(charset(), ptr(), length()).length();
+  }
+  bool is_ascii() const
+  {
+    if (length() == 0)
+      return TRUE;
+    if (charset()->mbminlen > 1)
+      return FALSE;
+    return !has_8bit_bytes();
+  }
+  bool eq(const String *other, CHARSET_INFO *cs) const
+  {
+    return !sortcmp(this, other, cs);
+  }
+private:
+  bool append_semi_hex(const char *s, uint len, CHARSET_INFO *cs);
+};
+
+
+// The following class is a backport from MySQL 5.6:
+/**
+  String class wrapper with a preallocated buffer of size buff_sz
+
+  This class allows to replace sequences of:
+     char buff[12345];
+     String str(buff, sizeof(buff));
+     str.length(0);
+  with a simple equivalent declaration:
+     StringBuffer<12345> str;
+*/
+
+template<size_t buff_sz>
+class StringBuffer : public String
+{
+  char buff[buff_sz];
+
+public:
+  StringBuffer() : String(buff, buff_sz, &my_charset_bin) { length(0); }
+  explicit StringBuffer(CHARSET_INFO *cs) : String(buff, buff_sz, cs)
+  {
+    length(0);
+  }
+  void set_buffer_if_not_allocated(CHARSET_INFO *cs)
+  {
+    if (!is_alloced())
+    {
+      Ptr= buff;
+      Alloced_length= (uint32) buff_sz;
+    }
+    str_length= 0;                          /* Safety, not required */
+    /* One should set str_length before using it */
+    MEM_UNDEFINED(&str_length, sizeof(str_length));
+    set_charset(cs);
+  }
+};
+
+
+template<size_t buff_sz>
+class BinaryStringBuffer : public Binary_string
+{
+  char buff[buff_sz];
+public:
+  BinaryStringBuffer() : Binary_string(buff, buff_sz) { length(0); }
+};
+
+static inline bool check_if_only_end_space(CHARSET_INFO *cs,
+                                           const char *str,
+                                           const char *end)
+{
+  return str + cs->scan(str, end, MY_SEQ_SPACES) == end;
+}
+
+int append_query_string(CHARSET_INFO *csinfo, String *to,
+                        const char *str, size_t len, bool no_backslash);
+
+#endif /* SQL_STRING_INCLUDED */