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