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

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

1 files changed, 873 insertions, 0 deletions

diff --git a/sql/field_conv.cc b/sql/field_conv.cc
new file mode 100644
index 00000000..ff6d60e7
--- /dev/null
+++ b/sql/field_conv.cc
@@ -0,0 +1,873 @@
+/* Copyright (c) 2000, 2016, Oracle and/or its affiliates.
+   Copyright (c) 2010, 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 */
+
+
+/**
+  @file
+
+  @brief
+  Functions to copy data to or from fields
+
+    This could be done with a single short function but opencoding this
+    gives much more speed.
+*/
+
+#include "mariadb.h"
+#include "sql_priv.h"
+#include "sql_class.h"                          // THD
+#include <m_ctype.h>
+
+void Field::do_field_eq(Copy_field *copy)
+{
+  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
+}
+
+static void do_field_1(Copy_field *copy)
+{
+  copy->to_ptr[0]=copy->from_ptr[0];
+}
+
+static void do_field_2(Copy_field *copy)
+{
+  copy->to_ptr[0]=copy->from_ptr[0];
+  copy->to_ptr[1]=copy->from_ptr[1];
+}
+
+static void do_field_3(Copy_field *copy)
+{
+  copy->to_ptr[0]=copy->from_ptr[0];
+  copy->to_ptr[1]=copy->from_ptr[1];
+  copy->to_ptr[2]=copy->from_ptr[2];
+}
+
+static void do_field_4(Copy_field *copy)
+{
+  copy->to_ptr[0]=copy->from_ptr[0];
+  copy->to_ptr[1]=copy->from_ptr[1];
+  copy->to_ptr[2]=copy->from_ptr[2];
+  copy->to_ptr[3]=copy->from_ptr[3];
+}
+
+static void do_field_6(Copy_field *copy)
+{						// For blob field
+  copy->to_ptr[0]=copy->from_ptr[0];
+  copy->to_ptr[1]=copy->from_ptr[1];
+  copy->to_ptr[2]=copy->from_ptr[2];
+  copy->to_ptr[3]=copy->from_ptr[3];
+  copy->to_ptr[4]=copy->from_ptr[4];
+  copy->to_ptr[5]=copy->from_ptr[5];
+}
+
+static void do_field_8(Copy_field *copy)
+{
+  copy->to_ptr[0]=copy->from_ptr[0];
+  copy->to_ptr[1]=copy->from_ptr[1];
+  copy->to_ptr[2]=copy->from_ptr[2];
+  copy->to_ptr[3]=copy->from_ptr[3];
+  copy->to_ptr[4]=copy->from_ptr[4];
+  copy->to_ptr[5]=copy->from_ptr[5];
+  copy->to_ptr[6]=copy->from_ptr[6];
+  copy->to_ptr[7]=copy->from_ptr[7];
+}
+
+
+static void do_field_to_null_str(Copy_field *copy)
+{
+  if (*copy->from_null_ptr & copy->from_bit)
+  {
+    bzero(copy->to_ptr,copy->from_length);
+    copy->to_null_ptr[0]=1;			// Always bit 1
+  }
+  else
+  {
+    copy->to_null_ptr[0]=0;
+    memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
+  }
+}
+
+
+static void do_outer_field_to_null_str(Copy_field *copy)
+{
+  if (*copy->null_row ||
+      (copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
+  {
+    bzero(copy->to_ptr,copy->from_length);
+    copy->to_null_ptr[0]=1;			// Always bit 1
+  }
+  else
+  {
+    copy->to_null_ptr[0]=0;
+    memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
+  }
+}
+
+
+static int set_bad_null_error(Field *field, int err)
+{
+  switch (field->table->in_use->count_cuted_fields) {
+  case CHECK_FIELD_WARN:
+    field->set_warning(Sql_condition::WARN_LEVEL_WARN, err, 1);
+    /* fall through */
+  case CHECK_FIELD_IGNORE:
+  case CHECK_FIELD_EXPRESSION:
+    return 0;
+  case CHECK_FIELD_ERROR_FOR_NULL:
+    if (!field->table->in_use->no_errors)
+      my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name.str);
+    return -1;
+  }
+  DBUG_ASSERT(0); // impossible
+  return -1;
+}
+
+
+int set_field_to_null(Field *field)
+{
+  if (field->table->null_catch_flags & CHECK_ROW_FOR_NULLS_TO_REJECT)
+  {
+    field->table->null_catch_flags|= REJECT_ROW_DUE_TO_NULL_FIELDS;
+    return -1;
+  }
+  if (field->real_maybe_null())
+  {
+    field->set_null();
+    field->reset();
+    return 0;
+  }
+  field->reset();
+  return set_bad_null_error(field, WARN_DATA_TRUNCATED);
+}
+
+
+/**
+  Set TIMESTAMP to NOW(), AUTO_INCREMENT to the next number, or report an error
+
+  @param field           Field to update
+
+  @retval
+    0    Field could take 0 or an automatic conversion was used
+  @retval
+    -1   Field could not take NULL and no conversion was used.
+    If no_conversion was not set, an error message is printed
+*/
+
+int convert_null_to_field_value_or_error(Field *field)
+{
+  if (field->type() == MYSQL_TYPE_TIMESTAMP)
+  {
+    field->set_time();
+    return 0;
+  }
+
+  field->reset(); // Note: we ignore any potential failure of reset() here.
+
+  if (field == field->table->next_number_field)
+  {
+    field->table->auto_increment_field_not_null= FALSE;
+    return 0;                             // field is set in fill_record()
+  }
+  return set_bad_null_error(field, ER_BAD_NULL_ERROR);
+}
+
+/**
+  Set field to NULL or TIMESTAMP or to next auto_increment number.
+
+  @param field           Field to update
+  @param no_conversions  Set to 1 if we should return 1 if field can't
+                         take null values.
+                         If set to 0 we will do store the 'default value'
+                         if the field is a special field. If not we will
+                         give an error.
+
+  @retval
+    0    Field could take 0 or an automatic conversion was used
+  @retval
+    -1   Field could not take NULL and no conversion was used.
+    If no_conversion was not set, an error message is printed
+*/
+
+int
+set_field_to_null_with_conversions(Field *field, bool no_conversions)
+{
+  if (field->table->null_catch_flags & CHECK_ROW_FOR_NULLS_TO_REJECT)
+  {
+    field->table->null_catch_flags|= REJECT_ROW_DUE_TO_NULL_FIELDS;
+    return -1;
+  }
+  if (field->real_maybe_null())
+  {
+    field->set_null();
+    field->reset();
+    return 0;
+  }
+  if (no_conversions)
+    return -1;
+
+  return convert_null_to_field_value_or_error(field);
+}
+
+
+static void do_skip(Copy_field *copy __attribute__((unused)))
+{
+}
+
+
+/* 
+  Copy: (NULLable field) -> (NULLable field) 
+
+  note: if the record we're copying from is NULL-complemetned (i.e. 
+  from_field->table->null_row==1), it will also have all NULLable columns to be
+  set to NULLs, so we don't need to check table->null_row here.
+*/
+
+static void do_copy_null(Copy_field *copy)
+{
+  if (*copy->from_null_ptr & copy->from_bit)
+  {
+    *copy->to_null_ptr|=copy->to_bit;
+    copy->to_field->reset();
+  }
+  else
+  {
+    *copy->to_null_ptr&= ~copy->to_bit;
+    (copy->do_copy2)(copy);
+  }
+}
+
+/*
+  Copy: (not-NULL field in table that can be NULL-complemented) -> (NULLable 
+     field)
+*/
+
+static void do_outer_field_null(Copy_field *copy)
+{
+  if (*copy->null_row ||
+      (copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
+  {
+    *copy->to_null_ptr|=copy->to_bit;
+    copy->to_field->reset();
+  }
+  else
+  {
+    *copy->to_null_ptr&= ~copy->to_bit;
+    (copy->do_copy2)(copy);
+  }
+}
+
+/*
+  Copy: (not-NULL field in table that can be NULL-complemented) -> (not-NULL
+  field)
+*/
+static void do_copy_nullable_row_to_notnull(Copy_field *copy)
+{
+  if (*copy->null_row ||
+      (copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
+  {
+    copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
+                                WARN_DATA_TRUNCATED, 1);
+    copy->to_field->reset();
+  }
+  else
+  {
+    (copy->do_copy2)(copy);
+  }
+
+}
+
+/* Copy: (NULL-able field) -> (not NULL-able field) */
+static void do_copy_not_null(Copy_field *copy)
+{
+  if (*copy->from_null_ptr & copy->from_bit)
+  {
+    copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
+                                WARN_DATA_TRUNCATED, 1);
+    copy->to_field->reset();
+  }
+  else
+    (copy->do_copy2)(copy);
+}
+
+
+/* Copy: (non-NULLable field) -> (NULLable field) */
+static void do_copy_maybe_null(Copy_field *copy)
+{
+  *copy->to_null_ptr&= ~copy->to_bit;
+  (copy->do_copy2)(copy);
+}
+
+/* timestamp and next_number has special handling in case of NULL values */
+
+static void do_copy_timestamp(Copy_field *copy)
+{
+  if (*copy->from_null_ptr & copy->from_bit)
+  {
+    /* Same as in set_field_to_null_with_conversions() */
+    copy->to_field->set_time();
+  }
+  else
+    (copy->do_copy2)(copy);
+}
+
+
+static void do_copy_next_number(Copy_field *copy)
+{
+  if (*copy->from_null_ptr & copy->from_bit)
+  {
+    /* Same as in set_field_to_null_with_conversions() */
+    copy->to_field->table->auto_increment_field_not_null= FALSE;
+    copy->to_field->reset();
+  }
+  else
+    (copy->do_copy2)(copy);
+}
+
+
+void Field_blob::do_copy_blob(Copy_field *copy)
+{
+  ((Field_blob*) copy->to_field)->copy_value(((Field_blob*) copy->from_field));
+}
+
+void Field_blob::do_conv_blob(Copy_field *copy)
+{
+  copy->from_field->val_str(&copy->tmp);
+  ((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
+					 copy->tmp.length(),
+					 copy->tmp.charset());
+}
+
+/** Save blob in copy->tmp for GROUP BY. */
+
+static void do_save_blob(Copy_field *copy)
+{
+  char buff[MAX_FIELD_WIDTH];
+  String res(buff,sizeof(buff),copy->tmp.charset());
+  copy->from_field->val_str(&res);
+  copy->tmp.copy(res);
+  ((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
+					 copy->tmp.length(),
+					 copy->tmp.charset());
+}
+
+
+void Field::do_field_string(Copy_field *copy)
+{
+  char buff[MAX_FIELD_WIDTH];
+  String res(buff, sizeof(buff), copy->from_field->charset());
+  res.length(0U);
+
+  copy->from_field->val_str(&res);
+  copy->to_field->store(res.c_ptr_quick(), res.length(), res.charset());
+}
+
+
+void Field_enum::do_field_enum(Copy_field *copy)
+{
+  if (copy->from_field->val_int() == 0)
+    ((Field_enum *) copy->to_field)->store_type((ulonglong) 0);
+  else
+    do_field_string(copy);
+}
+
+
+static void do_field_varbinary_pre50(Copy_field *copy)
+{
+  char buff[MAX_FIELD_WIDTH];
+  copy->tmp.set_quick(buff,sizeof(buff),copy->tmp.charset());
+  copy->from_field->val_str(&copy->tmp);
+
+  /* Use the same function as in 4.1 to trim trailing spaces */
+  size_t length= my_lengthsp_8bit(&my_charset_bin, copy->tmp.c_ptr_quick(),
+                                copy->from_field->field_length);
+
+  copy->to_field->store(copy->tmp.c_ptr_quick(), length,
+                        copy->tmp.charset());
+}
+
+
+void Field::do_field_int(Copy_field *copy)
+{
+  longlong value= copy->from_field->val_int();
+  copy->to_field->store(value,
+                        MY_TEST(copy->from_field->flags & UNSIGNED_FLAG));
+}
+
+void Field::do_field_real(Copy_field *copy)
+{
+  double value=copy->from_field->val_real();
+  copy->to_field->store(value);
+}
+
+
+void Field::do_field_decimal(Copy_field *copy)
+{
+  my_decimal value(copy->from_field);
+  copy->to_field->store_decimal(&value);
+}
+
+
+void Field::do_field_timestamp(Copy_field *copy)
+{
+  // XXX why couldn't we do it everywhere?
+  copy->from_field->save_in_field(copy->to_field);
+}
+
+
+void Field::do_field_temporal(Copy_field *copy, date_mode_t fuzzydate)
+{
+  MYSQL_TIME ltime;
+  // TODO: we now need to check result
+  if (copy->from_field->get_date(&ltime, fuzzydate))
+    copy->to_field->reset();
+  else
+    copy->to_field->store_time_dec(&ltime, copy->from_field->decimals());
+}
+
+
+void Field::do_field_datetime(Copy_field *copy)
+{
+  return do_field_temporal(copy, Datetime::Options(TIME_CONV_NONE, current_thd));
+}
+
+
+void Field::do_field_date(Copy_field *copy)
+{
+  return do_field_temporal(copy, Date::Options(TIME_CONV_NONE));
+}
+
+
+void Field_time::do_field_time(Copy_field *copy)
+{
+  return do_field_temporal(copy, Time::Options(current_thd));
+}
+
+
+/**
+  string copy for single byte characters set when to string is shorter than
+  from string.
+*/
+
+static void do_cut_string(Copy_field *copy)
+{
+  CHARSET_INFO *cs= copy->from_field->charset();
+  memcpy(copy->to_ptr,copy->from_ptr,copy->to_length);
+
+  /* Check if we loosed any important characters */
+  if (cs->scan((char*) copy->from_ptr + copy->to_length,
+               (char*) copy->from_ptr + copy->from_length,
+               MY_SEQ_SPACES) < copy->from_length - copy->to_length)
+  {
+    copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
+                                WARN_DATA_TRUNCATED, 1);
+  }
+}
+
+
+/**
+  string copy for multi byte characters set when to string is shorter than
+  from string.
+*/
+
+static void do_cut_string_complex(Copy_field *copy)
+{						// Shorter string field
+  CHARSET_INFO *cs= copy->from_field->charset();
+  const uchar *from_end= copy->from_ptr + copy->from_length;
+  Well_formed_prefix prefix(cs,
+                           (char*) copy->from_ptr,
+                           (char*) from_end,
+                           copy->to_length / cs->mbmaxlen);
+  size_t copy_length= prefix.length();
+  if (copy->to_length < copy_length)
+    copy_length= copy->to_length;
+  memcpy(copy->to_ptr, copy->from_ptr, copy_length);
+
+  /* Check if we lost any important characters */
+  if (unlikely(prefix.well_formed_error_pos() ||
+               cs->scan((char*) copy->from_ptr + copy_length,
+                        (char*) from_end,
+                        MY_SEQ_SPACES) <
+               (copy->from_length - copy_length)))
+  {
+    copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
+                                WARN_DATA_TRUNCATED, 1);
+  }
+
+  if (copy_length < copy->to_length)
+    cs->fill((char*) copy->to_ptr + copy_length,
+             copy->to_length - copy_length, ' ');
+}
+
+
+
+
+static void do_expand_binary(Copy_field *copy)
+{
+  CHARSET_INFO *cs= copy->from_field->charset();
+  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
+  cs->fill((char*) copy->to_ptr+copy->from_length,
+           copy->to_length-copy->from_length, '\0');
+}
+
+
+
+static void do_expand_string(Copy_field *copy)
+{
+  CHARSET_INFO *cs= copy->from_field->charset();
+  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
+  cs->fill((char*) copy->to_ptr+copy->from_length,
+           copy->to_length-copy->from_length, ' ');
+}
+
+
+static void do_varstring1(Copy_field *copy)
+{
+  uint length= (uint) *(uchar*) copy->from_ptr;
+  if (length > copy->to_length- 1)
+  {
+    length=copy->to_length - 1;
+    if (copy->from_field->table->in_use->count_cuted_fields >
+        CHECK_FIELD_EXPRESSION &&
+        copy->to_field)
+      copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
+                                  WARN_DATA_TRUNCATED, 1);
+  }
+  *(uchar*) copy->to_ptr= (uchar) length;
+  memcpy(copy->to_ptr+1, copy->from_ptr + 1, length);
+}
+
+
+static void do_varstring1_mb(Copy_field *copy)
+{
+  CHARSET_INFO *cs= copy->from_field->charset();
+  uint from_length= (uint) *(uchar*) copy->from_ptr;
+  const uchar *from_ptr= copy->from_ptr + 1;
+  uint to_char_length= (copy->to_length - 1) / cs->mbmaxlen;
+  Well_formed_prefix prefix(cs, (char*) from_ptr, from_length, to_char_length);
+  if (prefix.length() < from_length)
+  {
+    if (current_thd->count_cuted_fields > CHECK_FIELD_EXPRESSION)
+      copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
+                                  WARN_DATA_TRUNCATED, 1);
+  }
+  *copy->to_ptr= (uchar) prefix.length();
+  memcpy(copy->to_ptr + 1, from_ptr, prefix.length());
+}
+
+
+static void do_varstring2(Copy_field *copy)
+{
+  uint length=uint2korr(copy->from_ptr);
+  if (length > copy->to_length- HA_KEY_BLOB_LENGTH)
+  {
+    length=copy->to_length-HA_KEY_BLOB_LENGTH;
+    if (copy->from_field->table->in_use->count_cuted_fields >
+        CHECK_FIELD_EXPRESSION &&
+        copy->to_field)
+      copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
+                                  WARN_DATA_TRUNCATED, 1);
+  }
+  int2store(copy->to_ptr,length);
+  memcpy(copy->to_ptr+HA_KEY_BLOB_LENGTH, copy->from_ptr + HA_KEY_BLOB_LENGTH,
+         length);
+}
+
+
+static void do_varstring2_mb(Copy_field *copy)
+{
+  CHARSET_INFO *cs= copy->from_field->charset();
+  uint char_length= (copy->to_length - HA_KEY_BLOB_LENGTH) / cs->mbmaxlen;
+  uint from_length= uint2korr(copy->from_ptr);
+  const uchar *from_beg= copy->from_ptr + HA_KEY_BLOB_LENGTH;
+  Well_formed_prefix prefix(cs, (char*) from_beg, from_length, char_length);
+  if (prefix.length() < from_length)
+  {
+    if (current_thd->count_cuted_fields > CHECK_FIELD_EXPRESSION)
+      copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
+                                  WARN_DATA_TRUNCATED, 1);
+  }  
+  int2store(copy->to_ptr, prefix.length());
+  memcpy(copy->to_ptr+HA_KEY_BLOB_LENGTH, from_beg, prefix.length());
+}
+ 
+
+/***************************************************************************
+** The different functions that fills in a Copy_field class
+***************************************************************************/
+
+/**
+  copy of field to maybe null string.
+  If field is null then the all bytes are set to 0.
+  if field is not null then the first byte is set to 1 and the rest of the
+  string is the field value.
+  The 'to' buffer should have a size of field->pack_length()+1
+*/
+
+void Copy_field::set(uchar *to,Field *from)
+{
+  from_ptr=from->ptr;
+  to_ptr=to;
+  from_length=from->pack_length_in_rec();
+  if (from->maybe_null())
+  {
+    from_null_ptr=from->null_ptr;
+    from_bit=	  from->null_bit;
+    to_ptr[0]=	  1;				// Null as default value
+    to_null_ptr=  (uchar*) to_ptr++;
+    to_bit=	  1;
+    if (from->table->maybe_null)
+    {
+      null_row=   &from->table->null_row;
+      do_copy=	  do_outer_field_to_null_str;
+    }
+    else
+      do_copy=	  do_field_to_null_str;
+  }
+  else
+  { 
+    to_null_ptr=  0;				// For easy debugging
+    do_copy= Field::do_field_eq;
+  }
+}
+
+
+/*
+  To do: 
+
+  If 'save' is set to true and the 'from' is a blob field, do_copy is set to
+  do_save_blob rather than do_conv_blob.  The only differences between them
+  appears to be:
+
+  - do_save_blob allocates and uses an intermediate buffer before calling 
+    Field_blob::store. Is this in order to trigger the call to 
+    well_formed_copy_nchars, by changing the pointer copy->tmp.ptr()?
+    That call will take place anyway in all known cases.
+ */
+void Copy_field::set(Field *to,Field *from,bool save)
+{
+  if (to->type() == MYSQL_TYPE_NULL)
+  {
+    to_null_ptr=0;				// For easy debugging
+    to_ptr=0;
+    do_copy=do_skip;
+    return;
+  }
+  from_field=from;
+  to_field=to;
+  from_ptr=from->ptr;
+  from_length=from->pack_length_in_rec();
+  to_ptr=  to->ptr;
+  to_length=to_field->pack_length_in_rec();
+
+  // set up null handling
+  from_null_ptr=to_null_ptr=0;
+  if (from->maybe_null())
+  {
+    from_null_ptr=	from->null_ptr;
+    from_bit=		from->null_bit;
+    if (to_field->real_maybe_null())
+    {
+      to_null_ptr=	to->null_ptr;
+      to_bit=		to->null_bit;
+      if (from_null_ptr)
+	do_copy=	do_copy_null;
+      else
+      {
+	null_row=	&from->table->null_row;
+	do_copy=	do_outer_field_null;
+      }
+    }
+    else
+    {
+      if (to_field->type() == MYSQL_TYPE_TIMESTAMP)
+        do_copy= do_copy_timestamp;               // Automatic timestamp
+      else if (to_field == to_field->table->next_number_field)
+        do_copy= do_copy_next_number;
+      else
+      {
+        if (!from_null_ptr)
+        {
+          null_row= &from->table->null_row;
+          do_copy= do_copy_nullable_row_to_notnull;
+        }
+        else
+          do_copy= do_copy_not_null;
+      }
+    }
+  }
+  else if (to_field->real_maybe_null())
+  {
+    to_null_ptr=	to->null_ptr;
+    to_bit=		to->null_bit;
+    do_copy= do_copy_maybe_null;
+  }
+  else
+   do_copy=0;
+
+  if ((to->flags & BLOB_FLAG) && save)
+    do_copy2= do_save_blob;
+  else
+    do_copy2= from->get_copy_func_to(to);
+  if (!do_copy)					// Not null
+    do_copy=do_copy2;
+}
+
+
+Field::Copy_func *Field_timestamp::get_copy_func(const Field *from) const
+{
+  Field::Copy_func *copy= Field_temporal::get_copy_func(from);
+  if (copy == do_field_datetime && from->type() == MYSQL_TYPE_TIMESTAMP)
+    return do_field_timestamp;
+  else
+    return copy;
+}
+
+
+Field::Copy_func *Field_date_common::get_copy_func(const Field *from) const
+{
+  Field::Copy_func *copy= Field_temporal::get_copy_func(from);
+  return copy == do_field_datetime ? do_field_date : copy;
+}
+
+
+Field::Copy_func *Field_temporal::get_copy_func(const Field *from) const
+{
+  /* If types are not 100 % identical then convert trough get_date() */
+  if (from->cmp_type() == REAL_RESULT)
+    return do_field_string; // TODO: MDEV-9344
+  if (from->type() == MYSQL_TYPE_YEAR)
+    return do_field_string; // TODO: MDEV-9343
+  if (from->type() == MYSQL_TYPE_BIT)
+    return do_field_int;
+  if (!eq_def(from) ||
+      (table->in_use->variables.sql_mode &
+       (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE)))
+    return do_field_datetime;
+  return get_identical_copy_func();
+}
+
+
+Field::Copy_func *Field_varstring::get_copy_func(const Field *from) const
+{
+  if (from->type() == MYSQL_TYPE_BIT)
+    return do_field_int;
+  /*
+    Detect copy from pre 5.0 varbinary to varbinary as of 5.0 and
+    use special copy function that removes trailing spaces and thus
+    repairs data.
+  */
+  if (from->type() == MYSQL_TYPE_VAR_STRING && !from->has_charset() &&
+      !Field_varstring::has_charset())
+    return do_field_varbinary_pre50;
+  if (Field_varstring::real_type() != from->real_type() ||
+      Field_varstring::charset() != from->charset() ||
+      length_bytes != ((const Field_varstring*) from)->length_bytes ||
+      !compression_method() != !from->compression_method())
+    return do_field_string;
+  return length_bytes == 1 ?
+         (from->charset()->mbmaxlen == 1 ? do_varstring1 : do_varstring1_mb) :
+         (from->charset()->mbmaxlen == 1 ? do_varstring2 : do_varstring2_mb);
+}
+
+
+Field::Copy_func *Field_string::get_copy_func(const Field *from) const
+{
+  if (from->type() == MYSQL_TYPE_BIT)
+    return do_field_int;
+  if (Field_string::type_handler() != from->type_handler() ||
+      Field_string::charset() != from->charset())
+    return do_field_string;
+  if (Field_string::pack_length() < from->pack_length())
+    return (Field_string::charset()->mbmaxlen == 1 ?
+            do_cut_string : do_cut_string_complex);
+  if (Field_string::pack_length() > from->pack_length())
+    return Field_string::charset() == &my_charset_bin ? do_expand_binary :
+                                                        do_expand_string;
+  return get_identical_copy_func();
+}
+
+
+Field::Copy_func *Field::get_identical_copy_func() const
+{
+  /* Identical field types */
+  switch (pack_length()) {
+  case 1: return do_field_1;
+  case 2: return do_field_2;
+  case 3: return do_field_3;
+  case 4: return do_field_4;
+  case 6: return do_field_6;
+  case 8: return do_field_8;
+  }
+  return do_field_eq;
+}
+
+
+bool Field_temporal::memcpy_field_possible(const Field *from) const
+{
+  return real_type() == from->real_type() &&
+         decimals() == from->decimals() &&
+         !sql_mode_for_dates(table->in_use);
+}
+
+
+static int field_conv_memcpy(Field *to, Field *from)
+{
+  /*
+    This may happen if one does 'UPDATE ... SET x=x'
+    The test is here mostly for valgrind, but can also be relevant
+    if memcpy() is implemented with prefetch-write
+  */
+  if (to->ptr != from->ptr)
+    memcpy(to->ptr,from->ptr, to->pack_length());
+  return 0;
+}
+
+
+/**
+  Copy value of the field with conversion.
+
+  @note Impossibility of simple copy should be checked before this call.
+
+  @param to              The field to copy to
+
+  @retval TRUE ERROR
+  @retval FALSE OK
+
+*/
+static int field_conv_incompatible(Field *to, Field *from)
+{
+  return to->store_field(from);
+}
+
+
+/**
+  Simple quick field converter that is called on insert, e.g.:
+    INSERT INTO t1 (field1) SELECT field2 FROM t2;
+*/
+
+int field_conv(Field *to,Field *from)
+{
+  return to->memcpy_field_possible(from) ?
+         field_conv_memcpy(to, from) :
+         field_conv_incompatible(to, from);
+}
+
+
+fast_field_copier Field::get_fast_field_copier(const Field *from)
+{
+  DBUG_ENTER("Field::get_fast_field_copier");
+  DBUG_RETURN(memcpy_field_possible(from) ?
+              &field_conv_memcpy :
+              &field_conv_incompatible);
+}