开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
item_strfunc.cc
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：40k
源码类别：

MySQL数据库

开发平台：

Visual C++

item_strfunc.cc：源码内容
  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 */
  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. */
  23. #ifdef __GNUC__
  24. #pragma implementation // gcc: Class implementation
  25. #endif
  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
  34. #include "md5.h"
  36. String empty_string("");
  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. }
  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. }
  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. }
  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];
  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. }
  91. void Item_func_md5::fix_length_and_dec()
  92. {
  93.    max_length=32;
  94. }
  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. */
  102. String *Item_func_concat::val_str(String *str)
  103. {
  104.   String *res,*res2,*use_as_buff;
  105.   uint i;
  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;
  184. null:
  185.   null_value=1;
  186.   return 0;
  187. }
  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. }
  204. /* 
  205. ** concat with separator. First arg is the separator
  206. ** concat_ws takes at least two arguments.
  207. */
  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;
  216.   null_value=0;
  217.   if (!(sep_str= separator->val_str(&tmp_sep_str)))
  218.     goto null;
  220.   use_as_buff= &tmp_value;
  221.   str->length(0);
  222.   res=str;
  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.   }
  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;
  296. null:
  297.   null_value=1;
  298.   return 0;
  299. }
  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. }
  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. }
  325. String *Item_func_reverse::val_str(String *str)
  326. {
  327.   String *res = args[0]->val_str(str);
  328.   char *ptr,*end;
  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. }
  369. void Item_func_reverse::fix_length_and_dec()
  370. {
  371.   max_length = args[0]->max_length;
  372. }
  374. /*
  375. ** Replace all occurences of string2 in string1 with string3.
  376. ** Don't reallocate val_str() if not neaded
  377. */
  379. /* TODO: Fix that this works with binary strings when using USE_MB */
  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
  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;
  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();
  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;
  464. null:
  465.   null_value=1;
  466.   return 0;
  467. }
  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. }
  487. String *Item_func_insert::val_str(String *str)
  488. {
  489.   String *res,*res2;
  490.   uint start,length;
  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. }
  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. }
  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. }
  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. }
  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();
  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. }
  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. }
  603. void Item_func_left::fix_length_and_dec()
  604. {
  605.   left_right_max_length();
  606. }
  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();
  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. }
  637. void Item_func_right::fix_length_and_dec()
  638. {
  639.   left_right_max_length();
  640. }
  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;
  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;
  663.   tmp_length=(int32) res->length()-start;
  664.   length=min(length,tmp_length);
  666.   if (!start && res->length() == (uint) length)
  667.     return res;
  668.   tmp_value.set(*res,(uint) start,(uint) length);
  669.   return &tmp_value;
  670. }
  673. void Item_func_substr::fix_length_and_dec()
  674. {
  675.   max_length=args[0]->max_length;
  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. }
  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;
  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
  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. }
  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. */
  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);
  816.   if (!remove_str || (remove_length=remove_str->length()) == 0 ||
  817.       remove_length > res->length())
  818.     return res;
  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. }
  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);
  854.   if (!remove_str || (remove_length=remove_str->length()) == 0 ||
  855.       remove_length > res->length())
  856.     return res;
  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. }
  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);
  926.   if (!remove_str || (remove_length=remove_str->length()) == 0 ||
  927.       remove_length > res->length())
  928.     return res;
  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. }
  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. }
  980. #define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
  982. String *Item_func_encrypt::val_str(String *str)
  983. {
  984.   String *res  =args[0]->val_str(str);
  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;
  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. }
  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. }
  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. }
  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. }
  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. }
  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. }
  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. }
  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.     */
  1089. extern "C" {
  1090. extern char *soundex_map; // In mysys/static.c
  1091. }
  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. }
  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 */
  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();
  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. }
  1146. /*
  1147. ** Change a number to format '3,333,333,333.000'
  1148. ** This should be 'internationalized' sometimes.
  1149. */
  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. }
  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. }
  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.   with_sum_func= with_sum_func || item->with_sum_func;
  1203.   used_tables_cache|=item->used_tables();
  1204.   const_item_cache&=item->const_item();
  1205. }
  1208. void Item_func_elt::update_used_tables()
  1209. {
  1210.   Item_func::update_used_tables();
  1211.   item->update_used_tables();
  1212.   used_tables_cache|=item->used_tables();
  1213.   const_item_cache&=item->const_item();
  1214. }
  1217. double Item_func_elt::val()
  1218. {
  1219.   uint tmp;
  1220.   if ((tmp=(uint) item->val_int()) == 0 || tmp > arg_count)
  1221.   {
  1222.     null_value=1;
  1223.     return 0.0;
  1224.   }
  1225.   null_value=0;
  1226.   return args[tmp-1]->val();
  1227. }
  1229. longlong Item_func_elt::val_int()
  1230. {
  1231.   uint tmp;
  1232.   if ((tmp=(uint) item->val_int()) == 0 || tmp > arg_count)
  1233.   {
  1234.     null_value=1;
  1235.     return 0;
  1236.   }
  1237.   null_value=0;
  1238.   return args[tmp-1]->val_int();
  1239. }
  1241. String *Item_func_elt::val_str(String *str)
  1242. {
  1243.   uint tmp;
  1244.   if ((tmp=(uint) item->val_int()) == 0 || tmp > arg_count)
  1245.   {
  1246.     null_value=1;
  1247.     return NULL;
  1248.   }
  1249.   null_value=0;
  1250.   return args[tmp-1]->val_str(str);
  1251. }
  1254. void Item_func_make_set::fix_length_and_dec()
  1255. {
  1256.   max_length=arg_count-1;
  1257.   for (uint i=1 ; i < arg_count ; i++)
  1258.     max_length+=args[i]->max_length;
  1259.   used_tables_cache|=item->used_tables();
  1260.   const_item_cache&=item->const_item();
  1261. }
  1264. void Item_func_make_set::update_used_tables()
  1265. {
  1266.   Item_func::update_used_tables();
  1267.   item->update_used_tables();
  1268.   used_tables_cache|=item->used_tables();
  1269.   const_item_cache&=item->const_item();
  1270. }
  1273. String *Item_func_make_set::val_str(String *str)
  1274. {
  1275.   ulonglong bits;
  1276.   bool first_found=0;
  1277.   Item **ptr=args;
  1278.   String *result=&empty_string;
  1280.   bits=item->val_int();
  1281.   if ((null_value=item->null_value))
  1282.     return NULL;
  1284.   if (arg_count < 64)
  1285.     bits &= ((ulonglong) 1 << arg_count)-1;
  1287.   for (; bits; bits >>= 1, ptr++)
  1288.   {
  1289.     if (bits & 1)
  1290.     {
  1291.       String *res= (*ptr)->val_str(str);
  1292.       if (res) // Skipp nulls
  1293.       {
  1294. if (!first_found)
  1295. { // First argument
  1296.   first_found=1;
  1297.   if (res != str)
  1298.     result=res; // Use original string
  1299.   else
  1300.   {
  1301.     if (tmp_str.copy(*res)) // Don't use 'str'
  1302.       return &empty_string;
  1303.     result= &tmp_str;
  1304.   }
  1305. }
  1306. else
  1307. {
  1308.   if (result != &tmp_str)
  1309.   { // Copy data to tmp_str
  1310.     if (tmp_str.alloc(result->length()+res->length()+1) ||
  1311. tmp_str.copy(*result))
  1312.       return &empty_string;
  1313.     result= &tmp_str;
  1314.   }
  1315.   if (tmp_str.append(',') || tmp_str.append(*res))
  1316.     return &empty_string;
  1317. }
  1318.       }
  1319.     }
  1320.   }
  1321.   return result;
  1322. }
  1325. String *Item_func_char::val_str(String *str)
  1326. {
  1327.   str->length(0);
  1328.   for (uint i=0 ; i < arg_count ; i++)
  1329.   {
  1330.     int32 num=(int32) args[i]->val_int();
  1331.     if (!args[i]->null_value)
  1332. #ifdef USE_MB
  1333.       if (use_mb(default_charset_info))
  1334.       {
  1335.         if (num&0xFF000000L) {
  1336.            str->append((char)(num>>24));
  1337.            goto b2;
  1338.         } else if (num&0xFF0000L) {
  1339. b2:        str->append((char)(num>>16));
  1340.            goto b1;
  1341.         } else if (num&0xFF00L) {   
  1342. b1:        str->append((char)(num>>8));
  1343.         }
  1344.       }
  1345. #endif
  1346.       str->append((char)num);
  1347.   }
  1348.   str->realloc(str->length()); // Add end 0 (for Purify)
  1349.   return str;
  1350. }
  1353. inline String* alloc_buffer(String *res,String *str,String *tmp_value,
  1354.     ulong length)
  1355. {
  1356.   if (res->alloced_length() < length)
  1357.   {
  1358.     if (str->alloced_length() >= length)
  1359.     {
  1360.       (void) str->copy(*res);
  1361.       str->length(length);
  1362.       return str;
  1363.     }
  1364.     else
  1365.     {
  1366.       if (tmp_value->alloc(length))
  1367. return 0;
  1368.       (void) tmp_value->copy(*res);
  1369.       tmp_value->length(length);
  1370.       return tmp_value;
  1371.     }
  1372.   }
  1373.   res->length(length);
  1374.   return res;
  1375. }
  1378. void Item_func_repeat::fix_length_and_dec()
  1379. {
  1380.   if (args[1]->const_item())
  1381.   {
  1382.     max_length=(long) (args[0]->max_length * args[1]->val_int());
  1383.     if (max_length >= MAX_BLOB_WIDTH)
  1384.     {
  1385.       max_length=MAX_BLOB_WIDTH;
  1386.       maybe_null=1;
  1387.     }
  1388.   }
  1389.   else
  1390.   {
  1391.     max_length=MAX_BLOB_WIDTH;
  1392.     maybe_null=1;
  1393.   }
  1394. }
  1396. /*
  1397. ** Item_func_repeat::str is carefully written to avoid reallocs
  1398. ** as much as possible at the cost of a local buffer
  1399. */
  1401. String *Item_func_repeat::val_str(String *str)
  1402. {
  1403.   uint length,tot_length;
  1404.   char *to;
  1405.   long count= (long) args[1]->val_int();
  1406.   String *res =args[0]->val_str(str);
  1408.   if (args[0]->null_value || args[1]->null_value)
  1409.     goto err; // string and/or delim are null
  1410.   null_value=0;
  1411.   if (count <= 0) // For nicer SQL code
  1412.     return &empty_string;
  1413.   if (count == 1) // To avoid reallocs
  1414.     return res;
  1415.   length=res->length();
  1416.   if (length > max_allowed_packet/count)// Safe length check
  1417.     goto err; // Probably an error
  1418.   tot_length= length*(uint) count;
  1419.   if (!(res= alloc_buffer(res,str,&tmp_value,tot_length)))
  1420.     goto err;
  1422.   to=(char*) res->ptr()+length;
  1423.   while (--count)
  1424.   {
  1425.     memcpy(to,res->ptr(),length);
  1426.     to+=length;
  1427.   }
  1428.   return (res);
  1430. err:
  1431.   null_value=1;
  1432.   return 0;
  1433. }
  1436. void Item_func_rpad::fix_length_and_dec()
  1437. {
  1438.   if (args[1]->const_item())
  1439.   {
  1440.     uint32 length= (uint32) args[1]->val_int();
  1441.     max_length=max(args[0]->max_length,length);
  1442.     if (max_length >= MAX_BLOB_WIDTH)
  1443.     {
  1444.       max_length=MAX_BLOB_WIDTH;
  1445.       maybe_null=1;
  1446.     }
  1447.   }
  1448.   else
  1449.   {
  1450.     max_length=MAX_BLOB_WIDTH;
  1451.     maybe_null=1;
  1452.   }
  1453. }
  1456. String *Item_func_rpad::val_str(String *str)
  1457. {
  1458.   uint32 res_length,length_pad;
  1459.   char *to;
  1460.   const char *ptr_pad;
  1461.   int32 count= (int32) args[1]->val_int();
  1462.   String *res =args[0]->val_str(str);
  1463.   String *rpad = args[2]->val_str(str);
  1465.   if (!res || args[1]->null_value || !rpad)
  1466.     goto err;
  1467.   null_value=0;
  1468.   if (count <= (int32) (res_length=res->length()))
  1469.   { // String to pad is big enough
  1470.     res->length(count); // Shorten result if longer
  1471.     return (res);
  1472.   }
  1473.   length_pad= rpad->length();
  1474.   if ((ulong) count > max_allowed_packet || args[2]->null_value || !length_pad)
  1475.     goto err;
  1476.   if (!(res= alloc_buffer(res,str,&tmp_value,count)))
  1477.     goto err;
  1479.   to= (char*) res->ptr()+res_length;
  1480.   ptr_pad=rpad->ptr();
  1481.   for (count-= res_length; (uint32) count > length_pad; count-= length_pad)
  1482.   {
  1483.     memcpy(to,ptr_pad,length_pad);
  1484.     to+= length_pad;
  1485.   }
  1486.   memcpy(to,ptr_pad,(size_t) count);
  1487.   return (res);
  1489.  err:
  1490.   null_value=1;
  1491.   return 0;
  1492. }
  1495. void Item_func_lpad::fix_length_and_dec()
  1496. {
  1497.   if (args[1]->const_item())
  1498.   {
  1499.     uint32 length= (uint32) args[1]->val_int();
  1500.     max_length=max(args[0]->max_length,length);
  1501.     if (max_length >= MAX_BLOB_WIDTH)
  1502.     {
  1503.       max_length=MAX_BLOB_WIDTH;
  1504.       maybe_null=1;
  1505.     }
  1506.   }
  1507.   else
  1508.   {
  1509.     max_length=MAX_BLOB_WIDTH;
  1510.     maybe_null=1;
  1511.   }
  1512. }
  1515. String *Item_func_lpad::val_str(String *str)
  1516. {
  1517.   uint32 res_length,length_pad;
  1518.   char *to;
  1519.   const char *ptr_pad;
  1520.   ulong count= (long) args[1]->val_int();
  1521.   String *res= args[0]->val_str(str);
  1522.   String *lpad= args[2]->val_str(str);
  1524.   if (!res || args[1]->null_value || !lpad)
  1525.     goto err;
  1526.   null_value=0;
  1527.   if (count <= (res_length=res->length()))
  1528.   { // String to pad is big enough
  1529.     res->length(count); // Shorten result if longer
  1530.     return (res);
  1531.   }
  1532.   length_pad= lpad->length();
  1533.   if (count > max_allowed_packet || args[2]->null_value || !length_pad)
  1534.     goto err;
  1536.   if (res->alloced_length() < count)
  1537.   {
  1538.     if (str->alloced_length() >= count)
  1539.     {
  1540.       memcpy((char*) str->ptr()+(count-res_length),res->ptr(),res_length);
  1541.       res=str;
  1542.     }
  1543.     else
  1544.     {
  1545.       if (tmp_value.alloc(count))
  1546. goto err;
  1547.       memcpy((char*) tmp_value.ptr()+(count-res_length),res->ptr(),res_length);
  1548.       res=&tmp_value;
  1549.     }
  1550.   }
  1551.   else
  1552.     bmove_upp((char*) res->ptr()+count,res->ptr()+res_length,res_length);
  1553.   res->length(count);
  1555.   to= (char*) res->ptr();
  1556.   ptr_pad= lpad->ptr();
  1557.   for (count-= res_length; count > length_pad; count-= length_pad)
  1558.   {
  1559.     memcpy(to,ptr_pad,length_pad);
  1560.     to+= length_pad;
  1561.   }
  1562.   memcpy(to,ptr_pad,(size_t) count);
  1563.   return (res);
  1565.  err:
  1566.   null_value=1;
  1567.   return 0;
  1568. }
  1571. String *Item_func_conv::val_str(String *str)
  1572. {
  1573.   String *res= args[0]->val_str(str);
  1574.   char *endptr,ans[65],*ptr;
  1575.   longlong dec;
  1576.   int from_base= (int) args[1]->val_int();
  1577.   int to_base= (int) args[2]->val_int();
  1579.   if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
  1580.       abs(to_base) > 36 || abs(to_base) < 2 ||
  1581.       abs(from_base) > 36 || abs(from_base) < 2 || !(res->length()))
  1582.   {
  1583.     null_value=1;
  1584.     return 0;
  1585.   }
  1586.   null_value=0;
  1587.   if (from_base < 0)
  1588.     dec= strtoll(res->c_ptr(),&endptr,-from_base);
  1589.   else
  1590.     dec= (longlong) strtoull(res->c_ptr(),&endptr,from_base);
  1591.   ptr= longlong2str(dec,ans,to_base);
  1592.   if (str->copy(ans,(uint32) (ptr-ans)))
  1593.     return &empty_string;
  1594.   return str;
  1595. }
  1597. #include <my_dir.h> // For my_stat
  1599. String *Item_load_file::val_str(String *str)
  1600. {
  1601.   String *file_name;
  1602.   File file;
  1603.   MY_STAT stat_info;
  1604.   DBUG_ENTER("load_file");
  1606.   if (!(file_name= args[0]->val_str(str)) ||
  1607.       !(current_thd->master_access & FILE_ACL) ||
  1608.       !my_stat(file_name->c_ptr(), &stat_info, MYF(MY_WME)))
  1609.     goto err;
  1610.   if (!(stat_info.st_mode & S_IROTH))
  1611.   {
  1612.     /* my_error(ER_TEXTFILE_NOT_READABLE, MYF(0), file_name->c_ptr()); */
  1613.     goto err;
  1614.   }
  1615.   if (stat_info.st_size > (long) max_allowed_packet)
  1616.   {
  1617.     /* my_error(ER_TOO_LONG_STRING, MYF(0), file_name->c_ptr()); */
  1618.     goto err;
  1619.   }
  1620.   if (tmp_value.alloc(stat_info.st_size))
  1621.     goto err;
  1622.   if ((file = my_open(file_name->c_ptr(), O_RDONLY, MYF(0))) < 0)
  1623.     goto err;
  1624.   if (my_read(file, (byte*) tmp_value.ptr(), stat_info.st_size, MYF(MY_NABP)))
  1625.   {
  1626.     my_close(file, MYF(0));
  1627.     goto err;
  1628.   }
  1629.   tmp_value.length(stat_info.st_size);
  1630.   my_close(file, MYF(0));
  1631.   null_value = 0;
  1632.   return &tmp_value;
  1634. err:
  1635.   null_value = 1;
  1636.   DBUG_RETURN(0);
  1637. }
  1640. String* Item_func_export_set::val_str(String* str)
  1641. {
  1642.   ulonglong the_set = (ulonglong) args[0]->val_int();
  1643.   String yes_buf, *yes; 
  1644.   yes = args[1]->val_str(&yes_buf);
  1645.   String no_buf, *no; 
  1646.   no = args[2]->val_str(&no_buf);
  1647.   String *sep = NULL, sep_buf ; 
  1649.   uint num_set_values = 64;
  1650.   ulonglong mask = 0x1;
  1651.   str->length(0);
  1653.   /* Check if some argument is a NULL value */
  1654.   if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
  1655.   {
  1656.     null_value=1;
  1657.     return 0;
  1658.   }
  1659.   switch(arg_count) {
  1660.   case 5:
  1661.     num_set_values = (uint) args[4]->val_int();
  1662.     if (num_set_values > 64)
  1663.       num_set_values=64;
  1664.     if (args[4]->null_value)
  1665.     {
  1666.       null_value=1;
  1667.       return 0;
  1668.     }
  1669.     /* Fall through */
  1670.   case 4:
  1671.     if (!(sep = args[3]->val_str(&sep_buf))) // Only true if NULL
  1672.     {
  1673.       null_value=1;
  1674.       return 0;
  1675.     }
  1676.     break;
  1677.   case 3:
  1678.     sep_buf.set(",", 1);
  1679.     sep = &sep_buf;
  1680.   }
  1681.   null_value=0;
  1683.   for (uint i = 0; i < num_set_values; i++, mask = (mask << 1))
  1684.   {
  1685.     if (the_set & mask)
  1686.       str->append(*yes);
  1687.     else
  1688.       str->append(*no);
  1689.     if(i != num_set_values - 1)
  1690.       str->append(*sep);
  1691.   }
  1692.   return str;
  1693. }
  1695. void Item_func_export_set::fix_length_and_dec()
  1696. {
  1697.   uint length=max(args[1]->max_length,args[2]->max_length);
  1698.   uint sep_length=(arg_count > 3 ? args[3]->max_length : 1);
  1699.   max_length=length*64+sep_length*63;
  1700. }
  1702. String* Item_func_inet_ntoa::val_str(String* str)
  1703. {
  1704.   uchar buf[8], *p;
  1705.   ulonglong n = (ulonglong) args[0]->val_int();
  1706.   char num[4];
  1707.   // we do not know if args[0] is NULL until we have called
  1708.   // some val function on it if args[0] is not a constant!
  1709.   if ((null_value=args[0]->null_value))
  1710.     return 0; // Null value
  1711.   str->length(0);
  1712.   int8store(buf,n);
  1714.   // now we can assume little endian
  1715.   // we handle the possibility of an 8-byte IP address
  1716.   // however, we do not want to confuse those who are just using
  1717.   // 4 byte ones
  1718.   
  1719.   for (p= buf + 8; p > buf+4 && p[-1] == 0 ; p-- ) ;
  1720.   num[3]='.';
  1721.   while (p-- > buf)
  1722.   {
  1723.     uint c = *p;
  1724.     uint n1,n2; // Try to avoid divisions
  1725.     n1= c / 100; // 100 digits
  1726.     c-= n1*100;
  1727.     n2= c / 10; // 10 digits
  1728.     c-=n2*10; // last digit
  1729.     num[0]=(char) n1+'0';
  1730.     num[1]=(char) n2+'0';
  1731.     num[2]=(char) c+'0';
  1732.     uint length=(n1 ? 4 : n2 ? 3 : 2); // Remove pre-zero
  1734.     (void) str->append(num+4-length,length);
  1735.   }
  1736.   str->length(str->length()-1); // Remove last '.';
  1737.   return str;
  1738. }