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 / item_strfunc.cpp < prev    next >
C/C++ Source or Header  |  2000-11-16  |  41KB  |  1,732 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. /* This file defines all string functions
  19. ** Warning: Some string functions doesn't always put and end-null on a String
  20. ** (This shouldn't be neaded)
  21. */
  22.  
  23. #ifdef __GNUC__
  24. #pragma implementation                // gcc: Class implementation
  25. #endif
  26.  
  27. #include "mysql_priv.h"
  28. #include "sql_acl.h"
  29. #include <m_ctype.h>
  30. #ifdef HAVE_CRYPT_H
  31. #include <crypt.h>
  32. #endif
  33.  
  34. #include "md5.h"
  35.  
  36. String empty_string("");
  37.  
  38. uint nr_of_decimals(const char *str)
  39. {
  40.   if ((str=strchr(str,'.')))
  41.   {
  42.     const char *start= ++str;
  43.     for ( ; isdigit(*str) ; str++) ;
  44.     return (uint) (str-start);
  45.   }
  46.   return 0;
  47. }
  48.  
  49. double Item_str_func::val()
  50. {
  51.   String *res;
  52.   res=val_str(&str_value);
  53.   return res ? atof(res->c_ptr()) : 0.0;
  54. }
  55.  
  56. longlong Item_str_func::val_int()
  57. {
  58.   String *res;
  59.   res=val_str(&str_value);
  60.   return res ? strtoll(res->c_ptr(),NULL,10) : (longlong) 0;
  61. }
  62.  
  63.  
  64. String *Item_func_md5::val_str(String *str)
  65. {
  66.   String * sptr= args[0]->val_str(str);
  67.   if (sptr)
  68.   {
  69.     MD5_CTX context;
  70.     unsigned char digest[16];
  71.  
  72.     null_value=0;
  73.     MD5Init (&context);
  74.     MD5Update (&context,(unsigned char *) sptr->ptr(), sptr->length());
  75.     MD5Final (digest, &context);
  76.     str->alloc(32);                // Ensure that memory is free
  77.     sprintf((char *) str->ptr(),
  78.         "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
  79.         digest[0], digest[1], digest[2], digest[3],
  80.         digest[4], digest[5], digest[6], digest[7],
  81.         digest[8], digest[9], digest[10], digest[11],
  82.         digest[12], digest[13], digest[14], digest[15]);
  83.     str->length((uint) 32);
  84.     return str;
  85.   }
  86.   null_value=1;
  87.   return 0;
  88. }
  89.  
  90.  
  91. void Item_func_md5::fix_length_and_dec()
  92. {
  93.    max_length=32;
  94. }
  95.  
  96. /*
  97. ** Concatinate args with the following premissess
  98. ** If only one arg which is ok, return value of arg
  99. ** Don't reallocate val_str() if not absolute necessary.
  100. */
  101.  
  102. String *Item_func_concat::val_str(String *str)
  103. {
  104.   String *res,*res2,*use_as_buff;
  105.   uint i;
  106.  
  107.   null_value=0;
  108.   if (!(res=args[0]->val_str(str)))
  109.     goto null;
  110.   use_as_buff= &tmp_value;
  111.   for (i=1 ; i < arg_count ; i++)
  112.   {
  113.     if (res->length() == 0)
  114.     {
  115.       if (!(res=args[i]->val_str(str)))
  116.     goto null;
  117.     }
  118.     else
  119.     {
  120.       if (!(res2=args[i]->val_str(use_as_buff)))
  121.     goto null;
  122.       if (res2->length() == 0)
  123.     continue;
  124.       if (res->length()+res2->length() > max_allowed_packet)
  125.     goto null;                // Error check
  126.       if (res->alloced_length() >= res->length()+res2->length())
  127.       {                        // Use old buffer
  128.     res->append(*res2);
  129.       }
  130.       else if (str->alloced_length() >= res->length()+res2->length())
  131.       {
  132.     if (str == res2)
  133.       str->replace(0,0,*res);
  134.     else
  135.     {
  136.       str->copy(*res);
  137.       str->append(*res2);
  138.     }
  139.     res=str;
  140.       }
  141.       else if (res == &tmp_value)
  142.       {
  143.     if (res->append(*res2))            // Must be a blob
  144.       goto null;
  145.       }
  146.       else if (res2 == &tmp_value)
  147.       {                        // This can happend only 1 time
  148.     if (tmp_value.replace(0,0,*res))
  149.       goto null;
  150.     res= &tmp_value;
  151.     use_as_buff=str;            // Put next arg here
  152.       }
  153.       else if (tmp_value.is_alloced() && res2->ptr() >= tmp_value.ptr() &&
  154.            res2->ptr() <= tmp_value.ptr() + tmp_value.alloced_length())
  155.       {
  156.     /*
  157.       This happens really seldom:
  158.       In this case res2 is sub string of tmp_value.  We will
  159.       now work in place in tmp_value to set it to res | res2
  160.     */
  161.     /* Chop the last characters in tmp_value that isn't in res2 */
  162.     tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
  163.              res2->length());
  164.     /* Place res2 at start of tmp_value, remove chars before res2 */
  165.     if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
  166.                   *res))
  167.       goto null;
  168.     res= &tmp_value;
  169.     use_as_buff=str;            // Put next arg here
  170.       }
  171.       else
  172.       {                        // Two big const strings
  173.     if (tmp_value.alloc(max_length) ||
  174.         tmp_value.copy(*res) ||
  175.         tmp_value.append(*res2))
  176.       goto null;
  177.     res= &tmp_value;
  178.     use_as_buff=str;
  179.       }
  180.     }
  181.   }
  182.   return res;
  183.  
  184. null:
  185.   null_value=1;
  186.   return 0;
  187. }
  188.  
  189.  
  190. void Item_func_concat::fix_length_and_dec()
  191. {
  192.   max_length=0;
  193.   for (uint i=0 ; i < arg_count ; i++)
  194.     max_length+=args[i]->max_length;
  195.   if (max_length > MAX_BLOB_WIDTH)
  196.   {
  197.     max_length=MAX_BLOB_WIDTH;
  198.     maybe_null=1;
  199.   }
  200. }
  201.  
  202.  
  203.  
  204. /* 
  205. ** concat with separator. First arg is the separator
  206. ** concat_ws takes at least two arguments.
  207. */
  208.  
  209. String *Item_func_concat_ws::val_str(String *str)
  210. {
  211.   char tmp_str_buff[10];
  212.   String tmp_sep_str(tmp_str_buff, sizeof(tmp_str_buff)),
  213.          *sep_str, *res, *res2,*use_as_buff;
  214.   uint i;
  215.  
  216.   null_value=0;
  217.   if (!(sep_str= separator->val_str(&tmp_sep_str)))
  218.     goto null;
  219.  
  220.   use_as_buff= &tmp_value;
  221.   str->length(0);
  222.   res=str;
  223.  
  224.   // Skip until non-null and non-empty argument is found.
  225.   // If not, return the empty string
  226.   for (i=0; !(res= args[i]->val_str(str)) || !res->length(); i++)
  227.   {
  228.     if ((i + 1) == arg_count)
  229.       return &empty_string;
  230.   }
  231.  
  232.   for (i++; i < arg_count ; i++)
  233.   {
  234.     if (!(res2= args[i]->val_str(use_as_buff)) || !res2->length())
  235.       continue;
  236.     else
  237.     {
  238.       if (res->length() + sep_str->length() + res2->length() >
  239.       max_allowed_packet)
  240.     goto null;                // Error check
  241.       if (res->alloced_length() >=
  242.       res->length() + sep_str->length() + res2->length())
  243.       {                        // Use old buffer
  244.     res->append(*sep_str);                  // res->length() > 0 always
  245.     res->append(*res2);
  246.     use_as_buff= &tmp_value;
  247.       }
  248.       else if (str->alloced_length() >=
  249.            res->length() + sep_str->length() + res2->length())
  250.       {
  251.     str->copy(*res);
  252.     str->append(*sep_str);
  253.     str->append(*res2);
  254.     res=str;
  255.     use_as_buff= &tmp_value;
  256.       }
  257.       else if (res == &tmp_value)
  258.       {
  259.     if ((res->length() && res->append(*sep_str)) || res->append(*res2))
  260.       goto null; // Must be a blob
  261.       }
  262.       else if (tmp_value.is_alloced() && res2->ptr() >= tmp_value.ptr() &&
  263.                res2->ptr() <= tmp_value.ptr() + tmp_value.alloced_length())
  264.       {
  265.         /*
  266.           This happens really seldom:
  267.           In this case res2 is sub string of tmp_value.  We will
  268.           now work in place in tmp_value to set it to res | res2
  269.         */
  270.         /* Chop the last characters in tmp_value that isn't in res2 */
  271.         tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
  272.                  res2->length());
  273.         /* Place res2 at start of tmp_value, remove chars before res2 */
  274.     if (res->append(*sep_str))
  275.       goto null;
  276.         if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
  277.                       *res))
  278.           goto null;
  279.         res= &tmp_value;
  280.         use_as_buff=str;            // Put next arg here
  281.       }
  282.       else
  283.       {                        // Two big const strings
  284.     if (tmp_value.alloc(max_length) ||
  285.         tmp_value.copy(*res) ||
  286.         tmp_value.append(*sep_str) ||
  287.         tmp_value.append(*res2))
  288.       goto null;
  289.     res= &tmp_value;
  290.     use_as_buff=str;
  291.       }
  292.     }
  293.   }
  294.   return res;
  295.  
  296. null:
  297.   null_value=1;
  298.   return 0;
  299. }
  300.  
  301.  
  302. void Item_func_concat_ws::fix_length_and_dec()
  303. {
  304.   max_length=0;
  305.   for (uint i=0 ; i < arg_count ; i++)
  306.     max_length+=args[i]->max_length;
  307.   if (max_length > MAX_BLOB_WIDTH)
  308.   {
  309.     max_length=MAX_BLOB_WIDTH;
  310.     maybe_null=1;
  311.   }
  312.   used_tables_cache|=separator->used_tables();
  313.   const_item_cache&=separator->const_item();
  314. }
  315.  
  316. void Item_func_concat_ws::update_used_tables()
  317. {
  318.   Item_func::update_used_tables();
  319.   separator->update_used_tables();
  320.   used_tables_cache|=separator->used_tables();
  321.   const_item_cache&=separator->const_item();
  322. }
  323.  
  324.  
  325. String *Item_func_reverse::val_str(String *str)
  326. {
  327.   String *res = args[0]->val_str(str);
  328.   char *ptr,*end;
  329.  
  330.   if ((null_value=args[0]->null_value))
  331.     return 0;
  332.   /* An empty string is a special case as the string pointer may be null */
  333.   if (!res->length())
  334.     return &empty_string;
  335.   res=copy_if_not_alloced(str,res,res->length());
  336.   ptr = (char *) res->ptr();
  337.   end=ptr+res->length();
  338. #ifdef USE_MB
  339.   if (use_mb(default_charset_info) && !binary)
  340.   {
  341.     String tmpstr;
  342.     tmpstr.copy(*res);
  343.     char *tmp = (char *) tmpstr.ptr() + tmpstr.length();
  344.     register uint32 l;
  345.     while (ptr < end)
  346.     {
  347.       if ((l=my_ismbchar(default_charset_info, ptr,end)))
  348.         tmp-=l, memcpy(tmp,ptr,l), ptr+=l;
  349.       else
  350.         *--tmp=*ptr++;
  351.     }
  352.     memcpy((char *) res->ptr(),(char *) tmpstr.ptr(), res->length());
  353.   }
  354.   else
  355. #endif /* USE_MB */
  356.   {
  357.     char tmp;
  358.     while (ptr < end)
  359.     {
  360.       tmp=*ptr;
  361.       *ptr++=*--end;
  362.       *end=tmp;
  363.     }
  364.   }
  365.   return res;
  366. }
  367.  
  368.  
  369. void Item_func_reverse::fix_length_and_dec()
  370. {
  371.   max_length = args[0]->max_length;
  372. }
  373.  
  374. /*
  375. ** Replace all occurences of string2 in string1 with string3.
  376. ** Don't reallocate val_str() if not neaded
  377. */
  378.  
  379. /* TODO: Fix that this works with binary strings when using USE_MB */
  380.  
  381. String *Item_func_replace::val_str(String *str)
  382. {
  383.   String *res,*res2,*res3;
  384.   int offset=0;
  385.   uint from_length,to_length;
  386.   bool alloced=0;
  387. #ifdef USE_MB
  388.   const char *ptr,*end,*strend,*search,*search_end;
  389.   register uint32 l;
  390. #endif
  391.  
  392.   null_value=0;
  393.   res=args[0]->val_str(str);
  394.   if (args[0]->null_value)
  395.     goto null;
  396.   res2=args[1]->val_str(&tmp_value);
  397.   if (args[1]->null_value)
  398.     goto null;
  399.  
  400.   if (res2->length() == 0)
  401.     return res;
  402. #ifndef USE_MB
  403.   if ((offset=res->strstr(*res2)) < 0)
  404.     return res;
  405. #else
  406.   if (!use_mb(default_charset_info) && (offset=res->strstr(*res2)) < 0)
  407.     return res;
  408. #endif
  409.   if (!(res3=args[2]->val_str(&tmp_value2)))
  410.     goto null;
  411.   from_length= res2->length();
  412.   to_length=   res3->length();
  413.  
  414. #ifdef USE_MB
  415.   if (use_mb(default_charset_info))
  416.   {
  417.     search=res2->ptr();
  418.     search_end=search+from_length;
  419. redo:
  420.     ptr=res->ptr()+offset;
  421.     strend=res->ptr()+res->length();
  422.     end=strend-from_length+1;
  423.     while (ptr < end)
  424.     {
  425.         if (*ptr == *search)
  426.         {
  427.           register char *i,*j;
  428.           i=(char*) ptr+1; j=(char*) search+1;
  429.           while (j != search_end)
  430.             if (*i++ != *j++) goto skipp;
  431.           offset= (int) (ptr-res->ptr());
  432.           if (res->length()-from_length + to_length > max_allowed_packet)
  433.             goto null;
  434.           if (!alloced)
  435.           {
  436.             alloced=1;
  437.             res=copy_if_not_alloced(str,res,res->length()+to_length);
  438.           }
  439.           res->replace((uint) offset,from_length,*res3);
  440.           goto redo;
  441.         }
  442. skipp:
  443.         if ((l=my_ismbchar(default_charset_info, ptr,strend))) ptr+=l;
  444.         else ++ptr;
  445.     }
  446.   }
  447.   else
  448. #endif /* USE_MB */
  449.     do
  450.     {
  451.       if (res->length()-from_length + to_length > max_allowed_packet)
  452.         goto null;
  453.       if (!alloced)
  454.       {
  455.         alloced=1;
  456.         res=copy_if_not_alloced(str,res,res->length()+to_length);
  457.       }
  458.       res->replace((uint) offset,from_length,*res3);
  459.       offset+=(int) to_length;
  460.     }
  461.     while ((offset=res->strstr(*res2,(uint) offset)) >= 0);
  462.   return res;
  463.  
  464. null:
  465.   null_value=1;
  466.   return 0;
  467. }
  468.  
  469.  
  470. void Item_func_replace::fix_length_and_dec()
  471. {
  472.   max_length=args[0]->max_length;
  473.   int diff=(int) (args[2]->max_length - args[1]->max_length);
  474.   if (diff > 0 && args[1]->max_length)
  475.   {                        // Calculate of maxreplaces
  476.     max_length= max_length/args[1]->max_length;
  477.     max_length= (max_length+1)*(uint) diff;
  478.   }
  479.   if (max_length > MAX_BLOB_WIDTH)
  480.   {
  481.     max_length=MAX_BLOB_WIDTH;
  482.     maybe_null=1;
  483.   }
  484. }
  485.  
  486.  
  487. String *Item_func_insert::val_str(String *str)
  488. {
  489.   String *res,*res2;
  490.   uint start,length;
  491.  
  492.   null_value=0;
  493.   res=args[0]->val_str(str);
  494.   res2=args[3]->val_str(&tmp_value);
  495.   start=(uint) args[1]->val_int()-1;
  496.   length=(uint) args[2]->val_int();
  497.   if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
  498.       args[3]->null_value)
  499.     goto null; /* purecov: inspected */
  500. #ifdef USE_MB
  501.   if (use_mb(default_charset_info) && !args[0]->binary)
  502.   {
  503.     start=res->charpos(start);
  504.     length=res->charpos(length,start);
  505.   }
  506. #endif
  507.   if (start > res->length()+1)
  508.     return res;                    // Wrong param; skipp insert
  509.   if (length > res->length()-start)
  510.     length=res->length()-start;
  511.   if (res->length() - length + res2->length() > max_allowed_packet)
  512.     goto null;                    // OOM check
  513.   res=copy_if_not_alloced(str,res,res->length());
  514.   res->replace(start,length,*res2);
  515.   return res;
  516. null:
  517.   null_value=1;
  518.   return 0;
  519. }
  520.  
  521.  
  522. void Item_func_insert::fix_length_and_dec()
  523. {
  524.   max_length=args[0]->max_length+args[3]->max_length;
  525.   if (max_length > MAX_BLOB_WIDTH)
  526.   {
  527.     max_length=MAX_BLOB_WIDTH;
  528.     maybe_null=1;
  529.   }
  530. }
  531.  
  532.  
  533. String *Item_func_lcase::val_str(String *str)
  534. {
  535.   String *res;
  536.   if (!(res=args[0]->val_str(str)))
  537.   {
  538.     null_value=1; /* purecov: inspected */
  539.     return 0; /* purecov: inspected */
  540.   }
  541.   null_value=0;
  542.   res=copy_if_not_alloced(str,res,res->length());
  543.   res->casedn();
  544.   return res;
  545. }
  546.  
  547.  
  548. String *Item_func_ucase::val_str(String *str)
  549. {
  550.   String *res;
  551.   if (!(res=args[0]->val_str(str)))
  552.   {
  553.     null_value=1; /* purecov: inspected */
  554.     return 0; /* purecov: inspected */
  555.   }
  556.   null_value=0;
  557.   res=copy_if_not_alloced(str,res,res->length());
  558.   res->caseup();
  559.   return res;
  560. }
  561.  
  562.  
  563. String *Item_func_left::val_str(String *str)
  564. {
  565.   String *res  =args[0]->val_str(str);
  566.   long length  =(long) args[1]->val_int();
  567.  
  568.   if ((null_value=args[0]->null_value))
  569.     return 0;
  570.   if (length <= 0)
  571.     return &empty_string;
  572. #ifdef USE_MB
  573.   if (use_mb(default_charset_info) && !binary)
  574.     length = res->charpos(length);
  575. #endif
  576.   if (res->length() > (ulong) length)
  577.   {                        // Safe even if const arg
  578.     if (!res->alloced_length())
  579.     {                        // Don't change const str
  580.       str_value= *res;                // Not malloced string
  581.       res= &str_value;
  582.     }
  583.     res->length((uint) length);
  584.   }
  585.   return res;
  586. }
  587.  
  588.  
  589. void Item_str_func::left_right_max_length()
  590. {
  591.   max_length=args[0]->max_length;
  592.   if (args[1]->const_item())
  593.   {
  594.     int length=(int) args[1]->val_int();
  595.     if (length <= 0)
  596.       max_length=0;
  597.     else
  598.       set_if_smaller(max_length,(uint) length);
  599.   }
  600. }
  601.  
  602.  
  603. void Item_func_left::fix_length_and_dec()
  604. {
  605.   left_right_max_length();
  606. }
  607.  
  608.  
  609. String *Item_func_right::val_str(String *str)
  610. {
  611.   String *res  =args[0]->val_str(str);
  612.   long length  =(long) args[1]->val_int();
  613.  
  614.   if ((null_value=args[0]->null_value))
  615.     return 0; /* purecov: inspected */
  616.   if (length <= 0)
  617.     return &empty_string; /* purecov: inspected */
  618.   if (res->length() <= (uint) length)
  619.     return res; /* purecov: inspected */
  620. #ifdef USE_MB
  621.   if (use_mb(default_charset_info) && !binary)
  622.   {
  623.     uint start=res->numchars()-(uint) length;
  624.     if (start<=0) return res;
  625.     start=res->charpos(start);
  626.     tmp_value.set(*res,start,res->length()-start);
  627.   }
  628.   else
  629. #endif
  630.   {
  631.     tmp_value.set(*res,(res->length()- (uint) length),(uint) length);
  632.   }
  633.   return &tmp_value;
  634. }
  635.  
  636.  
  637. void Item_func_right::fix_length_and_dec()
  638. {
  639.   left_right_max_length();
  640. }
  641.  
  642.  
  643. String *Item_func_substr::val_str(String *str)
  644. {
  645.   String *res  = args[0]->val_str(str);
  646.   int32 start    = (int32) args[1]->val_int()-1;
  647.   int32 length    = arg_count == 3 ? (int32) args[2]->val_int() : INT_MAX32;
  648.   int32 tmp_length;
  649.  
  650.   if ((null_value=(args[0]->null_value || args[1]->null_value ||
  651.            (arg_count == 3 && args[2]->null_value))))
  652.     return 0; /* purecov: inspected */
  653. #ifdef USE_MB
  654.   if (use_mb(default_charset_info) && !binary)
  655.   {
  656.     start=res->charpos(start);
  657.     length=res->charpos(length,start);
  658.   }
  659. #endif
  660.   if (start < 0 || (uint) start+1 > res->length() || length <= 0)
  661.     return &empty_string;
  662.  
  663.   tmp_length=(int32) res->length()-start;
  664.   length=min(length,tmp_length);
  665.  
  666.   if (!start && res->length() == (uint) length)
  667.     return res;
  668.   tmp_value.set(*res,(uint) start,(uint) length);
  669.   return &tmp_value;
  670. }
  671.  
  672.  
  673. void Item_func_substr::fix_length_and_dec()
  674. {
  675.   max_length=args[0]->max_length;
  676.  
  677.   if (args[1]->const_item())
  678.   {
  679.     int32 start=(int32) args[1]->val_int()-1;
  680.     if (start < 0 || start >= (int32) max_length)
  681.       max_length=0; /* purecov: inspected */
  682.     else
  683.       max_length-= (uint) start;
  684.   }
  685.   if (arg_count == 3 && args[2]->const_item())
  686.   {
  687.     int32 length= (int32) args[2]->val_int();
  688.     if (length <= 0)
  689.       max_length=0; /* purecov: inspected */
  690.     else
  691.       set_if_smaller(max_length,(uint) length);
  692.   }
  693. }
  694.  
  695.  
  696. String *Item_func_substr_index::val_str(String *str)
  697. {
  698.   String *res =args[0]->val_str(str);
  699.   String *delimeter =args[1]->val_str(&tmp_value);
  700.   int32 count = (int32) args[2]->val_int();
  701.   uint offset;
  702.  
  703.   if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
  704.   {                    // string and/or delim are null
  705.     null_value=1;
  706.     return 0;
  707.   }
  708.   null_value=0;
  709.   uint delimeter_length=delimeter->length();
  710.   if (!res->length() || !delimeter_length || !count)
  711.     return &empty_string;        // Wrong parameters
  712.  
  713. #ifdef USE_MB
  714.   if (use_mb(default_charset_info) && !binary)
  715.   {
  716.     const char *ptr=res->ptr();
  717.     const char *strend = ptr+res->length();
  718.     const char *end=strend-delimeter_length+1;
  719.     const char *search=delimeter->ptr();
  720.     const char *search_end=search+delimeter_length;
  721.     int32 n=0,c=count,pass;
  722.     register uint32 l;
  723.     for (pass=(count>0);pass<2;++pass)
  724.     {
  725.       while (ptr < end)
  726.       {
  727.         if (*ptr == *search)
  728.         {
  729.       register char *i,*j;
  730.       i=(char*) ptr+1; j=(char*) search+1;
  731.       while (j != search_end)
  732.         if (*i++ != *j++) goto skipp;
  733.       if (pass==0) ++n;
  734.       else if (!--c) break;
  735.       ptr+=delimeter_length;
  736.       continue;
  737.     }
  738.     skipp:
  739.         if ((l=my_ismbchar(default_charset_info, ptr,strend))) ptr+=l;
  740.         else ++ptr;
  741.       } /* either not found or got total number when count<0 */
  742.       if (pass == 0) /* count<0 */
  743.       {
  744.         c+=n+1;
  745.         if (c<=0) return res; /* not found, return original string */
  746.         ptr=res->ptr();
  747.       }
  748.       else
  749.       {
  750.         if (c) return res; /* Not found, return original string */
  751.         if (count>0) /* return left part */
  752.         {
  753.       tmp_value.set(*res,0,(ulong) (ptr-res->ptr()));
  754.         }
  755.         else /* return right part */
  756.         {
  757.       ptr+=delimeter_length;
  758.       tmp_value.set(*res,(ulong) (ptr-res->ptr()), (ulong) (strend-ptr));
  759.         }
  760.       }
  761.     }
  762.   }
  763.   else
  764. #endif /* USE_MB */
  765.   {
  766.     if (count > 0)
  767.     {                    // start counting from the beginning
  768.       for (offset=0 ;; offset+=delimeter_length)
  769.       {
  770.     if ((int) (offset=res->strstr(*delimeter,offset)) < 0)
  771.       return res;            // Didn't find, return org string
  772.     if (!--count)
  773.     {
  774.       tmp_value.set(*res,0,offset);
  775.       break;
  776.     }
  777.       }
  778.     }
  779.     else
  780.     {                    // Start counting at end
  781.       for (offset=res->length() ; ; offset-=delimeter_length-1)
  782.       {
  783.     if ((int) (offset=res->strrstr(*delimeter,offset)) < 0)
  784.       return res;            // Didn't find, return org string
  785.     if (!++count)
  786.     {
  787.       offset+=delimeter_length;
  788.       tmp_value.set(*res,offset,res->length()- offset);
  789.       break;
  790.     }
  791.       }
  792.     }
  793.   }
  794.   return (&tmp_value);
  795. }
  796.  
  797. /*
  798. ** The trim functions are extension to ANSI SQL because they trim substrings
  799. ** They ltrim() and rtrim() functions are optimized for 1 byte strings
  800. ** They also return the original string if possible, else they return
  801. ** a substring that points at the original string.
  802. */
  803.  
  804.  
  805. String *Item_func_ltrim::val_str(String *str)
  806. {
  807.   String *res  =args[0]->val_str(str);
  808.   if ((null_value=args[0]->null_value))
  809.     return 0;                    /* purecov: inspected */
  810.   char buff[MAX_FIELD_WIDTH];
  811.   String tmp(buff,sizeof(buff));
  812.   String *remove_str=args[1]->val_str(&tmp);
  813.   uint remove_length;
  814.   LINT_INIT(remove_length);
  815.  
  816.   if (!remove_str || (remove_length=remove_str->length()) == 0 ||
  817.       remove_length > res->length())
  818.     return res;
  819.  
  820.   char *ptr=(char*) res->ptr();
  821.   char *end=ptr+res->length();
  822.   if (remove_length == 1)
  823.   {
  824.     char chr=(*remove_str)[0];
  825.     while (ptr != end && *ptr == chr)
  826.       ptr++;
  827.   }
  828.   else
  829.   {
  830.     const char *r_ptr=remove_str->ptr();
  831.     end-=remove_length;
  832.     while (ptr < end && !memcmp(ptr,r_ptr,remove_length))
  833.       ptr+=remove_length;
  834.     end+=remove_length;
  835.   }
  836.   if (ptr == res->ptr())
  837.     return res;
  838.   tmp_value.set(*res,(uint) (ptr - res->ptr()),(uint) (end-ptr));
  839.   return &tmp_value;
  840. }
  841.  
  842.  
  843. String *Item_func_rtrim::val_str(String *str)
  844. {
  845.   String *res  =args[0]->val_str(str);
  846.   if ((null_value=args[0]->null_value))
  847.     return 0; /* purecov: inspected */
  848.   char buff[MAX_FIELD_WIDTH];
  849.   String tmp(buff,sizeof(buff));
  850.   String *remove_str=args[1]->val_str(&tmp);
  851.   uint remove_length;
  852.   LINT_INIT(remove_length);
  853.  
  854.   if (!remove_str || (remove_length=remove_str->length()) == 0 ||
  855.       remove_length > res->length())
  856.     return res;
  857.  
  858.   char *ptr=(char*) res->ptr();
  859.   char *end=ptr+res->length();
  860. #ifdef USE_MB
  861.   char *p=ptr;
  862.   register uint32 l;
  863. #endif
  864.   if (remove_length == 1)
  865.   {
  866.     char chr=(*remove_str)[0];
  867. #ifdef USE_MB
  868.     if (use_mb(default_charset_info) && !binary)
  869.     {
  870.       while (ptr < end)
  871.       {
  872.     if ((l=my_ismbchar(default_charset_info, ptr,end))) ptr+=l,p=ptr;
  873.     else ++ptr;
  874.       }
  875.       ptr=p;
  876.     }
  877. #endif
  878.     while (ptr != end  && end[-1] == chr)
  879.       end--;
  880.   }
  881.   else
  882.   {
  883.     const char *r_ptr=remove_str->ptr();
  884. #ifdef USE_MB
  885.     if (use_mb(default_charset_info) && !binary)
  886.     {
  887.   loop:
  888.       while (ptr + remove_length < end)
  889.       {
  890.     if ((l=my_ismbchar(default_charset_info, ptr,end))) ptr+=l;
  891.     else ++ptr;
  892.       }
  893.       if (ptr + remove_length == end && !memcmp(ptr,r_ptr,remove_length))
  894.       {
  895.     end-=remove_length;
  896.     ptr=p;
  897.     goto loop;
  898.       }
  899.     }
  900.     else
  901. #endif /* USE_MB */
  902.     {
  903.       while (ptr + remove_length < end &&
  904.          !memcmp(end-remove_length,r_ptr,remove_length))
  905.     end-=remove_length;
  906.     }
  907.   }
  908.   if (end == res->ptr()+res->length())
  909.     return res;
  910.   tmp_value.set(*res,0,(uint) (end-res->ptr()));
  911.   return &tmp_value;
  912. }
  913.  
  914.  
  915. String *Item_func_trim::val_str(String *str)
  916. {
  917.   String *res  =args[0]->val_str(str);
  918.   if ((null_value=args[0]->null_value))
  919.     return 0;                    /* purecov: inspected */
  920.   char buff[MAX_FIELD_WIDTH];
  921.   String tmp(buff,sizeof(buff));
  922.   String *remove_str=args[1]->val_str(&tmp);
  923.   uint remove_length;
  924.   LINT_INIT(remove_length);
  925.  
  926.   if (!remove_str || (remove_length=remove_str->length()) == 0 ||
  927.       remove_length > res->length())
  928.     return res;
  929.  
  930.   char *ptr=(char*) res->ptr();
  931.   char *end=ptr+res->length();
  932.   const char *r_ptr=remove_str->ptr();
  933.   while (ptr+remove_length < end && !memcmp(ptr,r_ptr,remove_length))
  934.     ptr+=remove_length;
  935. #ifdef USE_MB
  936.   if (use_mb(default_charset_info) && !binary)
  937.   {
  938.     char *p=ptr;
  939.     register uint32 l;
  940.  loop:
  941.     while (ptr + remove_length < end)
  942.     {
  943.       if ((l=my_ismbchar(default_charset_info, ptr,end))) ptr+=l;
  944.       else ++ptr;
  945.     }
  946.     if (ptr + remove_length == end && !memcmp(ptr,r_ptr,remove_length))
  947.     {
  948.       end-=remove_length;
  949.       ptr=p;
  950.       goto loop;
  951.     }
  952.     ptr=p;
  953.   }
  954.   else
  955. #endif /* USE_MB */
  956.   {
  957.     while (ptr + remove_length < end &&
  958.        !memcmp(end-remove_length,r_ptr,remove_length))
  959.       end-=remove_length;
  960.   }
  961.   if (ptr == res->ptr() && end == ptr+res->length())
  962.     return res;
  963.   tmp_value.set(*res,(uint) (ptr - res->ptr()),(uint) (end-ptr));
  964.   return &tmp_value;
  965. }
  966.  
  967.  
  968. String *Item_func_password::val_str(String *str)
  969. {
  970.   String *res  =args[0]->val_str(str);
  971.   if ((null_value=args[0]->null_value))
  972.     return 0;
  973.   if (res->length() == 0)
  974.     return &empty_string;
  975.   make_scrambled_password(tmp_value,res->c_ptr());
  976.   str->set(tmp_value,16);
  977.   return str;
  978. }
  979.  
  980. #define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
  981.  
  982. String *Item_func_encrypt::val_str(String *str)
  983. {
  984.   String *res  =args[0]->val_str(str);
  985.  
  986. #ifdef HAVE_CRYPT
  987.   char salt[3],*salt_ptr;
  988.   if ((null_value=args[0]->null_value))
  989.     return 0;
  990.   if (res->length() == 0)
  991.     return &empty_string;
  992.  
  993.   if (arg_count == 1)
  994.   {                    // generate random salt
  995.     time_t timestamp=current_thd->query_start();
  996.     salt[0] = bin_to_ascii(timestamp & 0x3f);
  997.     salt[1] = bin_to_ascii((timestamp >> 5) & 0x3f);
  998.     salt[2] = 0;
  999.     salt_ptr=salt;
  1000.   }
  1001.   else
  1002.   {                    // obtain salt from the first two bytes
  1003.     String *salt_str=args[1]->val_str(&tmp_value);
  1004.     if ((null_value= (args[1]->null_value || salt_str->length() < 2)))
  1005.       return 0;
  1006.     salt_ptr= salt_str->c_ptr();
  1007.   }
  1008.   pthread_mutex_lock(&LOCK_crypt);
  1009.   char *tmp=crypt(res->c_ptr(),salt_ptr);
  1010.   str->set(tmp,(uint) strlen(tmp));
  1011.   str->copy();
  1012.   pthread_mutex_unlock(&LOCK_crypt);
  1013.   return str;
  1014. #else
  1015.   null_value=1;
  1016.   return 0;
  1017. #endif    /* HAVE_CRYPT */
  1018. }
  1019.  
  1020. void Item_func_encode::fix_length_and_dec()
  1021. {
  1022.   max_length=args[0]->max_length;
  1023.   maybe_null=args[0]->maybe_null;
  1024. }
  1025.  
  1026. String *Item_func_encode::val_str(String *str)
  1027. {
  1028.   String *res;
  1029.   if (!(res=args[0]->val_str(str)))
  1030.   {
  1031.     null_value=1; /* purecov: inspected */
  1032.     return 0; /* purecov: inspected */
  1033.   }
  1034.   null_value=0;
  1035.   res=copy_if_not_alloced(str,res,res->length());
  1036.   sql_crypt.init();
  1037.   sql_crypt.encode((char*) res->ptr(),res->length());
  1038.   return res;
  1039. }
  1040.  
  1041. String *Item_func_decode::val_str(String *str)
  1042. {
  1043.   String *res;
  1044.   if (!(res=args[0]->val_str(str)))
  1045.   {
  1046.     null_value=1; /* purecov: inspected */
  1047.     return 0; /* purecov: inspected */
  1048.   }
  1049.   null_value=0;
  1050.   res=copy_if_not_alloced(str,res,res->length());
  1051.   sql_crypt.init();
  1052.   sql_crypt.decode((char*) res->ptr(),res->length());
  1053.   return res;
  1054. }
  1055.  
  1056.  
  1057. String *Item_func_database::val_str(String *str)
  1058. {
  1059.   if (!current_thd->db)
  1060.     str->length(0);
  1061.   else
  1062.     str->set((const char*) current_thd->db,(uint) strlen(current_thd->db));
  1063.   return str;
  1064. }
  1065.  
  1066. String *Item_func_user::val_str(String *str)
  1067. {
  1068.   THD *thd=current_thd;
  1069.   if (str->copy((const char*) thd->user,(uint) strlen(thd->user)) ||
  1070.       str->append('@') ||
  1071.       str->append(thd->host ? thd->host : thd->ip ? thd->ip : ""))
  1072.     return &empty_string;
  1073.   return str;
  1074. }
  1075.  
  1076. void Item_func_soundex::fix_length_and_dec()
  1077. {
  1078.   max_length=args[0]->max_length;
  1079.   set_if_bigger(max_length,4);
  1080. }
  1081.  
  1082.  
  1083.   /*
  1084.     If alpha, map input letter to soundex code.
  1085.     If not alpha and remove_garbage is set then skipp to next char
  1086.     else return 0
  1087.     */
  1088.  
  1089. extern "C" {
  1090. extern char *soundex_map;        // In mysys/static.c
  1091. }
  1092.  
  1093. static char get_scode(char *ptr)
  1094. {
  1095.   uchar ch=toupper(*ptr);
  1096.   if (ch < 'A' || ch > 'Z')
  1097.   {
  1098.                     // Thread extended alfa (country spec)
  1099.     return '0';                // as vokal
  1100.   }
  1101.   return(soundex_map[ch-'A']);
  1102. }
  1103.  
  1104.  
  1105. String *Item_func_soundex::val_str(String *str)
  1106. {
  1107.   String *res  =args[0]->val_str(str);
  1108.   char last_ch,ch;
  1109.   if ((null_value=args[0]->null_value))
  1110.     return 0; /* purecov: inspected */
  1111.  
  1112.   if (str_value.alloc(max(res->length(),4)))
  1113.     return str; /* purecov: inspected */
  1114.   char *to= (char *) str_value.ptr();
  1115.   char *from= (char *) res->ptr(), *end=from+res->length();
  1116.  
  1117.   while (from != end && isspace(*from)) // Skipp pre-space
  1118.     from++; /* purecov: inspected */
  1119.   if (from == end)
  1120.     return &empty_string;        // No alpha characters.
  1121.   *to++ = toupper(*from);        // Copy first letter
  1122.   last_ch = get_scode(from);        // code of the first letter
  1123.                     // for the first 'double-letter check.
  1124.                     // Loop on input letters until
  1125.                     // end of input (null) or output
  1126.                     // letter code count = 3
  1127.   for (from++ ; from < end ; from++)
  1128.   {
  1129.     if (!isalpha(*from))
  1130.       continue;
  1131.     ch=get_scode(from);
  1132.     if ((ch != '0') && (ch != last_ch)) // if not skipped or double
  1133.     {
  1134.        *to++ = ch;            // letter, copy to output
  1135.        last_ch = ch;            // save code of last input letter
  1136.     }                    // for next double-letter check
  1137.   }
  1138.   for (end=(char*) str_value.ptr()+4 ; to < end ; to++)
  1139.     *to = '0';
  1140.   *to=0;                // end string
  1141.   str_value.length((uint) (to-str_value.ptr()));
  1142.   return &str_value;
  1143. }
  1144.  
  1145.  
  1146. /*
  1147. ** Change a number to format '3,333,333,333.000'
  1148. ** This should be 'internationalized' sometimes.
  1149. */
  1150.  
  1151. Item_func_format::Item_func_format(Item *org,int dec) :Item_str_func(org)
  1152. {
  1153.   decimals=(uint) set_zone(dec,0,30);
  1154. }
  1155.  
  1156.  
  1157. String *Item_func_format::val_str(String *str)
  1158. {
  1159.   double nr    =args[0]->val();
  1160.   uint32 diff,length,str_length;
  1161.   uint dec;
  1162.   if ((null_value=args[0]->null_value))
  1163.     return 0; /* purecov: inspected */
  1164.   dec= decimals ? decimals+1 : 0;
  1165.   str->set(nr,decimals);
  1166.   str_length=str->length();
  1167.   if (nr < 0)
  1168.     str_length--;                // Don't count sign
  1169.   length=str->length()+(diff=(str_length- dec-1)/3);
  1170.   if (diff)
  1171.   {
  1172.     char *tmp,*pos;
  1173.     str=copy_if_not_alloced(&tmp_str,str,length);
  1174.     str->length(length);
  1175.     tmp=(char*) str->ptr()+length - dec-1;
  1176.     for (pos=(char*) str->ptr()+length ; pos != tmp; pos--)
  1177.       pos[0]=pos[- (int) diff];
  1178.     while (diff)
  1179.     {
  1180.       pos[0]=pos[-(int) diff]; pos--;
  1181.       pos[0]=pos[-(int) diff]; pos--;
  1182.       pos[0]=pos[-(int) diff]; pos--;
  1183.       pos[0]=',';
  1184.       pos--;
  1185.       diff--;
  1186.     }
  1187.   }
  1188.   return str;
  1189. }
  1190.  
  1191.  
  1192. void Item_func_elt::fix_length_and_dec()
  1193. {
  1194.   max_length=0;
  1195.   decimals=0;
  1196.   for (uint i=1 ; i < arg_count ; i++)
  1197.   {
  1198.     set_if_bigger(max_length,args[i]->max_length);
  1199.     set_if_bigger(decimals,args[i]->decimals);
  1200.   }
  1201.   maybe_null=1;                    // NULL if wrong first arg
  1202.   used_tables_cache|=item->used_tables();
  1203.   const_item_cache&=item->const_item();
  1204. }
  1205.  
  1206.  
  1207. void Item_func_elt::update_used_tables()
  1208. {
  1209.   Item_func::update_used_tables();
  1210.   item->update_used_tables();
  1211.   used_tables_cache|=item->used_tables();
  1212.   const_item_cache&=item->const_item();
  1213. }
  1214.  
  1215.  
  1216. double Item_func_elt::val()
  1217. {
  1218.   uint tmp;
  1219.   if ((tmp=(uint) item->val_int()) == 0 || tmp > arg_count)
  1220.   {
  1221.     null_value=1;
  1222.     return 0.0;
  1223.   }
  1224.   null_value=0;
  1225.   return args[tmp-1]->val();
  1226. }
  1227.  
  1228. longlong Item_func_elt::val_int()
  1229. {
  1230.   uint tmp;
  1231.   if ((tmp=(uint) item->val_int()) == 0 || tmp > arg_count)
  1232.   {
  1233.     null_value=1;
  1234.     return 0;
  1235.   }
  1236.   null_value=0;
  1237.   return args[tmp-1]->val_int();
  1238. }
  1239.  
  1240. String *Item_func_elt::val_str(String *str)
  1241. {
  1242.   uint tmp;
  1243.   if ((tmp=(uint) item->val_int()) == 0 || tmp > arg_count)
  1244.   {
  1245.     null_value=1;
  1246.     return NULL;
  1247.   }
  1248.   null_value=0;
  1249.   return args[tmp-1]->val_str(str);
  1250. }
  1251.  
  1252.  
  1253. void Item_func_make_set::fix_length_and_dec()
  1254. {
  1255.   max_length=arg_count-1;
  1256.   for (uint i=1 ; i < arg_count ; i++)
  1257.     max_length+=args[i]->max_length;
  1258.   used_tables_cache|=item->used_tables();
  1259.   const_item_cache&=item->const_item();
  1260. }
  1261.  
  1262.  
  1263. void Item_func_make_set::update_used_tables()
  1264. {
  1265.   Item_func::update_used_tables();
  1266.   item->update_used_tables();
  1267.   used_tables_cache|=item->used_tables();
  1268.   const_item_cache&=item->const_item();
  1269. }
  1270.  
  1271.  
  1272. String *Item_func_make_set::val_str(String *str)
  1273. {
  1274.   ulonglong bits;
  1275.   bool first_found=0;
  1276.   Item **ptr=args;
  1277.   String *result=&empty_string;
  1278.  
  1279.   bits=item->val_int();
  1280.   if ((null_value=item->null_value))
  1281.     return NULL;
  1282.  
  1283.   if (arg_count < 64)
  1284.     bits &= ((ulonglong) 1 << arg_count)-1;
  1285.  
  1286.   for (; bits; bits >>= 1, ptr++)
  1287.   {
  1288.     if (bits & 1)
  1289.     {
  1290.       String *res= (*ptr)->val_str(str);
  1291.       if (res)                    // Skipp nulls
  1292.       {
  1293.     if (!first_found)
  1294.     {                    // First argument
  1295.       first_found=1;
  1296.       if (res != str)
  1297.         result=res;                // Use original string
  1298.       else
  1299.       {
  1300.         if (tmp_str.copy(*res))        // Don't use 'str'
  1301.           return &empty_string;
  1302.         result= &tmp_str;
  1303.       }
  1304.     }
  1305.     else
  1306.     {
  1307.       if (result != &tmp_str)
  1308.       {                    // Copy data to tmp_str
  1309.         if (tmp_str.alloc(result->length()+res->length()+1) ||
  1310.         tmp_str.copy(*result))
  1311.           return &empty_string;
  1312.         result= &tmp_str;
  1313.       }
  1314.       if (tmp_str.append(',') || tmp_str.append(*res))
  1315.         return &empty_string;
  1316.     }
  1317.       }
  1318.     }
  1319.   }
  1320.   return result;
  1321. }
  1322.  
  1323.  
  1324. String *Item_func_char::val_str(String *str)
  1325. {
  1326.   str->length(0);
  1327.   for (uint i=0 ; i < arg_count ; i++)
  1328.   {
  1329.     int32 num=(int32) args[i]->val_int();
  1330.     if (!args[i]->null_value)
  1331. #ifdef USE_MB
  1332.       if (use_mb(default_charset_info))
  1333.       {
  1334.         if (num&0xFF000000L) {
  1335.            str->append((char)(num>>24));
  1336.            goto b2;
  1337.         } else if (num&0xFF0000L) {
  1338. b2:        str->append((char)(num>>16));
  1339.            goto b1;
  1340.         } else if (num&0xFF00L) {   
  1341. b1:        str->append((char)(num>>8));
  1342.         }
  1343.       }
  1344. #endif
  1345.       str->append((char)num);
  1346.   }
  1347.   str->realloc(str->length());            // Add end 0 (for Purify)
  1348.   return str;
  1349. }
  1350.  
  1351.  
  1352. inline String* alloc_buffer(String *res,String *str,String *tmp_value,
  1353.                 ulong length)
  1354. {
  1355.   if (res->alloced_length() < length)
  1356.   {
  1357.     if (str->alloced_length() >= length)
  1358.     {
  1359.       (void) str->copy(*res);
  1360.       str->length(length);
  1361.       return str;
  1362.     }
  1363.     else
  1364.     {
  1365.       if (tmp_value->alloc(length))
  1366.     return 0;
  1367.       (void) tmp_value->copy(*res);
  1368.       tmp_value->length(length);
  1369.       return tmp_value;
  1370.     }
  1371.   }
  1372.   res->length(length);
  1373.   return res;
  1374. }
  1375.  
  1376.  
  1377. void Item_func_repeat::fix_length_and_dec()
  1378. {
  1379.   if (args[1]->const_item())
  1380.   {
  1381.     max_length=(long) (args[0]->max_length * args[1]->val_int());
  1382.     if (max_length >= MAX_BLOB_WIDTH)
  1383.     {
  1384.       max_length=MAX_BLOB_WIDTH;
  1385.       maybe_null=1;
  1386.     }
  1387.   }
  1388.   else
  1389.   {
  1390.     max_length=MAX_BLOB_WIDTH;
  1391.     maybe_null=1;
  1392.   }
  1393. }
  1394.  
  1395. /*
  1396. ** Item_func_repeat::str is carefully written to avoid reallocs
  1397. ** as much as possible at the cost of a local buffer
  1398. */
  1399.  
  1400. String *Item_func_repeat::val_str(String *str)
  1401. {
  1402.   uint length,tot_length;
  1403.   char *to;
  1404.   long count= (long) args[1]->val_int();
  1405.   String *res =args[0]->val_str(str);
  1406.  
  1407.   if (args[0]->null_value || args[1]->null_value)
  1408.     goto err;                // string and/or delim are null
  1409.   null_value=0;
  1410.   if (count <= 0)            // For nicer SQL code
  1411.     return &empty_string;
  1412.   if (count == 1)            // To avoid reallocs
  1413.     return res;
  1414.   length=res->length();
  1415.   if (length > max_allowed_packet/count)// Safe length check
  1416.     goto err;                // Probably an error
  1417.   tot_length= length*(uint) count;
  1418.   if (!(res= alloc_buffer(res,str,&tmp_value,tot_length)))
  1419.     goto err;
  1420.  
  1421.   to=(char*) res->ptr()+length;
  1422.   while (--count)
  1423.   {
  1424.     memcpy(to,res->ptr(),length);
  1425.     to+=length;
  1426.   }
  1427.   return (res);
  1428.  
  1429. err:
  1430.   null_value=1;
  1431.   return 0;
  1432. }
  1433.  
  1434.  
  1435. void Item_func_rpad::fix_length_and_dec()
  1436. {
  1437.   if (args[1]->const_item())
  1438.   {
  1439.     uint32 length= (uint32) args[1]->val_int();
  1440.     max_length=max(args[0]->max_length,length);
  1441.     if (max_length >= MAX_BLOB_WIDTH)
  1442.     {
  1443.       max_length=MAX_BLOB_WIDTH;
  1444.       maybe_null=1;
  1445.     }
  1446.   }
  1447.   else
  1448.   {
  1449.     max_length=MAX_BLOB_WIDTH;
  1450.     maybe_null=1;
  1451.   }
  1452. }
  1453.  
  1454.  
  1455. String *Item_func_rpad::val_str(String *str)
  1456. {
  1457.   uint32 res_length,length_pad;
  1458.   char *to;
  1459.   const char *ptr_pad;
  1460.   int32 count= (int32) args[1]->val_int();
  1461.   String *res =args[0]->val_str(str);
  1462.   String *rpad = args[2]->val_str(str);
  1463.  
  1464.   if (!res || args[1]->null_value || !rpad)
  1465.     goto err;
  1466.   null_value=0;
  1467.   if (count <= (int32) (res_length=res->length()))
  1468.     return (res);                // String to pad is big enough
  1469.   length_pad= rpad->length();
  1470.   if ((ulong) count > max_allowed_packet || args[2]->null_value || !length_pad)
  1471.     goto err;
  1472.   if (!(res= alloc_buffer(res,str,&tmp_value,count)))
  1473.     goto err;
  1474.  
  1475.   to= (char*) res->ptr()+res_length;
  1476.   ptr_pad=rpad->ptr();
  1477.   for (count-= res_length; (uint32) count > length_pad; count-= length_pad)
  1478.   {
  1479.     memcpy(to,ptr_pad,length_pad);
  1480.     to+= length_pad;
  1481.   }
  1482.   memcpy(to,ptr_pad,(size_t) count);
  1483.   return (res);
  1484.  
  1485.  err:
  1486.   null_value=1;
  1487.   return 0;
  1488. }
  1489.  
  1490.  
  1491. void Item_func_lpad::fix_length_and_dec()
  1492. {
  1493.   if (args[1]->const_item())
  1494.   {
  1495.     uint32 length= (uint32) args[1]->val_int();
  1496.     max_length=max(args[0]->max_length,length);
  1497.     if (max_length >= MAX_BLOB_WIDTH)
  1498.     {
  1499.       max_length=MAX_BLOB_WIDTH;
  1500.       maybe_null=1;
  1501.     }
  1502.   }
  1503.   else
  1504.   {
  1505.     max_length=MAX_BLOB_WIDTH;
  1506.     maybe_null=1;
  1507.   }
  1508. }
  1509.  
  1510.  
  1511. String *Item_func_lpad::val_str(String *str)
  1512. {
  1513.   uint32 res_length,length_pad;
  1514.   char *to;
  1515.   const char *ptr_pad;
  1516.   ulong count= (long) args[1]->val_int();
  1517.   String *res= args[0]->val_str(str);
  1518.   String *lpad= args[2]->val_str(str);
  1519.  
  1520.   if (!res || args[1]->null_value || !lpad)
  1521.     goto err;
  1522.   null_value=0;
  1523.   if (count <= (res_length=res->length()))
  1524.     return (res);                // String to pad is big enough
  1525.   length_pad= lpad->length();
  1526.   if (count > max_allowed_packet || args[2]->null_value || !length_pad)
  1527.     goto err;
  1528.  
  1529.   if (res->alloced_length() < count)
  1530.   {
  1531.     if (str->alloced_length() >= count)
  1532.     {
  1533.       memcpy((char*) str->ptr()+(count-res_length),res->ptr(),res_length);
  1534.       res=str;
  1535.     }
  1536.     else
  1537.     {
  1538.       if (tmp_value.alloc(count))
  1539.     goto err;
  1540.       memcpy((char*) tmp_value.ptr()+(count-res_length),res->ptr(),res_length);
  1541.       res=&tmp_value;
  1542.     }
  1543.   }
  1544.   else
  1545.     bmove_upp((char*) res->ptr()+count,res->ptr()+res_length,res_length);
  1546.   res->length(count);
  1547.  
  1548.   to= (char*) res->ptr();
  1549.   ptr_pad= lpad->ptr();
  1550.   for (count-= res_length; count > length_pad; count-= length_pad)
  1551.   {
  1552.     memcpy(to,ptr_pad,length_pad);
  1553.     to+= length_pad;
  1554.   }
  1555.   memcpy(to,ptr_pad,(size_t) count);
  1556.   return (res);
  1557.  
  1558.  err:
  1559.   null_value=1;
  1560.   return 0;
  1561. }
  1562.  
  1563.  
  1564. String *Item_func_conv::val_str(String *str)
  1565. {
  1566.   String *res= args[0]->val_str(str);
  1567.   char *endptr,ans[65],*ptr;
  1568.   longlong dec;
  1569.   int from_base= (int) args[1]->val_int();
  1570.   int to_base= (int) args[2]->val_int();
  1571.  
  1572.   if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
  1573.       abs(to_base) > 36 || abs(to_base) < 2 ||
  1574.       abs(from_base) > 36 || abs(from_base) < 2 || !(res->length()))
  1575.   {
  1576.     null_value=1;
  1577.     return 0;
  1578.   }
  1579.   null_value=0;
  1580.   if (from_base < 0)
  1581.     dec= strtoll(res->c_ptr(),&endptr,-from_base);
  1582.   else
  1583.     dec= (longlong) strtoull(res->c_ptr(),&endptr,from_base);
  1584.   ptr= longlong2str(dec,ans,to_base);
  1585.   if (str->copy(ans,(uint32) (ptr-ans)))
  1586.     return &empty_string;
  1587.   return str;
  1588. }
  1589.  
  1590. #include <my_dir.h>                // For my_stat
  1591.  
  1592. String *Item_load_file::val_str(String *str)
  1593. {
  1594.   String *file_name;
  1595.   File file;
  1596.   MY_STAT stat_info;
  1597.   DBUG_ENTER("load_file");
  1598.  
  1599.   if (!(file_name= args[0]->val_str(str)) ||
  1600.       !(current_thd->master_access & FILE_ACL) ||
  1601.       !my_stat(file_name->c_ptr(), &stat_info, MYF(MY_WME)))
  1602.     goto err;
  1603.   if (!(stat_info.st_mode & S_IROTH))
  1604.   {
  1605.     /* my_error(ER_TEXTFILE_NOT_READABLE, MYF(0), file_name->c_ptr()); */
  1606.     goto err;
  1607.   }
  1608.   if (stat_info.st_size > (long) max_allowed_packet)
  1609.   {
  1610.     /* my_error(ER_TOO_LONG_STRING, MYF(0), file_name->c_ptr()); */
  1611.     goto err;
  1612.   }
  1613.   if (tmp_value.alloc(stat_info.st_size))
  1614.     goto err;
  1615.   if ((file = my_open(file_name->c_ptr(), O_RDONLY, MYF(0))) < 0)
  1616.     goto err;
  1617.   if (my_read(file, (byte*) tmp_value.ptr(), stat_info.st_size, MYF(MY_NABP)))
  1618.   {
  1619.     my_close(file, MYF(0));
  1620.     goto err;
  1621.   }
  1622.   tmp_value.length(stat_info.st_size);
  1623.   my_close(file, MYF(0));
  1624.   null_value = 0;
  1625.   return &tmp_value;
  1626.  
  1627. err:
  1628.   null_value = 1;
  1629.   DBUG_RETURN(0);
  1630. }
  1631.  
  1632.  
  1633. String* Item_func_export_set::val_str(String* str)
  1634. {
  1635.   ulonglong the_set = (ulonglong) args[0]->val_int();
  1636.   String yes_buf, *yes; 
  1637.   yes = args[1]->val_str(&yes_buf);
  1638.   String no_buf, *no; 
  1639.   no = args[2]->val_str(&no_buf);
  1640.   String *sep = NULL, sep_buf ; 
  1641.  
  1642.   uint num_set_values = 64;
  1643.   ulonglong mask = 0x1;
  1644.   str->length(0);
  1645.  
  1646.   /* Check if some argument is a NULL value */
  1647.   if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
  1648.   {
  1649.     null_value=1;
  1650.     return 0;
  1651.   }
  1652.   switch(arg_count) {
  1653.   case 5:
  1654.     num_set_values = (uint) args[4]->val_int();
  1655.     if (num_set_values > 64)
  1656.       num_set_values=64;
  1657.     if (args[4]->null_value)
  1658.     {
  1659.       null_value=1;
  1660.       return 0;
  1661.     }
  1662.     /* Fall through */
  1663.   case 4:
  1664.     if (!(sep = args[3]->val_str(&sep_buf)))    // Only true if NULL
  1665.     {
  1666.       null_value=1;
  1667.       return 0;
  1668.     }
  1669.     break;
  1670.   case 3:
  1671.     sep_buf.set(",", 1);
  1672.     sep = &sep_buf;
  1673.   }
  1674.   null_value=0;
  1675.  
  1676.   for (uint i = 0; i < num_set_values; i++, mask = (mask << 1))
  1677.   {
  1678.     if (the_set & mask)
  1679.       str->append(*yes);
  1680.     else
  1681.       str->append(*no);
  1682.     if(i != num_set_values - 1)
  1683.       str->append(*sep);
  1684.   }
  1685.   return str;
  1686. }
  1687.  
  1688. void Item_func_export_set::fix_length_and_dec()
  1689. {
  1690.   uint length=max(args[1]->max_length,args[2]->max_length);
  1691.   uint sep_length=(arg_count > 3 ? args[3]->max_length : 1);
  1692.   max_length=length*64+sep_length*63;
  1693. }
  1694.  
  1695. String* Item_func_inet_ntoa::val_str(String* str)
  1696. {
  1697.   uchar buf[8], *p;
  1698.   ulonglong n = (ulonglong) args[0]->val_int();
  1699.   char num[4];
  1700.   // we do not know if args[0] is NULL until we have called
  1701.   // some val function on it if args[0] is not a constant!
  1702.   if ((null_value=args[0]->null_value))
  1703.     return 0;                    // Null value
  1704.   str->length(0);
  1705.   int8store(buf,n);
  1706.  
  1707.   // now we can assume little endian
  1708.   // we handle the possibility of an 8-byte IP address
  1709.   // however, we do not want to confuse those who are just using
  1710.   // 4 byte ones
  1711.   
  1712.   for (p= buf + 8; p > buf+4 && p[-1] == 0 ; p-- ) ;
  1713.   num[3]='.';
  1714.   while (p-- > buf)
  1715.   {
  1716.     uint c = *p;
  1717.     uint n1,n2;                    // Try to avoid divisions
  1718.     n1= c / 100;                // 100 digits
  1719.     c-= n1*100;
  1720.     n2= c / 10;                    // 10 digits
  1721.     c-=n2*10;                    // last digit
  1722.     num[0]=(char) n1+'0';
  1723.     num[1]=(char) n2+'0';
  1724.     num[2]=(char) c+'0';
  1725.     uint length=(n1 ? 4 : n2 ? 3 : 2);        // Remove pre-zero
  1726.  
  1727.     (void) str->append(num+4-length,length);
  1728.   }
  1729.   str->length(str->length()-1);            // Remove last '.';
  1730.   return str;
  1731. }
  1732.