field_conv.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:16k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000-2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /*
  14.  Functions to copy data to or from fields
  15.  This could be done with a single short function but opencoding this
  16.  gives much more speed.
  17.  */
  18. #include "mysql_priv.h"
  19. #include <m_ctype.h>
  20. static void do_field_eq(Copy_field *copy)
  21. {
  22.   memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
  23. }
  24. static void do_field_1(Copy_field *copy)
  25. {
  26.   copy->to_ptr[0]=copy->from_ptr[0];
  27. }
  28. static void do_field_2(Copy_field *copy)
  29. {
  30.   copy->to_ptr[0]=copy->from_ptr[0];
  31.   copy->to_ptr[1]=copy->from_ptr[1];
  32. }
  33. static void do_field_3(Copy_field *copy)
  34. {
  35.   copy->to_ptr[0]=copy->from_ptr[0];
  36.   copy->to_ptr[1]=copy->from_ptr[1];
  37.   copy->to_ptr[2]=copy->from_ptr[2];
  38. }
  39. static void do_field_4(Copy_field *copy)
  40. {
  41.   copy->to_ptr[0]=copy->from_ptr[0];
  42.   copy->to_ptr[1]=copy->from_ptr[1];
  43.   copy->to_ptr[2]=copy->from_ptr[2];
  44.   copy->to_ptr[3]=copy->from_ptr[3];
  45. }
  46. static void do_field_6(Copy_field *copy)
  47. { // For blob field
  48.   copy->to_ptr[0]=copy->from_ptr[0];
  49.   copy->to_ptr[1]=copy->from_ptr[1];
  50.   copy->to_ptr[2]=copy->from_ptr[2];
  51.   copy->to_ptr[3]=copy->from_ptr[3];
  52.   copy->to_ptr[4]=copy->from_ptr[4];
  53.   copy->to_ptr[5]=copy->from_ptr[5];
  54. }
  55. static void do_field_8(Copy_field *copy)
  56. {
  57.   copy->to_ptr[0]=copy->from_ptr[0];
  58.   copy->to_ptr[1]=copy->from_ptr[1];
  59.   copy->to_ptr[2]=copy->from_ptr[2];
  60.   copy->to_ptr[3]=copy->from_ptr[3];
  61.   copy->to_ptr[4]=copy->from_ptr[4];
  62.   copy->to_ptr[5]=copy->from_ptr[5];
  63.   copy->to_ptr[6]=copy->from_ptr[6];
  64.   copy->to_ptr[7]=copy->from_ptr[7];
  65. }
  66. static void do_field_to_null_str(Copy_field *copy)
  67. {
  68.   if (*copy->from_null_ptr & copy->from_bit)
  69.   {
  70.     bzero(copy->to_ptr,copy->from_length);
  71.     copy->to_null_ptr[0]=1; // Always bit 1
  72.   }
  73.   else
  74.   {
  75.     copy->to_null_ptr[0]=0;
  76.     memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
  77.   }
  78. }
  79. static void do_outer_field_to_null_str(Copy_field *copy)
  80. {
  81.   if (*copy->null_row ||
  82.       copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit))
  83.   {
  84.     bzero(copy->to_ptr,copy->from_length);
  85.     copy->to_null_ptr[0]=1; // Always bit 1
  86.   }
  87.   else
  88.   {
  89.     copy->to_null_ptr[0]=0;
  90.     memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
  91.   }
  92. }
  93. int
  94. set_field_to_null(Field *field)
  95. {
  96.   if (field->real_maybe_null())
  97.   {
  98.     field->set_null();
  99.     field->reset();
  100.     return 0;
  101.   }
  102.   field->reset();
  103.   if (current_thd->count_cuted_fields == CHECK_FIELD_WARN)
  104.   {
  105.     field->set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
  106.                        ER_WARN_DATA_TRUNCATED, 1);
  107.     return 0;
  108.   }
  109.   if (!current_thd->no_errors)
  110.     my_printf_error(ER_BAD_NULL_ERROR,ER(ER_BAD_NULL_ERROR),MYF(0),
  111.     field->field_name);
  112.   return -1;
  113. }
  114. /*
  115.   Set field to NULL or TIMESTAMP or to next auto_increment number
  116.   SYNOPSIS
  117.     set_field_to_null_with_conversions()
  118.     field Field to update
  119.     no_conversion Set to 1 if we should return 1 if field can't
  120. take null values.
  121. If set to 0 we will do store the 'default value'
  122. if the field is a special field. If not we will
  123. give an error.
  124.   RETURN VALUES
  125.     0 Field could take 0 or an automatic conversion was used
  126.     -1 Field could not take NULL and no conversion was used.
  127. If no_conversion was not set, an error message is printed
  128. */
  129. int
  130. set_field_to_null_with_conversions(Field *field, bool no_conversions)
  131. {
  132.   if (field->real_maybe_null())
  133.   {
  134.     field->set_null();
  135.     field->reset();
  136.     return 0;
  137.   }
  138.   if (no_conversions)
  139.     return -1;
  140.   /*
  141.     Check if this is a special type, which will get a special walue
  142.     when set to NULL (TIMESTAMP fields which allow setting to NULL
  143.     are handled by first check).
  144.   */
  145.   if (field->type() == FIELD_TYPE_TIMESTAMP)
  146.   {
  147.     ((Field_timestamp*) field)->set_time();
  148.     return 0; // Ok to set time to NULL
  149.   }
  150.   field->reset();
  151.   if (field == field->table->next_number_field)
  152.   {
  153.     field->table->auto_increment_field_not_null= FALSE;
  154.     return 0; // field is set in handler.cc
  155.   }
  156.   if (current_thd->count_cuted_fields == CHECK_FIELD_WARN)
  157.   {
  158.     field->set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
  159.                        ER_WARN_NULL_TO_NOTNULL, 1);
  160.     return 0;
  161.   }
  162.   if (!current_thd->no_errors)
  163.     my_printf_error(ER_BAD_NULL_ERROR,ER(ER_BAD_NULL_ERROR),MYF(0),
  164.     field->field_name);
  165.   return -1;
  166. }
  167. static void do_skip(Copy_field *copy __attribute__((unused)))
  168. {
  169. }
  170. static void do_copy_null(Copy_field *copy)
  171. {
  172.   if (*copy->from_null_ptr & copy->from_bit)
  173.   {
  174.     *copy->to_null_ptr|=copy->to_bit;
  175.     copy->to_field->reset();
  176.   }
  177.   else
  178.   {
  179.     *copy->to_null_ptr&= ~copy->to_bit;
  180.     (copy->do_copy2)(copy);
  181.   }
  182. }
  183. static void do_outer_field_null(Copy_field *copy)
  184. {
  185.   if (*copy->null_row ||
  186.       copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit))
  187.   {
  188.     *copy->to_null_ptr|=copy->to_bit;
  189.     copy->to_field->reset();
  190.   }
  191.   else
  192.   {
  193.     *copy->to_null_ptr&= ~copy->to_bit;
  194.     (copy->do_copy2)(copy);
  195.   }
  196. }
  197. static void do_copy_not_null(Copy_field *copy)
  198. {
  199.   if (*copy->from_null_ptr & copy->from_bit)
  200.   {
  201.     copy->to_field->set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
  202.                                 ER_WARN_DATA_TRUNCATED, 1);
  203.     copy->to_field->reset();
  204.   }
  205.   else
  206.     (copy->do_copy2)(copy);
  207. }
  208. static void do_copy_maybe_null(Copy_field *copy)
  209. {
  210.   *copy->to_null_ptr&= ~copy->to_bit;
  211.   (copy->do_copy2)(copy);
  212. }
  213. /* timestamp and next_number has special handling in case of NULL values */
  214. static void do_copy_timestamp(Copy_field *copy)
  215. {
  216.   if (*copy->from_null_ptr & copy->from_bit)
  217.   {
  218.     /* Same as in set_field_to_null_with_conversions() */
  219.     ((Field_timestamp*) copy->to_field)->set_time();
  220.   }
  221.   else
  222.     (copy->do_copy2)(copy);
  223. }
  224. static void do_copy_next_number(Copy_field *copy)
  225. {
  226.   if (*copy->from_null_ptr & copy->from_bit)
  227.   {
  228.     /* Same as in set_field_to_null_with_conversions() */
  229.     copy->to_field->table->auto_increment_field_not_null= FALSE;
  230.     copy->to_field->reset();
  231.   }
  232.   else
  233.     (copy->do_copy2)(copy);
  234. }
  235. static void do_copy_blob(Copy_field *copy)
  236. {
  237.   ulong length=((Field_blob*) copy->from_field)->get_length();
  238.   ((Field_blob*) copy->to_field)->store_length(length);
  239.   memcpy_fixed(copy->to_ptr,copy->from_ptr,sizeof(char*));
  240. }
  241. static void do_conv_blob(Copy_field *copy)
  242. {
  243.   copy->from_field->val_str(&copy->tmp);
  244.   ((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
  245.  copy->tmp.length(),
  246.  copy->tmp.charset());
  247. }
  248. /* Save blob in copy->tmp for GROUP BY */
  249. static void do_save_blob(Copy_field *copy)
  250. {
  251.   char buff[MAX_FIELD_WIDTH];
  252.   String res(buff,sizeof(buff),copy->tmp.charset());
  253.   copy->from_field->val_str(&res);
  254.   copy->tmp.copy(res);
  255.   ((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
  256.  copy->tmp.length(),
  257.  copy->tmp.charset());
  258. }
  259. static void do_field_string(Copy_field *copy)
  260. {
  261.   char buff[MAX_FIELD_WIDTH];
  262.   copy->tmp.set_quick(buff,sizeof(buff),copy->tmp.charset());
  263.   copy->from_field->val_str(&copy->tmp);
  264.   copy->to_field->store(copy->tmp.c_ptr_quick(),copy->tmp.length(),copy->tmp.charset());
  265. }
  266. static void do_field_int(Copy_field *copy)
  267. {
  268.   longlong value=copy->from_field->val_int();
  269.   copy->to_field->store(value);
  270. }
  271. static void do_field_real(Copy_field *copy)
  272. {
  273.   double value=copy->from_field->val_real();
  274.   copy->to_field->store(value);
  275. }
  276. /*
  277.   string copy for single byte characters set when to string is shorter than
  278.   from string
  279. */
  280. static void do_cut_string(Copy_field *copy)
  281. {
  282.   CHARSET_INFO *cs= copy->from_field->charset();
  283.   memcpy(copy->to_ptr,copy->from_ptr,copy->to_length);
  284.   /* Check if we loosed any important characters */
  285.   if (cs->cset->scan(cs,
  286.                      copy->from_ptr + copy->to_length,
  287.                      copy->from_ptr + copy->from_length,
  288.                      MY_SEQ_SPACES) < copy->from_length - copy->to_length)
  289.   {
  290.     copy->to_field->set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
  291.                                 ER_WARN_DATA_TRUNCATED, 1);
  292.   }
  293. }
  294. /*
  295.   string copy for multi byte characters set when to string is shorter than
  296.   from string
  297. */
  298. static void do_cut_string_complex(Copy_field *copy)
  299. { // Shorter string field
  300.   int well_formed_error;
  301.   CHARSET_INFO *cs= copy->from_field->charset();
  302.   const char *from_end= copy->from_ptr + copy->from_length;
  303.   uint copy_length= cs->cset->well_formed_len(cs, copy->from_ptr, from_end, 
  304.                                               copy->to_length / cs->mbmaxlen,
  305.                                               &well_formed_error);
  306.   if (copy->to_length < copy_length)
  307.     copy_length= copy->to_length;
  308.   memcpy(copy->to_ptr, copy->from_ptr, copy_length);
  309.   /* Check if we lost any important characters */
  310.   if (well_formed_error ||
  311.       cs->cset->scan(cs, copy->from_ptr + copy_length, from_end,
  312.                      MY_SEQ_SPACES) < (copy->from_length - copy_length))
  313.   {
  314.     copy->to_field->set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
  315.                                 ER_WARN_DATA_TRUNCATED, 1);
  316.   }
  317.   if (copy_length < copy->to_length)
  318.     cs->cset->fill(cs, copy->to_ptr + copy_length,
  319.                    copy->to_length - copy_length, ' ');
  320. }
  321. static void do_expand_string(Copy_field *copy)
  322. {
  323.   CHARSET_INFO *cs= copy->from_field->charset();
  324.   memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
  325.   cs->cset->fill(cs, copy->to_ptr+copy->from_length,
  326.                      copy->to_length-copy->from_length, ' ');
  327. }
  328. static void do_varstring(Copy_field *copy)
  329. {
  330.   uint length=uint2korr(copy->from_ptr);
  331.   if (length > copy->to_length-2)
  332.   {
  333.     length=copy->to_length-2;
  334.     if (current_thd->count_cuted_fields)
  335.       copy->to_field->set_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
  336.                                   ER_WARN_DATA_TRUNCATED, 1);
  337.   }
  338.   int2store(copy->to_ptr,length);
  339.   memcpy(copy->to_ptr+2, copy->from_ptr,length);
  340. }
  341. /***************************************************************************
  342. ** The different functions that fills in a Copy_field class
  343. ***************************************************************************/
  344. /*
  345.   copy of field to maybe null string.
  346.   If field is null then the all bytes are set to 0.
  347.   if field is not null then the first byte is set to 1 and the rest of the
  348.   string is the field value.
  349.   The 'to' buffer should have a size of field->pack_length()+1
  350. */
  351. void Copy_field::set(char *to,Field *from)
  352. {
  353.   from_ptr=from->ptr;
  354.   to_ptr=to;
  355.   from_length=from->pack_length();
  356.   if (from->maybe_null())
  357.   {
  358.     from_null_ptr=from->null_ptr;
  359.     from_bit=   from->null_bit;
  360.     to_ptr[0]=   1; // Null as default value
  361.     to_null_ptr=  (uchar*) to_ptr++;
  362.     to_bit=   1;
  363.     if (from->table->maybe_null)
  364.     {
  365.       null_row=   &from->table->null_row;
  366.       do_copy=   do_outer_field_to_null_str;
  367.     }
  368.     else
  369.       do_copy=   do_field_to_null_str;
  370.   }
  371.   else
  372.   {
  373.     to_null_ptr=  0; // For easy debugging
  374.     do_copy=   do_field_eq;
  375.   }
  376. }
  377. void Copy_field::set(Field *to,Field *from,bool save)
  378. {
  379.   if (to->type() == FIELD_TYPE_NULL)
  380.   {
  381.     to_null_ptr=0; // For easy debugging
  382.     to_ptr=0;
  383.     do_copy=do_skip;
  384.     return;
  385.   }
  386.   from_field=from;
  387.   to_field=to;
  388.   from_ptr=from->ptr;
  389.   from_length=from->pack_length();
  390.   to_ptr=  to->ptr;
  391.   to_length=to_field->pack_length();
  392.   // set up null handling
  393.   from_null_ptr=to_null_ptr=0;
  394.   if (from->maybe_null())
  395.   {
  396.     from_null_ptr= from->null_ptr;
  397.     from_bit= from->null_bit;
  398.     if (to_field->real_maybe_null())
  399.     {
  400.       to_null_ptr= to->null_ptr;
  401.       to_bit= to->null_bit;
  402.       if (from_null_ptr)
  403. do_copy= do_copy_null;
  404.       else
  405.       {
  406. null_row= &from->table->null_row;
  407. do_copy= do_outer_field_null;
  408.       }
  409.     }
  410.     else
  411.     {
  412.       if (to_field->type() == FIELD_TYPE_TIMESTAMP)
  413.         do_copy= do_copy_timestamp;               // Automatic timestamp
  414.       else if (to_field == to_field->table->next_number_field)
  415.         do_copy= do_copy_next_number;
  416.       else
  417.         do_copy= do_copy_not_null;
  418.     }
  419.   }
  420.   else if (to_field->real_maybe_null())
  421.   {
  422.     to_null_ptr= to->null_ptr;
  423.     to_bit= to->null_bit;
  424.     do_copy= do_copy_maybe_null;
  425.   }
  426.   else
  427.    do_copy=0;
  428.   if ((to->flags & BLOB_FLAG) && save)
  429.     do_copy2= do_save_blob;
  430.   else
  431.     do_copy2= get_copy_func(to,from);
  432.   if (!do_copy) // Not null
  433.     do_copy=do_copy2;
  434. }
  435. void (*Copy_field::get_copy_func(Field *to,Field *from))(Copy_field*)
  436. {
  437.   if (to->flags & BLOB_FLAG)
  438.   {
  439.     if (!(from->flags & BLOB_FLAG) || from->charset() != to->charset())
  440.       return do_conv_blob;
  441.     if (from_length != to_length ||
  442. to->table->db_low_byte_first != from->table->db_low_byte_first)
  443.     {
  444.       // Correct pointer to point at char pointer
  445.       to_ptr+=to_length - to->table->blob_ptr_size;
  446.       from_ptr+=from_length- from->table->blob_ptr_size;
  447.       return do_copy_blob;
  448.     }
  449.   }
  450.   else
  451.   {
  452.     // Check if identical fields
  453.     if (from->result_type() == STRING_RESULT)
  454.     {
  455.       if (to->real_type() != from->real_type() ||
  456.   to->table->db_low_byte_first != from->table->db_low_byte_first)
  457.       {
  458. if (from->real_type() == FIELD_TYPE_ENUM ||
  459.     from->real_type() == FIELD_TYPE_SET)
  460.   if (to->result_type() != STRING_RESULT)
  461.     return do_field_int; // Convert SET to number
  462. return do_field_string;
  463.       }
  464.       if (to->real_type() == FIELD_TYPE_ENUM ||
  465.   to->real_type() == FIELD_TYPE_SET)
  466.       {
  467. if (!to->eq_def(from))
  468.   return do_field_string;
  469.       }
  470.       else if (to->charset() != from->charset())
  471. return do_field_string;
  472.       else if (to->real_type() == FIELD_TYPE_VAR_STRING && to_length !=
  473.        from_length)
  474. return do_varstring;
  475.       else if (to_length < from_length)
  476. return (from->charset()->mbmaxlen == 1 ?
  477.                 do_cut_string : do_cut_string_complex);
  478.       else if (to_length > from_length)
  479. return do_expand_string;
  480.     }
  481.     else if (to->real_type() != from->real_type() ||
  482.      to_length != from_length ||
  483.      to->table->db_low_byte_first != from->table->db_low_byte_first)
  484.     {
  485.       if (to->real_type() == FIELD_TYPE_DECIMAL ||
  486.   to->result_type() == STRING_RESULT)
  487. return do_field_string;
  488.       if (to->result_type() == INT_RESULT)
  489. return do_field_int;
  490.       return do_field_real;
  491.     }
  492.     else
  493.     {
  494.       if (!to->eq_def(from) ||
  495.   to->table->db_low_byte_first != from->table->db_low_byte_first)
  496.       {
  497. if (to->real_type() == FIELD_TYPE_DECIMAL)
  498.   return do_field_string;
  499. if (to->result_type() == INT_RESULT)
  500.   return do_field_int;
  501. else
  502.   return do_field_real;
  503.       }
  504.     }
  505.   }
  506.     /* Eq fields */
  507.   switch (to_length) {
  508.   case 1: return do_field_1;
  509.   case 2: return do_field_2;
  510.   case 3: return do_field_3;
  511.   case 4: return do_field_4;
  512.   case 6: return do_field_6;
  513.   case 8: return do_field_8;
  514.   }
  515.   return do_field_eq;
  516. }
  517. /* Simple quick field convert that is called on insert */
  518. void field_conv(Field *to,Field *from)
  519. {
  520.   if (to->real_type() == from->real_type())
  521.   {
  522.     if (to->pack_length() == from->pack_length() &&
  523.         !(to->flags & UNSIGNED_FLAG && !(from->flags & UNSIGNED_FLAG)) &&
  524. to->real_type() != FIELD_TYPE_ENUM &&
  525. to->real_type() != FIELD_TYPE_SET &&
  526.         (to->real_type() != FIELD_TYPE_DECIMAL ||
  527.          (to->field_length == from->field_length &&
  528.           (((Field_num*) to)->dec == ((Field_num*) from)->dec))) &&
  529.         from->charset() == to->charset() &&
  530. to->table->db_low_byte_first == from->table->db_low_byte_first)
  531.     { // Identical fields
  532.       memcpy(to->ptr,from->ptr,to->pack_length());
  533.       return;
  534.     }
  535.   }
  536.   if (to->type() == FIELD_TYPE_BLOB)
  537.   { // Be sure the value is stored
  538.     Field_blob *blob=(Field_blob*) to;
  539.     from->val_str(&blob->value);
  540.     if (!blob->value.is_alloced() &&
  541. from->real_type() != FIELD_TYPE_STRING)
  542.       blob->value.copy();
  543.     blob->store(blob->value.ptr(),blob->value.length(),from->charset());
  544.     return;
  545.   }
  546.   if ((from->result_type() == STRING_RESULT &&
  547.        (to->result_type() == STRING_RESULT ||
  548. (from->real_type() != FIELD_TYPE_ENUM &&
  549.  from->real_type() != FIELD_TYPE_SET))) ||
  550.       to->type() == FIELD_TYPE_DECIMAL)
  551.   {
  552.     char buff[MAX_FIELD_WIDTH];
  553.     String result(buff,sizeof(buff),from->charset());
  554.     from->val_str(&result);
  555.     to->store(result.c_ptr_quick(),result.length(),from->charset());
  556.   }
  557.   else if (from->result_type() == REAL_RESULT)
  558.     to->store(from->val_real());
  559.   else
  560.     to->store(from->val_int());
  561. }