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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
item_strfunc.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：74k
源码类别：

MySQL数据库

开发平台：

Visual C++

item_strfunc.cpp：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  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.
  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.
  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 needed)
  21. */
  23. #ifdef USE_PRAGMA_IMPLEMENTATION
  24. #pragma implementation // gcc: Class implementation
  25. #endif
  27. #include "mysql_priv.h"
  28. #include <m_ctype.h>
  29. #ifdef HAVE_OPENSSL
  30. #include <openssl/des.h>
  31. #endif /* HAVE_OPENSSL */
  32. #include "md5.h"
  33. #include "sha1.h"
  34. #include "my_aes.h"
  35. C_MODE_START
  36. #include "../mysys/my_static.h" // For soundex_map
  37. C_MODE_END
  39. String my_empty_string("",default_charset_info);
  41. static void my_coll_agg_error(DTCollation &c1, DTCollation &c2,
  42.                               const char *fname)
  43. {
  44.   my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
  45.    c1.collation->name,c1.derivation_name(),
  46.    c2.collation->name,c2.derivation_name(),
  47.    fname);
  48. }
  50. uint nr_of_decimals(const char *str)
  51. {
  52.   if ((str=strchr(str,'.')))
  53.   {
  54.     const char *start= ++str;
  55.     for (; my_isdigit(system_charset_info,*str) ; str++) ;
  56.     return (uint) (str-start);
  57.   }
  58.   return 0;
  59. }
  61. double Item_str_func::val()
  62. {
  63.   DBUG_ASSERT(fixed == 1);
  64.   int err;
  65.   char buff[64];
  66.   char *end_not_used;
  67.   String *res, tmp(buff,sizeof(buff), &my_charset_bin);
  68.   res= val_str(&tmp);
  69.   return res ? my_strntod(res->charset(), (char*) res->ptr(),res->length(),
  70.   &end_not_used, &err) : 0.0;
  71. }
  73. longlong Item_str_func::val_int()
  74. {
  75.   DBUG_ASSERT(fixed == 1);
  76.   int err;
  77.   char buff[22];
  78.   String *res, tmp(buff,sizeof(buff), &my_charset_bin);
  79.   res= val_str(&tmp);
  80.   return (res ?
  81.   my_strntoll(res->charset(), res->ptr(), res->length(), 10, NULL,
  82.       &err) :
  83.   (longlong) 0);
  84. }
  87. String *Item_func_md5::val_str(String *str)
  88. {
  89.   DBUG_ASSERT(fixed == 1);
  90.   String * sptr= args[0]->val_str(str);
  91.   if (sptr)
  92.   {
  93.     my_MD5_CTX context;
  94.     unsigned char digest[16];
  96.     null_value=0;
  97.     my_MD5Init (&context);
  98.     my_MD5Update (&context,(unsigned char *) sptr->ptr(), sptr->length());
  99.     my_MD5Final (digest, &context);
  100.     if (str->alloc(32)) // Ensure that memory is free
  101.     {
  102.       null_value=1;
  103.       return 0;
  104.     }
  105.     sprintf((char *) str->ptr(),
  106.     "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
  107.     digest[0], digest[1], digest[2], digest[3],
  108.     digest[4], digest[5], digest[6], digest[7],
  109.     digest[8], digest[9], digest[10], digest[11],
  110.     digest[12], digest[13], digest[14], digest[15]);
  111.     str->length((uint) 32);
  112.     return str;
  113.   }
  114.   null_value=1;
  115.   return 0;
  116. }
  119. void Item_func_md5::fix_length_and_dec()
  120. {
  121.    max_length=32;
  122. }
  125. String *Item_func_sha::val_str(String *str)
  126. {
  127.   DBUG_ASSERT(fixed == 1);
  128.   String * sptr= args[0]->val_str(str);
  129.   if (sptr)  /* If we got value different from NULL */
  130.   {
  131.     SHA1_CONTEXT context;  /* Context used to generate SHA1 hash */
  132.     /* Temporary buffer to store 160bit digest */
  133.     uint8 digest[SHA1_HASH_SIZE];
  134.     sha1_reset(&context);  /* We do not have to check for error here */
  135.     /* No need to check error as the only case would be too long message */
  136.     sha1_input(&context,(const unsigned char *) sptr->ptr(), sptr->length());
  137.     /* Ensure that memory is free and we got result */
  138.     if (!( str->alloc(SHA1_HASH_SIZE*2) || (sha1_result(&context,digest))))
  139.     {
  140.       sprintf((char *) str->ptr(),
  141.       "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x
  142. %02x%02x%02x%02x%02x%02x%02x%02x",
  143.            digest[0], digest[1], digest[2], digest[3],
  144.            digest[4], digest[5], digest[6], digest[7],
  145.            digest[8], digest[9], digest[10], digest[11],
  146.            digest[12], digest[13], digest[14], digest[15],
  147.            digest[16], digest[17], digest[18], digest[19]);
  149.       str->length((uint)  SHA1_HASH_SIZE*2);
  150.       null_value=0;
  151.       return str;
  152.     }
  153.   }
  154.   null_value=1;
  155.   return 0;
  156. }
  158. void Item_func_sha::fix_length_and_dec()
  159. {
  160.    max_length=SHA1_HASH_SIZE*2; // size of hex representation of hash
  161. }
  164. /* Implementation of AES encryption routines */
  166. String *Item_func_aes_encrypt::val_str(String *str)
  167. {
  168.   DBUG_ASSERT(fixed == 1);
  169.   char key_buff[80];
  170.   String tmp_key_value(key_buff, sizeof(key_buff), system_charset_info);
  171.   String *sptr= args[0]->val_str(str); // String to encrypt
  172.   String *key=  args[1]->val_str(&tmp_key_value); // key
  173.   int aes_length;
  174.   if (sptr && key) // we need both arguments to be not NULL
  175.   {
  176.     null_value=0;
  177.     aes_length=my_aes_get_size(sptr->length()); // Calculate result length
  179.     if (!str_value.alloc(aes_length)) // Ensure that memory is free
  180.     {
  181.       // finally encrypt directly to allocated buffer.
  182.       if (my_aes_encrypt(sptr->ptr(),sptr->length(), (char*) str_value.ptr(),
  183.  key->ptr(), key->length()) == aes_length)
  184.       {
  185. // We got the expected result length
  186. str_value.length((uint) aes_length);
  187. return &str_value;
  188.       }
  189.     }
  190.   }
  191.   null_value=1;
  192.   return 0;
  193. }
  196. void Item_func_aes_encrypt::fix_length_and_dec()
  197. {
  198.   max_length=my_aes_get_size(args[0]->max_length);
  199. }
  202. String *Item_func_aes_decrypt::val_str(String *str)
  203. {
  204.   DBUG_ASSERT(fixed == 1);
  205.   char key_buff[80];
  206.   String tmp_key_value(key_buff, sizeof(key_buff), system_charset_info);
  207.   String *sptr, *key;
  208.   DBUG_ENTER("Item_func_aes_decrypt::val_str");
  210.   sptr= args[0]->val_str(str); // String to decrypt
  211.   key=  args[1]->val_str(&tmp_key_value); // Key
  212.   if (sptr && key)   // Need to have both arguments not NULL
  213.   {
  214.     null_value=0;
  215.     if (!str_value.alloc(sptr->length()))  // Ensure that memory is free
  216.     {
  217.       // finally decrypt directly to allocated buffer.
  218.       int length;
  219.       length=my_aes_decrypt(sptr->ptr(), sptr->length(),
  220.     (char*) str_value.ptr(),
  221.                             key->ptr(), key->length());
  222.       if (length >= 0)  // if we got correct data data
  223.       {
  224.         str_value.length((uint) length);
  225.         DBUG_RETURN(&str_value);
  226.       }
  227.     }
  228.   }
  229.   // Bad parameters. No memory or bad data will all go here
  230.   null_value=1;
  231.   DBUG_RETURN(0);
  232. }
  235. void Item_func_aes_decrypt::fix_length_and_dec()
  236. {
  237.    max_length=args[0]->max_length;
  238.    maybe_null= 1;
  239. }
  242. /*
  243.   Concatenate args with the following premises:
  244.   If only one arg (which is ok), return value of arg
  245.   Don't reallocate val_str() if not absolute necessary.
  246. */
  248. String *Item_func_concat::val_str(String *str)
  249. {
  250.   DBUG_ASSERT(fixed == 1);
  251.   String *res,*res2,*use_as_buff;
  252.   uint i;
  254.   null_value=0;
  255.   if (!(res=args[0]->val_str(str)))
  256.     goto null;
  257.   use_as_buff= &tmp_value;
  258.   for (i=1 ; i < arg_count ; i++)
  259.   {
  260.     if (res->length() == 0)
  261.     {
  262.       if (!(res=args[i]->val_str(str)))
  263. goto null;
  264.     }
  265.     else
  266.     {
  267.       if (!(res2=args[i]->val_str(use_as_buff)))
  268. goto null;
  269.       if (res2->length() == 0)
  270. continue;
  271.       if (res->length()+res2->length() >
  272.   current_thd->variables.max_allowed_packet)
  273.       {
  274. push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  275.     ER_WARN_ALLOWED_PACKET_OVERFLOWED,
  276.     ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
  277.     current_thd->variables.max_allowed_packet);
  278. goto null;
  279.       }
  280.       if (res->alloced_length() >= res->length()+res2->length())
  281.       { // Use old buffer
  282. res->append(*res2);
  283.       }
  284.       else if (str->alloced_length() >= res->length()+res2->length())
  285.       {
  286. if (str == res2)
  287.   str->replace(0,0,*res);
  288. else
  289. {
  290.   str->copy(*res);
  291.   str->append(*res2);
  292. }
  293.         res= str;
  294.         use_as_buff= &tmp_value;
  295.       }
  296.       else if (res == &tmp_value)
  297.       {
  298. if (res->append(*res2)) // Must be a blob
  299.   goto null;
  300.       }
  301.       else if (res2 == &tmp_value)
  302.       { // This can happend only 1 time
  303. if (tmp_value.replace(0,0,*res))
  304.   goto null;
  305. res= &tmp_value;
  306. use_as_buff=str; // Put next arg here
  307.       }
  308.       else if (tmp_value.is_alloced() && res2->ptr() >= tmp_value.ptr() &&
  309.        res2->ptr() <= tmp_value.ptr() + tmp_value.alloced_length())
  310.       {
  311. /*
  312.   This happens really seldom:
  313.   In this case res2 is sub string of tmp_value.  We will
  314.   now work in place in tmp_value to set it to res | res2
  315. */
  316. /* Chop the last characters in tmp_value that isn't in res2 */
  317. tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
  318.  res2->length());
  319. /* Place res2 at start of tmp_value, remove chars before res2 */
  320. if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
  321.       *res))
  322.   goto null;
  323. res= &tmp_value;
  324. use_as_buff=str; // Put next arg here
  325.       }
  326.       else
  327.       { // Two big const strings
  328. if (tmp_value.alloc(max_length) ||
  329.     tmp_value.copy(*res) ||
  330.     tmp_value.append(*res2))
  331.   goto null;
  332. res= &tmp_value;
  333. use_as_buff=str;
  334.       }
  335.     }
  336.   }
  337.   res->set_charset(collation.collation);
  338.   return res;
  340. null:
  341.   null_value=1;
  342.   return 0;
  343. }
  346. void Item_func_concat::fix_length_and_dec()
  347. {
  348.   ulonglong max_result_length= 0;
  350.   if (agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV))
  351.     return;
  353.   for (uint i=0 ; i < arg_count ; i++)
  354.     max_result_length+= args[i]->max_length;
  356.   if (max_result_length >= MAX_BLOB_WIDTH)
  357.   {
  358.     max_result_length= MAX_BLOB_WIDTH;
  359.     maybe_null= 1;
  360.   }
  361.   max_length= (ulong) max_result_length;
  362. }
  364. /*
  365.   Function des_encrypt() by tonu@spam.ee & monty
  366.   Works only if compiled with OpenSSL library support.
  367.   This returns a binary string where first character is CHAR(128 | key-number).
  368.   If one uses a string key key_number is 127.
  369.   Encryption result is longer than original by formula:
  370.   new_length= org_length + (8-(org_length % 8))+1
  371. */
  373. String *Item_func_des_encrypt::val_str(String *str)
  374. {
  375.   DBUG_ASSERT(fixed == 1);
  376. #ifdef HAVE_OPENSSL
  377.   uint code= ER_WRONG_PARAMETERS_TO_PROCEDURE;
  378.   DES_cblock ivec;
  379.   struct st_des_keyblock keyblock;
  380.   struct st_des_keyschedule keyschedule;
  381.   const char *append_str="********";
  382.   uint key_number, res_length, tail;
  383.   String *res= args[0]->val_str(str);
  385.   if ((null_value= args[0]->null_value))
  386.     return 0;                                   // ENCRYPT(NULL) == NULL
  387.   if ((res_length=res->length()) == 0)
  388.     return &my_empty_string;
  390.   if (arg_count == 1)
  391.   {
  392.     /* Protect against someone doing FLUSH DES_KEY_FILE */
  393.     VOID(pthread_mutex_lock(&LOCK_des_key_file));
  394.     keyschedule= des_keyschedule[key_number=des_default_key];
  395.     VOID(pthread_mutex_unlock(&LOCK_des_key_file));
  396.   }
  397.   else if (args[1]->result_type() == INT_RESULT)
  398.   {
  399.     key_number= (uint) args[1]->val_int();
  400.     if (key_number > 9)
  401.       goto error;
  402.     VOID(pthread_mutex_lock(&LOCK_des_key_file));
  403.     keyschedule= des_keyschedule[key_number];
  404.     VOID(pthread_mutex_unlock(&LOCK_des_key_file));
  405.   }
  406.   else
  407.   {
  408.     String *keystr=args[1]->val_str(&tmp_value);
  409.     if (!keystr)
  410.       goto error;
  411.     key_number=127; // User key string
  413.     /* We make good 24-byte (168 bit) key from given plaintext key with MD5 */
  414.     bzero((char*) &ivec,sizeof(ivec));
  415.     EVP_BytesToKey(EVP_des_ede3_cbc(),EVP_md5(),NULL,
  416.    (uchar*) keystr->ptr(), (int) keystr->length(),
  417.    1, (uchar*) &keyblock,ivec);
  418.     DES_set_key_unchecked(&keyblock.key1,&keyschedule.ks1);
  419.     DES_set_key_unchecked(&keyblock.key2,&keyschedule.ks2);
  420.     DES_set_key_unchecked(&keyblock.key3,&keyschedule.ks3);
  421.   }
  423.   /*
  424.      The problem: DES algorithm requires original data to be in 8-bytes
  425.      chunks. Missing bytes get filled with '*'s and result of encryption
  426.      can be up to 8 bytes longer than original string. When decrypted,
  427.      we do not know the size of original string :(
  428.      We add one byte with value 0x1..0x8 as the last byte of the padded
  429.      string marking change of string length.
  430.   */
  432.   tail=  (8-(res_length) % 8); // 1..8 marking extra length
  433.   res_length+=tail;
  434.   code= ER_OUT_OF_RESOURCES;
  435.   if (tail && res->append(append_str, tail) || tmp_value.alloc(res_length+1))
  436.     goto error;
  437.   (*res)[res_length-1]=tail; // save extra length
  438.   tmp_value.length(res_length+1);
  439.   tmp_value[0]=(char) (128 | key_number);
  440.   // Real encryption
  441.   bzero((char*) &ivec,sizeof(ivec));
  442.   DES_ede3_cbc_encrypt((const uchar*) (res->ptr()),
  443.        (uchar*) (tmp_value.ptr()+1),
  444.        res_length,
  445.        &keyschedule.ks1,
  446.        &keyschedule.ks2,
  447.        &keyschedule.ks3,
  448.        &ivec, TRUE);
  449.   return &tmp_value;
  451. error:
  452.   push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
  453.                           code, ER(code),
  454.                           "des_encrypt");
  455. #else
  456.   push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
  457.                       ER_FEATURE_DISABLED, ER(ER_FEATURE_DISABLED),
  458.                       "des_encrypt","--with-openssl");
  459. #endif /* HAVE_OPENSSL */
  460.   null_value=1;
  461.   return 0;
  462. }
  465. String *Item_func_des_decrypt::val_str(String *str)
  466. {
  467.   DBUG_ASSERT(fixed == 1);
  468. #ifdef HAVE_OPENSSL
  469.   uint code= ER_WRONG_PARAMETERS_TO_PROCEDURE;
  470.   DES_key_schedule ks1, ks2, ks3;
  471.   DES_cblock ivec;
  472.   struct st_des_keyblock keyblock;
  473.   struct st_des_keyschedule keyschedule;
  474.   String *res= args[0]->val_str(str);
  475.   uint length,tail;
  477.   if ((null_value= args[0]->null_value))
  478.     return 0;
  479.   length= res->length();
  480.   if (length < 9 || (length % 8) != 1 || !((*res)[0] & 128))
  481.     return res; // Skip decryption if not encrypted
  483.   if (arg_count == 1) // If automatic uncompression
  484.   {
  485.     uint key_number=(uint) (*res)[0] & 127;
  486.     // Check if automatic key and that we have privilege to uncompress using it
  487.     if (!(current_thd->master_access & SUPER_ACL) || key_number > 9)
  488.       goto error;
  490.     VOID(pthread_mutex_lock(&LOCK_des_key_file));
  491.     keyschedule= des_keyschedule[key_number];
  492.     VOID(pthread_mutex_unlock(&LOCK_des_key_file));
  493.   }
  494.   else
  495.   {
  496.     // We make good 24-byte (168 bit) key from given plaintext key with MD5
  497.     String *keystr=args[1]->val_str(&tmp_value);
  498.     if (!keystr)
  499.       goto error;
  501.     bzero((char*) &ivec,sizeof(ivec));
  502.     EVP_BytesToKey(EVP_des_ede3_cbc(),EVP_md5(),NULL,
  503.    (uchar*) keystr->ptr(),(int) keystr->length(),
  504.    1,(uchar*) &keyblock,ivec);
  505.     // Here we set all 64-bit keys (56 effective) one by one
  506.     DES_set_key_unchecked(&keyblock.key1,&keyschedule.ks1);
  507.     DES_set_key_unchecked(&keyblock.key2,&keyschedule.ks2);
  508.     DES_set_key_unchecked(&keyblock.key3,&keyschedule.ks3);
  509.   }
  510.   code= ER_OUT_OF_RESOURCES;
  511.   if (tmp_value.alloc(length-1))
  512.     goto error;
  514.   bzero((char*) &ivec,sizeof(ivec));
  515.   DES_ede3_cbc_encrypt((const uchar*) res->ptr()+1,
  516.        (uchar*) (tmp_value.ptr()),
  517.        length-1,
  518.        &keyschedule.ks1,
  519.        &keyschedule.ks2,
  520.        &keyschedule.ks3,
  521.        &ivec, FALSE);
  522.   /* Restore old length of key */
  523.   if ((tail=(uint) (uchar) tmp_value[length-2]) > 8)
  524.     goto wrong_key;      // Wrong key
  525.   tmp_value.length(length-1-tail);
  526.   return &tmp_value;
  528. error:
  529.   push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
  530.                           code, ER(code),
  531.                           "des_decrypt");
  532. wrong_key:
  533. #else
  534.   push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
  535.                       ER_FEATURE_DISABLED, ER(ER_FEATURE_DISABLED),
  536.                       "des_decrypt","--with-openssl");
  537. #endif /* HAVE_OPENSSL */
  538.   null_value=1;
  539.   return 0;
  540. }
  543. /*
  544.   concat with separator. First arg is the separator
  545.   concat_ws takes at least two arguments.
  546. */
  548. String *Item_func_concat_ws::val_str(String *str)
  549. {
  550.   DBUG_ASSERT(fixed == 1);
  551.   char tmp_str_buff[10];
  552.   String tmp_sep_str(tmp_str_buff, sizeof(tmp_str_buff),default_charset_info),
  553.          *sep_str, *res, *res2,*use_as_buff;
  554.   uint i;
  556.   null_value=0;
  557.   if (!(sep_str= args[0]->val_str(&tmp_sep_str)))
  558.     goto null;
  560.   use_as_buff= &tmp_value;
  561.   str->length(0); // QQ; Should be removed
  562.   res=str;
  564.   // Skip until non-null argument is found.
  565.   // If not, return the empty string
  566.   for (i=1; i < arg_count; i++)
  567.     if ((res= args[i]->val_str(str)))
  568.       break;
  569.   if (i ==  arg_count)
  570.     return &my_empty_string;
  572.   for (i++; i < arg_count ; i++)
  573.   {
  574.     if (!(res2= args[i]->val_str(use_as_buff)))
  575.       continue; // Skip NULL
  577.     if (res->length() + sep_str->length() + res2->length() >
  578. current_thd->variables.max_allowed_packet)
  579.     {
  580.       push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  581.   ER_WARN_ALLOWED_PACKET_OVERFLOWED,
  582.   ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
  583.   current_thd->variables.max_allowed_packet);
  584.       goto null;
  585.     }
  586.     if (res->alloced_length() >=
  587. res->length() + sep_str->length() + res2->length())
  588.     { // Use old buffer
  589.       res->append(*sep_str); // res->length() > 0 always
  590.       res->append(*res2);
  591.     }
  592.     else if (str->alloced_length() >=
  593.      res->length() + sep_str->length() + res2->length())
  594.     {
  595.       /* We have room in str;  We can't get any errors here */
  596.       if (str == res2)
  597.       { // This is quote uncommon!
  598. str->replace(0,0,*sep_str);
  599. str->replace(0,0,*res);
  600.       }
  601.       else
  602.       {
  603. str->copy(*res);
  604. str->append(*sep_str);
  605. str->append(*res2);
  606.       }
  607.       res=str;
  608.       use_as_buff= &tmp_value;
  609.     }
  610.     else if (res == &tmp_value)
  611.     {
  612.       if (res->append(*sep_str) || res->append(*res2))
  613. goto null; // Must be a blob
  614.     }
  615.     else if (res2 == &tmp_value)
  616.     { // This can happend only 1 time
  617.       if (tmp_value.replace(0,0,*sep_str) || tmp_value.replace(0,0,*res))
  618. goto null;
  619.       res= &tmp_value;
  620.       use_as_buff=str; // Put next arg here
  621.     }
  622.     else if (tmp_value.is_alloced() && res2->ptr() >= tmp_value.ptr() &&
  623.      res2->ptr() < tmp_value.ptr() + tmp_value.alloced_length())
  624.     {
  625.       /*
  626. This happens really seldom:
  627. In this case res2 is sub string of tmp_value.  We will
  628. now work in place in tmp_value to set it to res | sep_str | res2
  629.       */
  630.       /* Chop the last characters in tmp_value that isn't in res2 */
  631.       tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
  632.        res2->length());
  633.       /* Place res2 at start of tmp_value, remove chars before res2 */
  634.       if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
  635.     *res) ||
  636.   tmp_value.replace(res->length(),0, *sep_str))
  637. goto null;
  638.       res= &tmp_value;
  639.       use_as_buff=str; // Put next arg here
  640.     }
  641.     else
  642.     { // Two big const strings
  643.       if (tmp_value.alloc(max_length) ||
  644.   tmp_value.copy(*res) ||
  645.   tmp_value.append(*sep_str) ||
  646.   tmp_value.append(*res2))
  647. goto null;
  648.       res= &tmp_value;
  649.       use_as_buff=str;
  650.     }
  651.   }
  652.   res->set_charset(collation.collation);
  653.   return res;
  655. null:
  656.   null_value=1;
  657.   return 0;
  658. }
  661. void Item_func_concat_ws::fix_length_and_dec()
  662. {
  663.   ulonglong max_result_length;
  665.   if (agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV))
  666.     return;
  668.   /*
  669.      arg_count cannot be less than 2,
  670.      it is done on parser level in sql_yacc.yy
  671.      so, (arg_count - 2) is safe here.
  672.   */
  673.   max_result_length= (ulonglong) args[0]->max_length * (arg_count - 2);
  674.   for (uint i=1 ; i < arg_count ; i++)
  675.     max_result_length+=args[i]->max_length;
  677.   if (max_result_length >= MAX_BLOB_WIDTH)
  678.   {
  679.     max_result_length= MAX_BLOB_WIDTH;
  680.     maybe_null= 1;
  681.   }
  682.   max_length= (ulong) max_result_length;
  683. }
  686. String *Item_func_reverse::val_str(String *str)
  687. {
  688.   DBUG_ASSERT(fixed == 1);
  689.   String *res = args[0]->val_str(str);
  690.   char *ptr,*end;
  692.   if ((null_value=args[0]->null_value))
  693.     return 0;
  694.   /* An empty string is a special case as the string pointer may be null */
  695.   if (!res->length())
  696.     return &my_empty_string;
  697.   res=copy_if_not_alloced(str,res,res->length());
  698.   ptr = (char *) res->ptr();
  699.   end=ptr+res->length();
  700. #ifdef USE_MB
  701.   if (use_mb(res->charset()))
  702.   {
  703.     String tmpstr;
  704.     tmpstr.copy(*res);
  705.     char *tmp = (char *) tmpstr.ptr() + tmpstr.length();
  706.     register uint32 l;
  707.     while (ptr < end)
  708.     {
  709.       if ((l=my_ismbchar(res->charset(), ptr,end)))
  710.         tmp-=l, memcpy(tmp,ptr,l), ptr+=l;
  711.       else
  712.         *--tmp=*ptr++;
  713.     }
  714.     memcpy((char *) res->ptr(),(char *) tmpstr.ptr(), res->length());
  715.   }
  716.   else
  717. #endif /* USE_MB */
  718.   {
  719.     char tmp;
  720.     while (ptr < end)
  721.     {
  722.       tmp=*ptr;
  723.       *ptr++=*--end;
  724.       *end=tmp;
  725.     }
  726.   }
  727.   return res;
  728. }
  731. void Item_func_reverse::fix_length_and_dec()
  732. {
  733.   collation.set(args[0]->collation);
  734.   max_length = args[0]->max_length;
  735. }
  737. /*
  738. ** Replace all occurences of string2 in string1 with string3.
  739. ** Don't reallocate val_str() if not needed
  740. */
  742. /* TODO: Fix that this works with binary strings when using USE_MB */
  744. String *Item_func_replace::val_str(String *str)
  745. {
  746.   DBUG_ASSERT(fixed == 1);
  747.   String *res,*res2,*res3;
  748.   int offset;
  749.   uint from_length,to_length;
  750.   bool alloced=0;
  751. #ifdef USE_MB
  752.   const char *ptr,*end,*strend,*search,*search_end;
  753.   register uint32 l;
  754.   bool binary_cmp;
  755. #endif
  757.   null_value=0;
  758.   res=args[0]->val_str(str);
  759.   if (args[0]->null_value)
  760.     goto null;
  761.   res2=args[1]->val_str(&tmp_value);
  762.   if (args[1]->null_value)
  763.     goto null;
  765.   res->set_charset(collation.collation);
  767. #ifdef USE_MB
  768.   binary_cmp = ((res->charset()->state & MY_CS_BINSORT) || !use_mb(res->charset()));
  769. #endif
  771.   if (res2->length() == 0)
  772.     return res;
  773. #ifndef USE_MB
  774.   if ((offset=res->strstr(*res2)) < 0)
  775.     return res;
  776. #else
  777.   offset=0;
  778.   if (binary_cmp && (offset=res->strstr(*res2)) < 0)
  779.     return res;
  780. #endif
  781.   if (!(res3=args[2]->val_str(&tmp_value2)))
  782.     goto null;
  783.   from_length= res2->length();
  784.   to_length=   res3->length();
  786. #ifdef USE_MB
  787.   if (!binary_cmp)
  788.   {
  789.     search=res2->ptr();
  790.     search_end=search+from_length;
  791. redo:
  792.     ptr=res->ptr()+offset;
  793.     strend=res->ptr()+res->length();
  794.     end=strend-from_length+1;
  795.     while (ptr < end)
  796.     {
  797.         if (*ptr == *search)
  798.         {
  799.           register char *i,*j;
  800.           i=(char*) ptr+1; j=(char*) search+1;
  801.           while (j != search_end)
  802.             if (*i++ != *j++) goto skip;
  803.           offset= (int) (ptr-res->ptr());
  804.           if (res->length()-from_length + to_length >
  805.       current_thd->variables.max_allowed_packet)
  806.   {
  807.     push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  808. ER_WARN_ALLOWED_PACKET_OVERFLOWED,
  809. ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
  810. func_name(),
  811. current_thd->variables.max_allowed_packet);
  813.             goto null;
  814.   }
  815.           if (!alloced)
  816.           {
  817.             alloced=1;
  818.             res=copy_if_not_alloced(str,res,res->length()+to_length);
  819.           }
  820.           res->replace((uint) offset,from_length,*res3);
  821.   offset+=(int) to_length;
  822.           goto redo;
  823.         }
  824. skip:
  825.         if ((l=my_ismbchar(res->charset(), ptr,strend))) ptr+=l;
  826.         else ++ptr;
  827.     }
  828.   }
  829.   else
  830. #endif /* USE_MB */
  831.     do
  832.     {
  833.       if (res->length()-from_length + to_length >
  834.   current_thd->variables.max_allowed_packet)
  835.       {
  836. push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  837.     ER_WARN_ALLOWED_PACKET_OVERFLOWED,
  838.     ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
  839.     current_thd->variables.max_allowed_packet);
  840.         goto null;
  841.       }
  842.       if (!alloced)
  843.       {
  844.         alloced=1;
  845.         res=copy_if_not_alloced(str,res,res->length()+to_length);
  846.       }
  847.       res->replace((uint) offset,from_length,*res3);
  848.       offset+=(int) to_length;
  849.     }
  850.     while ((offset=res->strstr(*res2,(uint) offset)) >= 0);
  851.   return res;
  853. null:
  854.   null_value=1;
  855.   return 0;
  856. }
  859. void Item_func_replace::fix_length_and_dec()
  860. {
  861.   ulonglong max_result_length= args[0]->max_length;
  862.   int diff=(int) (args[2]->max_length - args[1]->max_length);
  863.   if (diff > 0 && args[1]->max_length)
  864.   { // Calculate of maxreplaces
  865.     ulonglong max_substrs= max_result_length/args[1]->max_length;
  866.     max_result_length+= max_substrs * (uint) diff;
  867.   }
  868.   if (max_result_length >= MAX_BLOB_WIDTH)
  869.   {
  870.     max_result_length= MAX_BLOB_WIDTH;
  871.     maybe_null= 1;
  872.   }
  873.   max_length= (ulong) max_result_length;
  874.   
  875.   if (agg_arg_charsets(collation, args, 3, MY_COLL_CMP_CONV))
  876.     return;
  877. }
  880. String *Item_func_insert::val_str(String *str)
  881. {
  882.   DBUG_ASSERT(fixed == 1);
  883.   String *res,*res2;
  884.   uint start,length;
  886.   null_value=0;
  887.   res=args[0]->val_str(str);
  888.   res2=args[3]->val_str(&tmp_value);
  889.   start=(uint) args[1]->val_int()-1;
  890.   length=(uint) args[2]->val_int();
  891.   if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
  892.       args[3]->null_value)
  893.     goto null; /* purecov: inspected */
  894.   start=res->charpos(start);
  895.   length=res->charpos(length,start);
  896.   if (start > res->length()+1)
  897.     return res; // Wrong param; skip insert
  898.   if (length > res->length()-start)
  899.     length=res->length()-start;
  900.   if (res->length() - length + res2->length() >
  901.       current_thd->variables.max_allowed_packet)
  902.   {
  903.     push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  904. ER_WARN_ALLOWED_PACKET_OVERFLOWED,
  905. ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
  906. func_name(), current_thd->variables.max_allowed_packet);
  907.     goto null;
  908.   }
  909.   res=copy_if_not_alloced(str,res,res->length());
  910.   res->replace(start,length,*res2);
  911.   return res;
  912. null:
  913.   null_value=1;
  914.   return 0;
  915. }
  918. void Item_func_insert::fix_length_and_dec()
  919. {
  920.   Item *cargs[2];
  921.   ulonglong max_result_length;
  923.   cargs[0]= args[0];
  924.   cargs[1]= args[3];
  925.   if (agg_arg_charsets(collation, cargs, 2, MY_COLL_ALLOW_CONV))
  926.     return;
  927.   args[0]= cargs[0];
  928.   args[3]= cargs[1];
  929.   max_result_length= ((ulonglong) args[0]->max_length+
  930.                       (ulonglong) args[3]->max_length);
  931.   if (max_result_length >= MAX_BLOB_WIDTH)
  932.   {
  933.     max_result_length= MAX_BLOB_WIDTH;
  934.     maybe_null= 1;
  935.   }
  936.   max_length= (ulong) max_result_length;
  937. }
  940. String *Item_func_lcase::val_str(String *str)
  941. {
  942.   DBUG_ASSERT(fixed == 1);
  943.   String *res;
  944.   if (!(res=args[0]->val_str(str)))
  945.   {
  946.     null_value=1; /* purecov: inspected */
  947.     return 0; /* purecov: inspected */
  948.   }
  949.   null_value=0;
  950.   res=copy_if_not_alloced(str,res,res->length());
  951.   res->casedn();
  952.   return res;
  953. }
  956. String *Item_func_ucase::val_str(String *str)
  957. {
  958.   DBUG_ASSERT(fixed == 1);
  959.   String *res;
  960.   if (!(res=args[0]->val_str(str)))
  961.   {
  962.     null_value=1; /* purecov: inspected */
  963.     return 0; /* purecov: inspected */
  964.   }
  965.   null_value=0;
  966.   res=copy_if_not_alloced(str,res,res->length());
  967.   res->caseup();
  968.   return res;
  969. }
  972. String *Item_func_left::val_str(String *str)
  973. {
  974.   DBUG_ASSERT(fixed == 1);
  975.   String *res  =args[0]->val_str(str);
  976.   long length  =(long) args[1]->val_int();
  977.   uint char_pos;
  979.   if ((null_value=args[0]->null_value))
  980.     return 0;
  981.   if (length <= 0)
  982.     return &my_empty_string;
  983.   if (res->length() <= (uint) length ||
  984.       res->length() <= (char_pos= res->charpos(length)))
  985.     return res;
  987.   tmp_value.set(*res, 0, char_pos);
  988.   return &tmp_value;
  989. }
  992. void Item_str_func::left_right_max_length()
  993. {
  994.   max_length=args[0]->max_length;
  995.   if (args[1]->const_item())
  996.   {
  997.     int length=(int) args[1]->val_int()*collation.collation->mbmaxlen;
  998.     if (length <= 0)
  999.       max_length=0;
  1000.     else
  1001.       set_if_smaller(max_length,(uint) length);
  1002.   }
  1003. }
  1006. void Item_func_left::fix_length_and_dec()
  1007. {
  1008.   collation.set(args[0]->collation);
  1009.   left_right_max_length();
  1010. }
  1013. String *Item_func_right::val_str(String *str)
  1014. {
  1015.   DBUG_ASSERT(fixed == 1);
  1016.   String *res  =args[0]->val_str(str);
  1017.   long length  =(long) args[1]->val_int();
  1019.   if ((null_value=args[0]->null_value))
  1020.     return 0; /* purecov: inspected */
  1021.   if (length <= 0)
  1022.     return &my_empty_string; /* purecov: inspected */
  1023.   if (res->length() <= (uint) length)
  1024.     return res; /* purecov: inspected */
  1026.   uint start=res->numchars();
  1027.   if (start <= (uint) length)
  1028.     return res;
  1029.   start=res->charpos(start - (uint) length);
  1030.   tmp_value.set(*res,start,res->length()-start);
  1031.   return &tmp_value;
  1032. }
  1035. void Item_func_right::fix_length_and_dec()
  1036. {
  1037.   collation.set(args[0]->collation);
  1038.   left_right_max_length();
  1039. }
  1042. String *Item_func_substr::val_str(String *str)
  1043. {
  1044.   DBUG_ASSERT(fixed == 1);
  1045.   String *res  = args[0]->val_str(str);
  1046.   int32 start = (int32) args[1]->val_int();
  1047.   int32 length = arg_count == 3 ? (int32) args[2]->val_int() : INT_MAX32;
  1048.   int32 tmp_length;
  1050.   if ((null_value=(args[0]->null_value || args[1]->null_value ||
  1051.    (arg_count == 3 && args[2]->null_value))))
  1052.     return 0; /* purecov: inspected */
  1053.   start= (int32)((start < 0) ? res->numchars() + start : start -1);
  1054.   start=res->charpos(start);
  1055.   length=res->charpos(length,start);
  1056.   if (start < 0 || (uint) start+1 > res->length() || length <= 0)
  1057.     return &my_empty_string;
  1059.   tmp_length=(int32) res->length()-start;
  1060.   length=min(length,tmp_length);
  1062.   if (!start && res->length() == (uint) length)
  1063.     return res;
  1064.   tmp_value.set(*res,(uint) start,(uint) length);
  1065.   return &tmp_value;
  1066. }
  1069. void Item_func_substr::fix_length_and_dec()
  1070. {
  1071.   max_length=args[0]->max_length;
  1073.   collation.set(args[0]->collation);
  1074.   if (args[1]->const_item())
  1075.   {
  1076.     int32 start= (int32) args[1]->val_int();
  1077.     start= (int32)((start < 0) ? max_length + start : start - 1);
  1078.     if (start < 0 || start >= (int32) max_length)
  1079.       max_length=0; /* purecov: inspected */
  1080.     else
  1081.       max_length-= (uint) start;
  1082.   }
  1083.   if (arg_count == 3 && args[2]->const_item())
  1084.   {
  1085.     int32 length= (int32) args[2]->val_int() * collation.collation->mbmaxlen;
  1086.     if (length <= 0)
  1087.       max_length=0; /* purecov: inspected */
  1088.     else
  1089.       set_if_smaller(max_length,(uint) length);
  1090.   }
  1091. }
  1094. void Item_func_substr_index::fix_length_and_dec()
  1095. { 
  1096.   max_length= args[0]->max_length;
  1098.   if (agg_arg_charsets(collation, args, 2, MY_COLL_CMP_CONV))
  1099.     return;
  1100. }
  1103. String *Item_func_substr_index::val_str(String *str)
  1104. {
  1105.   DBUG_ASSERT(fixed == 1);
  1106.   String *res =args[0]->val_str(str);
  1107.   String *delimeter =args[1]->val_str(&tmp_value);
  1108.   int32 count = (int32) args[2]->val_int();
  1109.   uint offset;
  1111.   if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
  1112.   { // string and/or delim are null
  1113.     null_value=1;
  1114.     return 0;
  1115.   }
  1116.   null_value=0;
  1117.   uint delimeter_length=delimeter->length();
  1118.   if (!res->length() || !delimeter_length || !count)
  1119.     return &my_empty_string; // Wrong parameters
  1121.   res->set_charset(collation.collation);
  1123. #ifdef USE_MB
  1124.   if (use_mb(res->charset()))
  1125.   {
  1126.     const char *ptr=res->ptr();
  1127.     const char *strend = ptr+res->length();
  1128.     const char *end=strend-delimeter_length+1;
  1129.     const char *search=delimeter->ptr();
  1130.     const char *search_end=search+delimeter_length;
  1131.     int32 n=0,c=count,pass;
  1132.     register uint32 l;
  1133.     for (pass=(count>0);pass<2;++pass)
  1134.     {
  1135.       while (ptr < end)
  1136.       {
  1137.         if (*ptr == *search)
  1138.         {
  1139.   register char *i,*j;
  1140.   i=(char*) ptr+1; j=(char*) search+1;
  1141.   while (j != search_end)
  1142.     if (*i++ != *j++) goto skip;
  1143.   if (pass==0) ++n;
  1144.   else if (!--c) break;
  1145.   ptr+=delimeter_length;
  1146.   continue;
  1147. }
  1148.     skip:
  1149.         if ((l=my_ismbchar(res->charset(), ptr,strend))) ptr+=l;
  1150.         else ++ptr;
  1151.       } /* either not found or got total number when count<0 */
  1152.       if (pass == 0) /* count<0 */
  1153.       {
  1154.         c+=n+1;
  1155.         if (c<=0) return res; /* not found, return original string */
  1156.         ptr=res->ptr();
  1157.       }
  1158.       else
  1159.       {
  1160.         if (c) return res; /* Not found, return original string */
  1161.         if (count>0) /* return left part */
  1162.         {
  1163.   tmp_value.set(*res,0,(ulong) (ptr-res->ptr()));
  1164.         }
  1165.         else /* return right part */
  1166.         {
  1167.   ptr+=delimeter_length;
  1168.   tmp_value.set(*res,(ulong) (ptr-res->ptr()), (ulong) (strend-ptr));
  1169.         }
  1170.       }
  1171.     }
  1172.   }
  1173.   else
  1174. #endif /* USE_MB */
  1175.   {
  1176.     if (count > 0)
  1177.     { // start counting from the beginning
  1178.       for (offset=0 ;; offset+=delimeter_length)
  1179.       {
  1180. if ((int) (offset=res->strstr(*delimeter,offset)) < 0)
  1181.   return res; // Didn't find, return org string
  1182. if (!--count)
  1183. {
  1184.   tmp_value.set(*res,0,offset);
  1185.   break;
  1186. }
  1187.       }
  1188.     }
  1189.     else
  1190.     {
  1191.       /*
  1192.         Negative index, start counting at the end
  1193.       */
  1194.       for (offset=res->length(); offset ;)
  1195.       {
  1196.         /* 
  1197.           this call will result in finding the position pointing to one 
  1198.           address space less than where the found substring is located
  1199.           in res
  1200.         */
  1201. if ((int) (offset=res->strrstr(*delimeter,offset)) < 0)
  1202.   return res; // Didn't find, return org string
  1203.         /*
  1204.           At this point, we've searched for the substring
  1205.           the number of times as supplied by the index value
  1206.         */
  1207. if (!++count)
  1208. {
  1209.   offset+=delimeter_length;
  1210.   tmp_value.set(*res,offset,res->length()- offset);
  1211.   break;
  1212. }
  1213.       }
  1214.     }
  1215.   }
  1216.   return (&tmp_value);
  1217. }
  1219. /*
  1220. ** The trim functions are extension to ANSI SQL because they trim substrings
  1221. ** They ltrim() and rtrim() functions are optimized for 1 byte strings
  1222. ** They also return the original string if possible, else they return
  1223. ** a substring that points at the original string.
  1224. */
  1227. String *Item_func_ltrim::val_str(String *str)
  1228. {
  1229.   DBUG_ASSERT(fixed == 1);
  1230.   String *res  =args[0]->val_str(str);
  1231.   if ((null_value=args[0]->null_value))
  1232.     return 0; /* purecov: inspected */
  1233.   char buff[MAX_FIELD_WIDTH];
  1234.   String tmp(buff,sizeof(buff),res->charset());
  1235.   String *remove_str= (arg_count==2) ? args[1]->val_str(&tmp) : &remove;
  1236.   uint remove_length;
  1237.   LINT_INIT(remove_length);
  1239.   if (!remove_str || (remove_length=remove_str->length()) == 0 ||
  1240.       remove_length > res->length())
  1241.     return res;
  1243.   char *ptr=(char*) res->ptr();
  1244.   char *end=ptr+res->length();
  1245.   if (remove_length == 1)
  1246.   {
  1247.     char chr=(*remove_str)[0];
  1248.     while (ptr != end && *ptr == chr)
  1249.       ptr++;
  1250.   }
  1251.   else
  1252.   {
  1253.     const char *r_ptr=remove_str->ptr();
  1254.     end-=remove_length;
  1255.     while (ptr <= end && !memcmp(ptr, r_ptr, remove_length))
  1256.       ptr+=remove_length;
  1257.     end+=remove_length;
  1258.   }
  1259.   if (ptr == res->ptr())
  1260.     return res;
  1261.   tmp_value.set(*res,(uint) (ptr - res->ptr()),(uint) (end-ptr));
  1262.   return &tmp_value;
  1263. }
  1266. String *Item_func_rtrim::val_str(String *str)
  1267. {
  1268.   DBUG_ASSERT(fixed == 1);
  1269.   String *res  =args[0]->val_str(str);
  1270.   if ((null_value=args[0]->null_value))
  1271.     return 0; /* purecov: inspected */
  1272.   char buff[MAX_FIELD_WIDTH];
  1273.   String tmp(buff,sizeof(buff),res->charset());
  1274.   String *remove_str= (arg_count==2) ? args[1]->val_str(&tmp) : &remove;
  1275.   uint remove_length;
  1276.   LINT_INIT(remove_length);
  1278.   if (!remove_str || (remove_length=remove_str->length()) == 0 ||
  1279.       remove_length > res->length())
  1280.     return res;
  1282.   char *ptr=(char*) res->ptr();
  1283.   char *end=ptr+res->length();
  1284. #ifdef USE_MB
  1285.   char *p=ptr;
  1286.   register uint32 l;
  1287. #endif
  1288.   if (remove_length == 1)
  1289.   {
  1290.     char chr=(*remove_str)[0];
  1291. #ifdef USE_MB
  1292.     if (use_mb(res->charset()))
  1293.     {
  1294.       while (ptr < end)
  1295.       {
  1296. if ((l=my_ismbchar(res->charset(), ptr,end))) ptr+=l,p=ptr;
  1297. else ++ptr;
  1298.       }
  1299.       ptr=p;
  1300.     }
  1301. #endif
  1302.     while (ptr != end  && end[-1] == chr)
  1303.       end--;
  1304.   }
  1305.   else
  1306.   {
  1307.     const char *r_ptr=remove_str->ptr();
  1308. #ifdef USE_MB
  1309.     if (use_mb(res->charset()))
  1310.     {
  1311.   loop:
  1312.       while (ptr + remove_length < end)
  1313.       {
  1314. if ((l=my_ismbchar(res->charset(), ptr,end))) ptr+=l;
  1315. else ++ptr;
  1316.       }
  1317.       if (ptr + remove_length == end && !memcmp(ptr,r_ptr,remove_length))
  1318.       {
  1319. end-=remove_length;
  1320. ptr=p;
  1321. goto loop;
  1322.       }
  1323.     }
  1324.     else
  1325. #endif /* USE_MB */
  1326.     {
  1327.       while (ptr + remove_length <= end &&
  1328.      !memcmp(end-remove_length, r_ptr, remove_length))
  1329. end-=remove_length;
  1330.     }
  1331.   }
  1332.   if (end == res->ptr()+res->length())
  1333.     return res;
  1334.   tmp_value.set(*res,0,(uint) (end-res->ptr()));
  1335.   return &tmp_value;
  1336. }
  1339. String *Item_func_trim::val_str(String *str)
  1340. {
  1341.   DBUG_ASSERT(fixed == 1);
  1342.   String *res  =args[0]->val_str(str);
  1343.   if ((null_value=args[0]->null_value))
  1344.     return 0; /* purecov: inspected */
  1345.   char buff[MAX_FIELD_WIDTH];
  1346.   String tmp(buff,sizeof(buff),res->charset());
  1347.   uint remove_length;
  1348.   LINT_INIT(remove_length);
  1349.   String *remove_str; /* The string to remove from res. */
  1351.   if (arg_count == 2)
  1352.   {
  1353.     remove_str= args[1]->val_str(&tmp);
  1354.     if ((null_value= args[1]->null_value))
  1355.       return 0;
  1356.   }
  1357.   else
  1358.     remove_str= &remove; /* Default value. */
  1360.   if (!remove_str || (remove_length=remove_str->length()) == 0 ||
  1361.       remove_length > res->length())
  1362.     return res;
  1364.   char *ptr=(char*) res->ptr();
  1365.   char *end=ptr+res->length();
  1366.   const char *r_ptr=remove_str->ptr();
  1367.   while (ptr+remove_length <= end && !memcmp(ptr,r_ptr,remove_length))
  1368.     ptr+=remove_length;
  1369. #ifdef USE_MB
  1370.   if (use_mb(res->charset()))
  1371.   {
  1372.     char *p=ptr;
  1373.     register uint32 l;
  1374.  loop:
  1375.     while (ptr + remove_length < end)
  1376.     {
  1377.       if ((l=my_ismbchar(res->charset(), ptr,end))) ptr+=l;
  1378.       else ++ptr;
  1379.     }
  1380.     if (ptr + remove_length == end && !memcmp(ptr,r_ptr,remove_length))
  1381.     {
  1382.       end-=remove_length;
  1383.       ptr=p;
  1384.       goto loop;
  1385.     }
  1386.     ptr=p;
  1387.   }
  1388.   else
  1389. #endif /* USE_MB */
  1390.   {
  1391.     while (ptr + remove_length <= end &&
  1392.    !memcmp(end-remove_length,r_ptr,remove_length))
  1393.       end-=remove_length;
  1394.   }
  1395.   if (ptr == res->ptr() && end == ptr+res->length())
  1396.     return res;
  1397.   tmp_value.set(*res,(uint) (ptr - res->ptr()),(uint) (end-ptr));
  1398.   return &tmp_value;
  1399. }
  1401. void Item_func_trim::fix_length_and_dec()
  1402. {
  1403.   max_length= args[0]->max_length;
  1404.   if (arg_count == 1)
  1405.   {
  1406.     collation.set(args[0]->collation);
  1407.     remove.set_charset(collation.collation);
  1408.     remove.set_ascii(" ",1);
  1409.   }
  1410.   else
  1411.   {
  1412.     Item *cargs[2];
  1413.     cargs[0]= args[1];
  1414.     cargs[1]= args[0];
  1415.     if (agg_arg_charsets(collation, cargs, 2, MY_COLL_CMP_CONV))
  1416.       return;
  1417.     args[0]= cargs[1];
  1418.     args[1]= cargs[0];
  1419.   }
  1420. }
  1423. /* Item_func_password */
  1425. String *Item_func_password::val_str(String *str)
  1426. {
  1427.   DBUG_ASSERT(fixed == 1);
  1428.   String *res= args[0]->val_str(str); 
  1429.   if ((null_value=args[0]->null_value))
  1430.     return 0;
  1431.   if (res->length() == 0)
  1432.     return &my_empty_string;
  1433.   make_scrambled_password(tmp_value, res->c_ptr());
  1434.   str->set(tmp_value, SCRAMBLED_PASSWORD_CHAR_LENGTH, res->charset());
  1435.   return str;
  1436. }
  1438. char *Item_func_password::alloc(THD *thd, const char *password)
  1439. {
  1440.   char *buff= (char *) thd->alloc(SCRAMBLED_PASSWORD_CHAR_LENGTH+1);
  1441.   if (buff)
  1442.     make_scrambled_password(buff, password);
  1443.   return buff;
  1444. }
  1446. /* Item_func_old_password */
  1448. String *Item_func_old_password::val_str(String *str)
  1449. {
  1450.   DBUG_ASSERT(fixed == 1);
  1451.   String *res= args[0]->val_str(str);
  1452.   if ((null_value=args[0]->null_value))
  1453.     return 0;
  1454.   if (res->length() == 0)
  1455.     return &my_empty_string;
  1456.   make_scrambled_password_323(tmp_value, res->c_ptr());
  1457.   str->set(tmp_value, SCRAMBLED_PASSWORD_CHAR_LENGTH_323, res->charset());
  1458.   return str;
  1459. }
  1461. char *Item_func_old_password::alloc(THD *thd, const char *password)
  1462. {
  1463.   char *buff= (char *) thd->alloc(SCRAMBLED_PASSWORD_CHAR_LENGTH_323+1);
  1464.   if (buff)
  1465.     make_scrambled_password_323(buff, password);
  1466.   return buff;
  1467. }
  1470. #define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
  1472. String *Item_func_encrypt::val_str(String *str)
  1473. {
  1474.   DBUG_ASSERT(fixed == 1);
  1475.   String *res  =args[0]->val_str(str);
  1477. #ifdef HAVE_CRYPT
  1478.   char salt[3],*salt_ptr;
  1479.   if ((null_value=args[0]->null_value))
  1480.     return 0;
  1481.   if (res->length() == 0)
  1482.     return &my_empty_string;
  1484.   if (arg_count == 1)
  1485.   { // generate random salt
  1486.     time_t timestamp=current_thd->query_start();
  1487.     salt[0] = bin_to_ascii( (ulong) timestamp & 0x3f);
  1488.     salt[1] = bin_to_ascii(( (ulong) timestamp >> 5) & 0x3f);
  1489.     salt[2] = 0;
  1490.     salt_ptr=salt;
  1491.   }
  1492.   else
  1493.   { // obtain salt from the first two bytes
  1494.     String *salt_str=args[1]->val_str(&tmp_value);
  1495.     if ((null_value= (args[1]->null_value || salt_str->length() < 2)))
  1496.       return 0;
  1497.     salt_ptr= salt_str->c_ptr();
  1498.   }
  1499.   pthread_mutex_lock(&LOCK_crypt);
  1500.   char *tmp= crypt(res->c_ptr(),salt_ptr);
  1501.   if (!tmp)
  1502.   {
  1503.     pthread_mutex_unlock(&LOCK_crypt);
  1504.     null_value= 1;
  1505.     return 0;
  1506.   }
  1507.   str->set(tmp,(uint) strlen(tmp),res->charset());
  1508.   str->copy();
  1509.   pthread_mutex_unlock(&LOCK_crypt);
  1510.   return str;
  1511. #else
  1512.   null_value=1;
  1513.   return 0;
  1514. #endif /* HAVE_CRYPT */
  1515. }
  1517. void Item_func_encode::fix_length_and_dec()
  1518. {
  1519.   max_length=args[0]->max_length;
  1520.   maybe_null=args[0]->maybe_null;
  1521.   collation.set(&my_charset_bin);
  1522. }
  1524. String *Item_func_encode::val_str(String *str)
  1525. {
  1526.   DBUG_ASSERT(fixed == 1);
  1527.   String *res;
  1528.   if (!(res=args[0]->val_str(str)))
  1529.   {
  1530.     null_value=1; /* purecov: inspected */
  1531.     return 0; /* purecov: inspected */
  1532.   }
  1533.   null_value=0;
  1534.   res=copy_if_not_alloced(str,res,res->length());
  1535.   sql_crypt.init();
  1536.   sql_crypt.encode((char*) res->ptr(),res->length());
  1537.   res->set_charset(&my_charset_bin);
  1538.   return res;
  1539. }
  1541. String *Item_func_decode::val_str(String *str)
  1542. {
  1543.   DBUG_ASSERT(fixed == 1);
  1544.   String *res;
  1545.   if (!(res=args[0]->val_str(str)))
  1546.   {
  1547.     null_value=1; /* purecov: inspected */
  1548.     return 0; /* purecov: inspected */
  1549.   }
  1550.   null_value=0;
  1551.   res=copy_if_not_alloced(str,res,res->length());
  1552.   sql_crypt.init();
  1553.   sql_crypt.decode((char*) res->ptr(),res->length());
  1554.   return res;
  1555. }
  1558. Item *Item_func_sysconst::safe_charset_converter(CHARSET_INFO *tocs)
  1559. {
  1560.   Item_string *conv;
  1561.   uint conv_errors;
  1562.   String tmp, cstr, *ostr= val_str(&tmp);
  1563.   cstr.copy(ostr->ptr(), ostr->length(), ostr->charset(), tocs, &conv_errors);
  1564.   if (conv_errors || !(conv= new Item_string(cstr.ptr(), cstr.length(),
  1565.                                              cstr.charset(),
  1566.                                              collation.derivation)))
  1567.   {
  1568.     return NULL;
  1569.   }
  1570.   conv->str_value.copy();
  1571.   conv->str_value.shrink_to_length();
  1572.   return conv;
  1573. }
  1576. String *Item_func_database::val_str(String *str)
  1577. {
  1578.   DBUG_ASSERT(fixed == 1);
  1579.   THD *thd= current_thd;
  1580.   if (!thd->db)
  1581.   {
  1582.     null_value= 1;
  1583.     return 0;
  1584.   }
  1585.   else
  1586.     str->copy((const char*) thd->db,(uint) strlen(thd->db),system_charset_info);
  1587.   return str;
  1588. }
  1590. // TODO: make USER() replicate properly (currently it is replicated to "")
  1592. String *Item_func_user::val_str(String *str)
  1593. {
  1594.   DBUG_ASSERT(fixed == 1);
  1595.   THD          *thd=current_thd;
  1596.   CHARSET_INFO *cs= system_charset_info;
  1597.   const char   *host= thd->host_or_ip;
  1598.   uint res_length;
  1600.   // For system threads (e.g. replication SQL thread) user may be empty
  1601.   if (!thd->user)
  1602.     return &my_empty_string;
  1603.   res_length= (strlen(thd->user)+strlen(host)+2) * cs->mbmaxlen;
  1605.   if (str->alloc(res_length))
  1606.   {
  1607.     null_value=1;
  1608.     return 0;
  1609.   }
  1610.   res_length=cs->cset->snprintf(cs, (char*)str->ptr(), res_length, "%s@%s",
  1611.   thd->user, host);
  1612.   str->length(res_length);
  1613.   str->set_charset(cs);
  1614.   return str;
  1615. }
  1617. void Item_func_soundex::fix_length_and_dec()
  1618. {
  1619.   collation.set(args[0]->collation);
  1620.   max_length=args[0]->max_length;
  1621.   set_if_bigger(max_length,4);
  1622. }
  1625. /*
  1626.   If alpha, map input letter to soundex code.
  1627.   If not alpha and remove_garbage is set then skip to next char
  1628.   else return 0
  1629. */
  1631. static char soundex_toupper(char ch)
  1632. {
  1633.   return (ch >= 'a' && ch <= 'z') ? ch - 'a' + 'A' : ch;
  1634. }
  1636. static char get_scode(char *ptr)
  1637. {
  1638.   uchar ch= soundex_toupper(*ptr);
  1639.   if (ch < 'A' || ch > 'Z')
  1640.   {
  1641. // Thread extended alfa (country spec)
  1642.     return '0'; // as vokal
  1643.   }
  1644.   return(soundex_map[ch-'A']);
  1645. }
  1648. String *Item_func_soundex::val_str(String *str)
  1649. {
  1650.   DBUG_ASSERT(fixed == 1);
  1651.   String *res  =args[0]->val_str(str);
  1652.   char last_ch,ch;
  1653.   CHARSET_INFO *cs= collation.collation;
  1655.   if ((null_value=args[0]->null_value))
  1656.     return 0; /* purecov: inspected */
  1658.   if (tmp_value.alloc(max(res->length(),4)))
  1659.     return str; /* purecov: inspected */
  1660.   char *to= (char *) tmp_value.ptr();
  1661.   char *from= (char *) res->ptr(), *end=from+res->length();
  1662.   tmp_value.set_charset(cs);
  1663.   
  1664.   while (from != end && !my_isalpha(cs,*from)) // Skip pre-space
  1665.     from++; /* purecov: inspected */
  1666.   if (from == end)
  1667.     return &my_empty_string; // No alpha characters.
  1668.   *to++ = soundex_toupper(*from); // Copy first letter
  1669.   last_ch = get_scode(from); // code of the first letter
  1670. // for the first 'double-letter check.
  1671. // Loop on input letters until
  1672. // end of input (null) or output
  1673. // letter code count = 3
  1674.   for (from++ ; from < end ; from++)
  1675.   {
  1676.     if (!my_isalpha(cs,*from))
  1677.       continue;
  1678.     ch=get_scode(from);
  1679.     if ((ch != '0') && (ch != last_ch)) // if not skipped or double
  1680.     {
  1681.        *to++ = ch; // letter, copy to output
  1682.        last_ch = ch; // save code of last input letter
  1683.     } // for next double-letter check
  1684.   }
  1685.   for (end=(char*) tmp_value.ptr()+4 ; to < end ; to++)
  1686.     *to = '0';
  1687.   *to=0; // end string
  1688.   tmp_value.length((uint) (to-tmp_value.ptr()));
  1689.   return &tmp_value;
  1690. }
  1693. /*
  1694. ** Change a number to format '3,333,333,333.000'
  1695. ** This should be 'internationalized' sometimes.
  1696. */
  1698. Item_func_format::Item_func_format(Item *org,int dec) :Item_str_func(org)
  1699. {
  1700.   decimals=(uint) set_zone(dec,0,30);
  1701. }
  1704. /*
  1705.   TODO: This needs to be fixed for multi-byte character set where numbers
  1706.   are stored in more than one byte
  1707. */
  1709. String *Item_func_format::val_str(String *str)
  1710. {
  1711.   DBUG_ASSERT(fixed == 1);
  1712.   double nr =args[0]->val();
  1713.   int diff;
  1714.   uint32 length, str_length;
  1715.   uint dec;
  1716.   if ((null_value=args[0]->null_value))
  1717.     return 0; /* purecov: inspected */
  1718.   dec= decimals ? decimals+1 : 0;
  1719.   /* Here default_charset() is right as this is not an automatic conversion */
  1720.   str->set(nr,decimals, default_charset());
  1721.   if (isnan(nr))
  1722.     return str;
  1723.   str_length=str->length();
  1724.   if (nr < 0)
  1725.     str_length--; // Don't count sign
  1727.   /* We need this test to handle 'nan' values */
  1728.   if (str_length >= dec+4)
  1729.   {
  1730.     char *tmp,*pos;
  1731.     length= str->length()+(diff= (int)(str_length- dec-1)/3);
  1732.     str= copy_if_not_alloced(&tmp_str,str,length);
  1733.     str->length(length);
  1734.     tmp= (char*) str->ptr()+length - dec-1;
  1735.     for (pos= (char*) str->ptr()+length-1; pos != tmp; pos--)
  1736.       pos[0]= pos[-diff];
  1737.     while (diff)
  1738.     {
  1739.       *pos= *(pos - diff);
  1740.       pos--;
  1741.       *pos= *(pos - diff);
  1742.       pos--;
  1743.       *pos= *(pos - diff);
  1744.       pos--;
  1745.       pos[0]=',';
  1746.       pos--;
  1747.       diff--;
  1748.     }
  1749.   }
  1750.   return str;
  1751. }
  1754. void Item_func_format::print(String *str)
  1755. {
  1756.   str->append("format(", 7);
  1757.   args[0]->print(str);
  1758.   str->append(',');  
  1759.   // my_charset_bin is good enough for numbers
  1760.   char buffer[20];
  1761.   String st(buffer, sizeof(buffer), &my_charset_bin);
  1762.   st.set((ulonglong)decimals, &my_charset_bin);
  1763.   str->append(st);
  1764.   str->append(')');
  1765. }
  1767. void Item_func_elt::fix_length_and_dec()
  1768. {
  1769.   max_length=0;
  1770.   decimals=0;
  1772.   if (agg_arg_charsets(collation, args+1, arg_count-1, MY_COLL_ALLOW_CONV))
  1773.     return;
  1775.   for (uint i= 1 ; i < arg_count ; i++)
  1776.   {
  1777.     set_if_bigger(max_length,args[i]->max_length);
  1778.     set_if_bigger(decimals,args[i]->decimals);
  1779.   }
  1780.   maybe_null=1; // NULL if wrong first arg
  1781. }
  1784. double Item_func_elt::val()
  1785. {
  1786.   DBUG_ASSERT(fixed == 1);
  1787.   uint tmp;
  1788.   null_value=1;
  1789.   if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
  1790.     return 0.0;
  1791.   double result= args[tmp]->val();
  1792.   null_value= args[tmp]->null_value;
  1793.   return result;
  1794. }
  1797. longlong Item_func_elt::val_int()
  1798. {
  1799.   DBUG_ASSERT(fixed == 1);
  1800.   uint tmp;
  1801.   null_value=1;
  1802.   if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
  1803.     return 0;
  1805.   longlong result= args[tmp]->val_int();
  1806.   null_value= args[tmp]->null_value;
  1807.   return result;
  1808. }
  1811. String *Item_func_elt::val_str(String *str)
  1812. {
  1813.   DBUG_ASSERT(fixed == 1);
  1814.   uint tmp;
  1815.   null_value=1;
  1816.   if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
  1817.     return NULL;
  1819.   String *result= args[tmp]->val_str(str);
  1820.   if (result)
  1821.     result->set_charset(collation.collation);
  1822.   null_value= args[tmp]->null_value;
  1823.   return result;
  1824. }
  1827. void Item_func_make_set::split_sum_func(THD *thd, Item **ref_pointer_array,
  1828. List<Item> &fields)
  1829. {
  1830.   item->split_sum_func2(thd, ref_pointer_array, fields, &item);
  1831.   Item_str_func::split_sum_func(thd, ref_pointer_array, fields);
  1832. }
  1835. void Item_func_make_set::fix_length_and_dec()
  1836. {
  1837.   max_length=arg_count-1;
  1839.   if (agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV))
  1840.     return;
  1841.   
  1842.   for (uint i=0 ; i < arg_count ; i++)
  1843.     max_length+=args[i]->max_length;
  1844.   
  1845.   used_tables_cache|=   item->used_tables();
  1846.   not_null_tables_cache&= item->not_null_tables();
  1847.   const_item_cache&=   item->const_item();
  1848.   with_sum_func= with_sum_func || item->with_sum_func;
  1849. }
  1852. void Item_func_make_set::update_used_tables()
  1853. {
  1854.   Item_func::update_used_tables();
  1855.   item->update_used_tables();
  1856.   used_tables_cache|=item->used_tables();
  1857.   const_item_cache&=item->const_item();
  1858. }
  1861. String *Item_func_make_set::val_str(String *str)
  1862. {
  1863.   DBUG_ASSERT(fixed == 1);
  1864.   ulonglong bits;
  1865.   bool first_found=0;
  1866.   Item **ptr=args;
  1867.   String *result=&my_empty_string;
  1869.   bits=item->val_int();
  1870.   if ((null_value=item->null_value))
  1871.     return NULL;
  1873.   if (arg_count < 64)
  1874.     bits &= ((ulonglong) 1 << arg_count)-1;
  1876.   for (; bits; bits >>= 1, ptr++)
  1877.   {
  1878.     if (bits & 1)
  1879.     {
  1880.       String *res= (*ptr)->val_str(str);
  1881.       if (res) // Skip nulls
  1882.       {
  1883. if (!first_found)
  1884. { // First argument
  1885.   first_found=1;
  1886.   if (res != str)
  1887.     result=res; // Use original string
  1888.   else
  1889.   {
  1890.     if (tmp_str.copy(*res)) // Don't use 'str'
  1891.       return &my_empty_string;
  1892.     result= &tmp_str;
  1893.   }
  1894. }
  1895. else
  1896. {
  1897.   if (result != &tmp_str)
  1898.   { // Copy data to tmp_str
  1899.     if (tmp_str.alloc(result->length()+res->length()+1) ||
  1900. tmp_str.copy(*result))
  1901.       return &my_empty_string;
  1902.     result= &tmp_str;
  1903.   }
  1904.   if (tmp_str.append(',') || tmp_str.append(*res))
  1905.     return &my_empty_string;
  1906. }
  1907.       }
  1908.     }
  1909.   }
  1910.   return result;
  1911. }
  1914. void Item_func_make_set::print(String *str)
  1915. {
  1916.   str->append("make_set(", 9);
  1917.   item->print(str);
  1918.   if (arg_count)
  1919.   {
  1920.     str->append(',');
  1921.     print_args(str, 0);
  1922.   }
  1923.   str->append(')');
  1924. }
  1927. String *Item_func_char::val_str(String *str)
  1928. {
  1929.   DBUG_ASSERT(fixed == 1);
  1930.   str->length(0);
  1931.   for (uint i=0 ; i < arg_count ; i++)
  1932.   {
  1933.     int32 num=(int32) args[i]->val_int();
  1934.     if (!args[i]->null_value)
  1935.     {
  1936. #ifdef USE_MB
  1937.       if (use_mb(collation.collation))
  1938.       {
  1939.         if (num&0xFF000000L) {
  1940.            str->append((char)(num>>24));
  1941.            goto b2;
  1942.         } else if (num&0xFF0000L) {
  1943. b2:        str->append((char)(num>>16));
  1944.            goto b1;
  1945.         } else if (num&0xFF00L) {
  1946. b1:        str->append((char)(num>>8));
  1947.         }
  1948.       }
  1949. #endif
  1950.       str->append((char)num);
  1951.     }
  1952.   }
  1953.   str->set_charset(collation.collation);
  1954.   str->realloc(str->length()); // Add end 0 (for Purify)
  1955.   return str;
  1956. }
  1959. inline String* alloc_buffer(String *res,String *str,String *tmp_value,
  1960.     ulong length)
  1961. {
  1962.   if (res->alloced_length() < length)
  1963.   {
  1964.     if (str->alloced_length() >= length)
  1965.     {
  1966.       (void) str->copy(*res);
  1967.       str->length(length);
  1968.       return str;
  1969.     }
  1970.     if (tmp_value->alloc(length))
  1971.       return 0;
  1972.     (void) tmp_value->copy(*res);
  1973.     tmp_value->length(length);
  1974.     return tmp_value;
  1975.   }
  1976.   res->length(length);
  1977.   return res;
  1978. }
  1981. void Item_func_repeat::fix_length_and_dec()
  1982. {
  1983.   collation.set(args[0]->collation);
  1984.   if (args[1]->const_item())
  1985.   {
  1986.     ulonglong max_result_length= ((ulonglong) args[0]->max_length *
  1987.                                   args[1]->val_int());
  1988.     if (max_result_length >= MAX_BLOB_WIDTH)
  1989.     {
  1990.       max_result_length= MAX_BLOB_WIDTH;
  1991.       maybe_null= 1;
  1992.     }
  1993.     max_length= (ulong) max_result_length;
  1994.   }
  1995.   else
  1996.   {
  1997.     max_length= MAX_BLOB_WIDTH;
  1998.     maybe_null= 1;
  1999.   }
  2000. }
  2002. /*
  2003. ** Item_func_repeat::str is carefully written to avoid reallocs
  2004. ** as much as possible at the cost of a local buffer
  2005. */
  2007. String *Item_func_repeat::val_str(String *str)
  2008. {
  2009.   DBUG_ASSERT(fixed == 1);
  2010.   uint length,tot_length;
  2011.   char *to;
  2012.   long count= (long) args[1]->val_int();
  2013.   String *res =args[0]->val_str(str);
  2015.   if (args[0]->null_value || args[1]->null_value)
  2016.     goto err; // string and/or delim are null
  2017.   null_value=0;
  2018.   if (count <= 0) // For nicer SQL code
  2019.     return &my_empty_string;
  2020.   if (count == 1) // To avoid reallocs
  2021.     return res;
  2022.   length=res->length();
  2023.   // Safe length check
  2024.   if (length > current_thd->variables.max_allowed_packet/count)
  2025.   {
  2026.     push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  2027. ER_WARN_ALLOWED_PACKET_OVERFLOWED,
  2028. ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
  2029. func_name(), current_thd->variables.max_allowed_packet);
  2030.     goto err;
  2031.   }
  2032.   tot_length= length*(uint) count;
  2033.   if (!(res= alloc_buffer(res,str,&tmp_value,tot_length)))
  2034.     goto err;
  2036.   to=(char*) res->ptr()+length;
  2037.   while (--count)
  2038.   {
  2039.     memcpy(to,res->ptr(),length);
  2040.     to+=length;
  2041.   }
  2042.   return (res);
  2044. err:
  2045.   null_value=1;
  2046.   return 0;
  2047. }
  2050. void Item_func_rpad::fix_length_and_dec()
  2051. {
  2052.   Item *cargs[2];
  2054.   cargs[0]= args[0];
  2055.   cargs[1]= args[2];
  2056.   if (agg_arg_charsets(collation, cargs, 2, MY_COLL_ALLOW_CONV))
  2057.     return;
  2058.   args[0]= cargs[0];
  2059.   args[2]= cargs[1];
  2060.   if (args[1]->const_item())
  2061.   {
  2062.     ulonglong length= ((ulonglong) args[1]->val_int() *
  2063.                        collation.collation->mbmaxlen);
  2064.     if (length >= MAX_BLOB_WIDTH)
  2065.     {
  2066.       length= MAX_BLOB_WIDTH;
  2067.       maybe_null= 1;
  2068.     }
  2069.     max_length= (ulong) length;
  2070.   }
  2071.   else
  2072.   {
  2073.     max_length= MAX_BLOB_WIDTH;
  2074.     maybe_null= 1;
  2075.   }
  2076. }
  2079. String *Item_func_rpad::val_str(String *str)
  2080. {
  2081.   DBUG_ASSERT(fixed == 1);
  2082.   uint32 res_byte_length,res_char_length,pad_char_length,pad_byte_length;
  2083.   char *to;
  2084.   const char *ptr_pad;
  2085.   int32 count= (int32) args[1]->val_int();
  2086.   int32 byte_count= count * collation.collation->mbmaxlen;
  2087.   String *res =args[0]->val_str(str);
  2088.   String *rpad = args[2]->val_str(&rpad_str);
  2090.   if (!res || args[1]->null_value || !rpad || count < 0)
  2091.     goto err;
  2092.   null_value=0;
  2093.   if (count <= (int32) (res_char_length=res->numchars()))
  2094.   { // String to pad is big enough
  2095.     res->length(res->charpos(count)); // Shorten result if longer
  2096.     return (res);
  2097.   }
  2098.   pad_char_length= rpad->numchars();
  2099.   if ((ulong) byte_count > current_thd->variables.max_allowed_packet)
  2100.   {
  2101.     push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  2102. ER_WARN_ALLOWED_PACKET_OVERFLOWED,
  2103. ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
  2104. func_name(), current_thd->variables.max_allowed_packet);
  2105.     goto err;
  2106.   }
  2107.   if(args[2]->null_value || !pad_char_length)
  2108.     goto err;
  2109.   res_byte_length= res->length(); /* Must be done before alloc_buffer */
  2110.   if (!(res= alloc_buffer(res,str,&tmp_value,byte_count)))
  2111.     goto err;
  2113.   to= (char*) res->ptr()+res_byte_length;
  2114.   ptr_pad=rpad->ptr();
  2115.   pad_byte_length= rpad->length();
  2116.   count-= res_char_length;
  2117.   for ( ; (uint32) count > pad_char_length; count-= pad_char_length)
  2118.   {
  2119.     memcpy(to,ptr_pad,pad_byte_length);
  2120.     to+= pad_byte_length;
  2121.   }
  2122.   if (count)
  2123.   {
  2124.     pad_byte_length= rpad->charpos(count);
  2125.     memcpy(to,ptr_pad,(size_t) pad_byte_length);
  2126.     to+= pad_byte_length;
  2127.   }
  2128.   res->length(to- (char*) res->ptr());
  2129.   return (res);
  2131.  err:
  2132.   null_value=1;
  2133.   return 0;
  2134. }
  2137. void Item_func_lpad::fix_length_and_dec()
  2138. {
  2139.   Item *cargs[2];
  2140.   cargs[0]= args[0];
  2141.   cargs[1]= args[2];
  2142.   if (agg_arg_charsets(collation, cargs, 2, MY_COLL_ALLOW_CONV))
  2143.     return;
  2144.   args[0]= cargs[0];
  2145.   args[2]= cargs[1];
  2146.   
  2147.   if (args[1]->const_item())
  2148.   {
  2149.     ulonglong length= ((ulonglong) args[1]->val_int() *
  2150.                        collation.collation->mbmaxlen);
  2151.     if (length >= MAX_BLOB_WIDTH)
  2152.     {
  2153.       length= MAX_BLOB_WIDTH;
  2154.       maybe_null= 1;
  2155.     }
  2156.     max_length= (ulong) length;
  2157.   }
  2158.   else
  2159.   {
  2160.     max_length= MAX_BLOB_WIDTH;
  2161.     maybe_null= 1;
  2162.   }
  2163. }
  2166. String *Item_func_lpad::val_str(String *str)
  2167. {
  2168.   DBUG_ASSERT(fixed == 1);
  2169.   uint32 res_char_length,pad_char_length;
  2170.   ulong count= (long) args[1]->val_int(), byte_count;
  2171.   String *res= args[0]->val_str(&tmp_value);
  2172.   String *pad= args[2]->val_str(&lpad_str);
  2174.   if (!res || args[1]->null_value || !pad)
  2175.     goto err;
  2177.   null_value=0;
  2178.   res_char_length= res->numchars();
  2180.   if (count <= res_char_length)
  2181.   {
  2182.     res->length(res->charpos(count));
  2183.     return res;
  2184.   }
  2185.   
  2186.   pad_char_length= pad->numchars();
  2187.   byte_count= count * collation.collation->mbmaxlen;
  2188.   
  2189.   if (byte_count > current_thd->variables.max_allowed_packet)
  2190.   {
  2191.     push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  2192. ER_WARN_ALLOWED_PACKET_OVERFLOWED,
  2193. ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
  2194. func_name(), current_thd->variables.max_allowed_packet);
  2195.     goto err;
  2196.   }
  2198.   if (args[2]->null_value || !pad_char_length || str->alloc(byte_count))
  2199.     goto err;
  2200.   
  2201.   str->length(0);
  2202.   str->set_charset(collation.collation);
  2203.   count-= res_char_length;
  2204.   while (count >= pad_char_length)
  2205.   {
  2206.     str->append(*pad);
  2207.     count-= pad_char_length;
  2208.   }
  2209.   if (count > 0)
  2210.     str->append(pad->ptr(), pad->charpos(count), collation.collation);
  2212.   str->append(*res);
  2213.   null_value= 0;
  2214.   return str;
  2216. err:
  2217.   null_value= 1;
  2218.   return 0;
  2219. }
  2222. String *Item_func_conv::val_str(String *str)
  2223. {
  2224.   DBUG_ASSERT(fixed == 1);
  2225.   String *res= args[0]->val_str(str);
  2226.   char *endptr,ans[65],*ptr;
  2227.   longlong dec;
  2228.   int from_base= (int) args[1]->val_int();
  2229.   int to_base= (int) args[2]->val_int();
  2230.   int err;
  2232.   if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
  2233.       abs(to_base) > 36 || abs(to_base) < 2 ||
  2234.       abs(from_base) > 36 || abs(from_base) < 2 || !(res->length()))
  2235.   {
  2236.     null_value=1;
  2237.     return 0;
  2238.   }
  2239.   null_value=0;
  2240.   unsigned_flag= !(from_base < 0);
  2241.   if (from_base < 0)
  2242.     dec= my_strntoll(res->charset(),res->ptr(),res->length(),-from_base,&endptr,&err);
  2243.   else
  2244.     dec= (longlong) my_strntoull(res->charset(),res->ptr(),res->length(),from_base,&endptr,&err);
  2245.   ptr= longlong2str(dec,ans,to_base);
  2246.   if (str->copy(ans,(uint32) (ptr-ans), default_charset()))
  2247.     return &my_empty_string;
  2248.   return str;
  2249. }
  2252. String *Item_func_conv_charset::val_str(String *str)
  2253. {
  2254.   DBUG_ASSERT(fixed == 1);
  2255.   if (use_cached_value)
  2256.     return null_value ? 0 : &str_value;
  2257.   String *arg= args[0]->val_str(str);
  2258.   uint dummy_errors;
  2259.   if (!arg)
  2260.   {
  2261.     null_value=1;
  2262.     return 0;
  2263.   }
  2264.   null_value= str_value.copy(arg->ptr(),arg->length(),arg->charset(),
  2265.                              conv_charset, &dummy_errors);
  2266.   return null_value ? 0 : &str_value;
  2267. }
  2269. void Item_func_conv_charset::fix_length_and_dec()
  2270. {
  2271.   collation.set(conv_charset, DERIVATION_IMPLICIT);
  2272.   max_length = args[0]->max_length*conv_charset->mbmaxlen;
  2273. }
  2275. void Item_func_conv_charset::print(String *str)
  2276. {
  2277.   str->append("convert(", 8);
  2278.   args[0]->print(str);
  2279.   str->append(" using ", 7);
  2280.   str->append(conv_charset->csname);
  2281.   str->append(')');
  2282. }
  2284. String *Item_func_set_collation::val_str(String *str)
  2285. {
  2286.   DBUG_ASSERT(fixed == 1);
  2287.   str=args[0]->val_str(str);
  2288.   if ((null_value=args[0]->null_value))
  2289.     return 0;
  2290.   str->set_charset(collation.collation);
  2291.   return str;
  2292. }
  2294. void Item_func_set_collation::fix_length_and_dec()
  2295. {
  2296.   CHARSET_INFO *set_collation;
  2297.   const char *colname;
  2298.   String tmp, *str= args[1]->val_str(&tmp);
  2299.   colname= str->c_ptr();
  2300.   if (colname == binary_keyword)
  2301.     set_collation= get_charset_by_csname(args[0]->collation.collation->csname,
  2302.  MY_CS_BINSORT,MYF(0));
  2303.   else
  2304.   {
  2305.     if (!(set_collation= get_charset_by_name(colname,MYF(0))))
  2306.     {
  2307.       my_error(ER_UNKNOWN_COLLATION, MYF(0), colname);
  2308.       return;
  2309.     }
  2310.   }
  2312.   if (!set_collation || 
  2313.       !my_charset_same(args[0]->collation.collation,set_collation))
  2314.   {
  2315.     my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0), 
  2316.       colname,args[0]->collation.collation->csname);
  2317.     return;
  2318.   }
  2319.   collation.set(set_collation, DERIVATION_EXPLICIT);
  2320.   max_length= args[0]->max_length;
  2321. }
  2324. bool Item_func_set_collation::eq(const Item *item, bool binary_cmp) const
  2325. {
  2326.   /* Assume we don't have rtti */
  2327.   if (this == item)
  2328.     return 1;
  2329.   if (item->type() != FUNC_ITEM)
  2330.     return 0;
  2331.   Item_func *item_func=(Item_func*) item;
  2332.   if (arg_count != item_func->arg_count ||
  2333.       func_name() != item_func->func_name())
  2334.     return 0;
  2335.   Item_func_set_collation *item_func_sc=(Item_func_set_collation*) item;
  2336.   if (collation.collation != item_func_sc->collation.collation)
  2337.     return 0;
  2338.   for (uint i=0; i < arg_count ; i++)
  2339.     if (!args[i]->eq(item_func_sc->args[i], binary_cmp))
  2340.       return 0;
  2341.   return 1;
  2342. }
  2344. String *Item_func_charset::val_str(String *str)
  2345. {
  2346.   DBUG_ASSERT(fixed == 1);
  2347.   uint dummy_errors;
  2349.   CHARSET_INFO *cs= args[0]->collation.collation; 
  2350.   null_value= 0;
  2351.   str->copy(cs->csname, strlen(cs->csname),
  2352.     &my_charset_latin1, collation.collation, &dummy_errors);
  2353.   return str;
  2354. }
  2356. String *Item_func_collation::val_str(String *str)
  2357. {
  2358.   DBUG_ASSERT(fixed == 1);
  2359.   uint dummy_errors;
  2360.   CHARSET_INFO *cs= args[0]->collation.collation; 
  2362.   null_value= 0;
  2363.   str->copy(cs->name, strlen(cs->name),
  2364.     &my_charset_latin1, collation.collation, &dummy_errors);
  2365.   return str;
  2366. }
  2369. String *Item_func_hex::val_str(String *str)
  2370. {
  2371.   DBUG_ASSERT(fixed == 1);
  2372.   if (args[0]->result_type() != STRING_RESULT)
  2373.   {
  2374.     ulonglong dec;
  2375.     char ans[65],*ptr;
  2376.     /* Return hex of unsigned longlong value */
  2377.     if (args[0]->result_type() == REAL_RESULT)
  2378.     {
  2379.       double val= args[0]->val();
  2380.       if ((val <= (double) LONGLONG_MIN) || 
  2381.           (val >= (double) (ulonglong) ULONGLONG_MAX))
  2382.         dec=  ~(longlong) 0;
  2383.       else
  2384.         dec= (ulonglong) (val + (val > 0 ? 0.5 : -0.5));
  2385.     }
  2386.     else
  2387.       dec= (ulonglong) args[0]->val_int();
  2389.     if ((null_value= args[0]->null_value))
  2390.       return 0;
  2391.     ptr= longlong2str(dec,ans,16);
  2392.     if (str->copy(ans,(uint32) (ptr-ans),default_charset()))
  2393.       return &my_empty_string; // End of memory
  2394.     return str;
  2395.   }
  2397.   /* Convert given string to a hex string, character by character */
  2398.   String *res= args[0]->val_str(str);
  2399.   const char *from, *end;
  2400.   char *to;
  2401.   if (!res || tmp_value.alloc(res->length()*2))
  2402.   {
  2403.     null_value=1;
  2404.     return 0;
  2405.   }
  2406.   null_value=0;
  2407.   tmp_value.length(res->length()*2);
  2408.   for (from=res->ptr(), end=from+res->length(), to= (char*) tmp_value.ptr();
  2409.        from < end ;
  2410.        from++, to+=2)
  2411.   {
  2412.     uint tmp=(uint) (uchar) *from;
  2413.     to[0]=_dig_vec_upper[tmp >> 4];
  2414.     to[1]=_dig_vec_upper[tmp & 15];
  2415.   }
  2416.   return &tmp_value;
  2417. }
  2419.   /* Convert given hex string to a binary string */
  2421. String *Item_func_unhex::val_str(String *str)
  2422. {
  2423.   const char *from, *end;
  2424.   char *to;
  2425.   String *res;
  2426.   uint length;
  2427.   DBUG_ASSERT(fixed == 1);
  2429.   res= args[0]->val_str(str);
  2430.   if (!res || tmp_value.alloc(length= (1+res->length())/2))
  2431.   {
  2432.     null_value=1;
  2433.     return 0;
  2434.   }
  2436.   from= res->ptr();
  2437.   null_value= 0;
  2438.   tmp_value.length(length);
  2439.   to= (char*) tmp_value.ptr();
  2440.   if (res->length() % 2)
  2441.   {
  2442.     int hex_char;
  2443.     *to++= hex_char= hexchar_to_int(*from++);
  2444.     if ((null_value= (hex_char == -1)))
  2445.       return 0;
  2446.   }
  2447.   for (end=res->ptr()+res->length(); from < end ; from+=2, to++)
  2448.   {
  2449.     int hex_char;
  2450.     *to= (hex_char= hexchar_to_int(from[0])) << 4;
  2451.     if ((null_value= (hex_char == -1)))
  2452.       return 0;
  2453.     *to|= hex_char= hexchar_to_int(from[1]);
  2454.     if ((null_value= (hex_char == -1)))
  2455.       return 0;
  2456.   }
  2457.   return &tmp_value;
  2458. }
  2461. void Item_func_binary::print(String *str)
  2462. {
  2463.   str->append("cast(", 5);
  2464.   args[0]->print(str);
  2465.   str->append(" as binary)", 11);
  2466. }
  2469. #include <my_dir.h> // For my_stat
  2471. String *Item_load_file::val_str(String *str)
  2472. {
  2473.   DBUG_ASSERT(fixed == 1);
  2474.   String *file_name;
  2475.   File file;
  2476.   MY_STAT stat_info;
  2477.   char path[FN_REFLEN];
  2478.   DBUG_ENTER("load_file");
  2480.   if (!(file_name= args[0]->val_str(str))
  2481. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  2482.       || !(current_thd->master_access & FILE_ACL)
  2483. #endif
  2484.       )
  2485.     goto err;
  2487.   (void) fn_format(path, file_name->c_ptr(), mysql_real_data_home, "",
  2488.    MY_RELATIVE_PATH | MY_UNPACK_FILENAME);
  2490.   if (!my_stat(path, &stat_info, MYF(MY_WME)))
  2491.     goto err;
  2493.   if (!(stat_info.st_mode & S_IROTH))
  2494.   {
  2495.     /* my_error(ER_TEXTFILE_NOT_READABLE, MYF(0), file_name->c_ptr()); */
  2496.     goto err;
  2497.   }
  2498.   if (stat_info.st_size > (long) current_thd->variables.max_allowed_packet)
  2499.   {
  2500.     push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
  2501. ER_WARN_ALLOWED_PACKET_OVERFLOWED,
  2502. ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
  2503. func_name(), current_thd->variables.max_allowed_packet);
  2504.     goto err;
  2505.   }
  2506.   if (tmp_value.alloc(stat_info.st_size))
  2507.     goto err;
  2508.   if ((file = my_open(file_name->c_ptr(), O_RDONLY, MYF(0))) < 0)
  2509.     goto err;
  2510.   if (my_read(file, (byte*) tmp_value.ptr(), stat_info.st_size, MYF(MY_NABP)))
  2511.   {
  2512.     my_close(file, MYF(0));
  2513.     goto err;
  2514.   }
  2515.   tmp_value.length(stat_info.st_size);
  2516.   my_close(file, MYF(0));
  2517.   null_value = 0;
  2518.   return &tmp_value;
  2520. err:
  2521.   null_value = 1;
  2522.   DBUG_RETURN(0);
  2523. }
  2526. String* Item_func_export_set::val_str(String* str)
  2527. {
  2528.   DBUG_ASSERT(fixed == 1);
  2529.   ulonglong the_set = (ulonglong) args[0]->val_int();
  2530.   String yes_buf, *yes;
  2531.   yes = args[1]->val_str(&yes_buf);
  2532.   String no_buf, *no;
  2533.   no = args[2]->val_str(&no_buf);
  2534.   String *sep = NULL, sep_buf ;
  2536.   uint num_set_values = 64;
  2537.   ulonglong mask = 0x1;
  2538.   str->length(0);
  2539.   str->set_charset(collation.collation);
  2541.   /* Check if some argument is a NULL value */
  2542.   if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
  2543.   {
  2544.     null_value=1;
  2545.     return 0;
  2546.   }
  2547.   /*
  2548.     Arg count can only be 3, 4 or 5 here. This is guaranteed from the
  2549.     grammar for EXPORT_SET()
  2550.   */
  2551.   switch(arg_count) {
  2552.   case 5:
  2553.     num_set_values = (uint) args[4]->val_int();
  2554.     if (num_set_values > 64)
  2555.       num_set_values=64;
  2556.     if (args[4]->null_value)
  2557.     {
  2558.       null_value=1;
  2559.       return 0;
  2560.     }
  2561.     /* Fall through */
  2562.   case 4:
  2563.     if (!(sep = args[3]->val_str(&sep_buf))) // Only true if NULL
  2564.     {
  2565.       null_value=1;
  2566.       return 0;
  2567.     }
  2568.     break;
  2569.   case 3:
  2570.     sep_buf.set(",", 1, default_charset());
  2571.     sep = &sep_buf;
  2572.     break;
  2573.   default:
  2574.     DBUG_ASSERT(0); // cannot happen
  2575.   }
  2576.   null_value=0;
  2578.   for (uint i = 0; i < num_set_values; i++, mask = (mask << 1))
  2579.   {
  2580.     if (the_set & mask)
  2581.       str->append(*yes);
  2582.     else
  2583.       str->append(*no);
  2584.     if (i != num_set_values - 1)
  2585.       str->append(*sep);
  2586.   }
  2587.   return str;
  2588. }
  2590. void Item_func_export_set::fix_length_and_dec()
  2591. {
  2592.   uint length=max(args[1]->max_length,args[2]->max_length);
  2593.   uint sep_length=(arg_count > 3 ? args[3]->max_length : 1);
  2594.   max_length=length*64+sep_length*63;
  2596.   if (agg_arg_charsets(collation, args+1, min(4,arg_count)-1),
  2597.                        MY_COLL_ALLOW_CONV)
  2598.     return;
  2599. }
  2601. String* Item_func_inet_ntoa::val_str(String* str)
  2602. {
  2603.   DBUG_ASSERT(fixed == 1);
  2604.   uchar buf[8], *p;
  2605.   ulonglong n = (ulonglong) args[0]->val_int();
  2606.   char num[4];
  2608.   /*
  2609.     We do not know if args[0] is NULL until we have called
  2610.     some val function on it if args[0] is not a constant!
  2612.     Also return null if n > 255.255.255.255
  2613.   */
  2614.   if ((null_value= (args[0]->null_value || n > (ulonglong) LL(4294967295))))
  2615.     return 0; // Null value
  2617.   str->length(0);
  2618.   int4store(buf,n);
  2620.   /* Now we can assume little endian. */
  2622.   num[3]='.';
  2623.   for (p=buf+4 ; p-- > buf ; )
  2624.   {
  2625.     uint c = *p;
  2626.     uint n1,n2; // Try to avoid divisions
  2627.     n1= c / 100; // 100 digits
  2628.     c-= n1*100;
  2629.     n2= c / 10; // 10 digits
  2630.     c-=n2*10; // last digit
  2631.     num[0]=(char) n1+'0';
  2632.     num[1]=(char) n2+'0';
  2633.     num[2]=(char) c+'0';
  2634.     uint length=(n1 ? 4 : n2 ? 3 : 2); // Remove pre-zero
  2636.     (void) str->append(num+4-length,length);
  2637.   }
  2638.   str->length(str->length()-1); // Remove last '.';
  2639.   return str;
  2640. }
  2643. /*
  2644.   QUOTE() function returns argument string in single quotes suitable for
  2645.   using in a SQL statement.
  2647.   DESCRIPTION
  2648.     Adds a  before all characters that needs to be escaped in a SQL string.
  2649.     We also escape '^Z' (END-OF-FILE in windows) to avoid probelms when
  2650.     running commands from a file in windows.
  2652.     This function is very useful when you want to generate SQL statements
  2654.   NOTE
  2655.     QUOTE(NULL) returns the string 'NULL' (4 letters, without quotes).
  2657.   RETURN VALUES
  2658.     str Quoted string
  2659.     NULL Out of memory.
  2660. */
  2662. #define get_esc_bit(mask, num) (1 & (*((mask) + ((num) >> 3))) >> ((num) & 7))
  2664. String *Item_func_quote::val_str(String *str)
  2665. {
  2666.   DBUG_ASSERT(fixed == 1);
  2667.   /*
  2668.     Bit mask that has 1 for set for the position of the following characters:
  2669.     0, , ' and ^Z
  2670.   */
  2672.   static uchar escmask[32]=
  2673.   {
  2674.     0x01, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x00,
  2675.     0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
  2676.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  2677.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  2678.   };
  2680.   char *from, *to, *end, *start;
  2681.   String *arg= args[0]->val_str(str);
  2682.   uint arg_length, new_length;
  2683.   if (!arg) // Null argument
  2684.   {
  2685.     str->copy("NULL", 4, collation.collation); // Return the string 'NULL'
  2686.     null_value= 0;
  2687.     return str;
  2688.   }
  2690.   arg_length= arg->length();
  2691.   new_length= arg_length+2; /* for beginning and ending ' signs */
  2693.   for (from= (char*) arg->ptr(), end= from + arg_length; from < end; from++)
  2694.     new_length+= get_esc_bit(escmask, (uchar) *from);
  2696.   if (tmp_value.alloc(new_length))
  2697.     goto null;
  2699.   /*
  2700.     We replace characters from the end to the beginning
  2701.   */
  2702.   to= (char*) tmp_value.ptr() + new_length - 1;
  2703.   *to--= ''';
  2704.   for (start= (char*) arg->ptr(),end= start + arg_length; end-- != start; to--)
  2705.   {
  2706.     /*
  2707.       We can't use the bitmask here as we want to replace O and ^Z with 0
  2708.       and Z
  2709.     */
  2710.     switch (*end)  {
  2711.     case 0:
  2712.       *to--= '0';
  2713.       *to=   '\';
  2714.       break;
  2715.     case '32':
  2716.       *to--= 'Z';
  2717.       *to=   '\';
  2718.       break;
  2719.     case ''':
  2720.     case '\':
  2721.       *to--= *end;
  2722.       *to=   '\';
  2723.       break;
  2724.     default:
  2725.       *to= *end;
  2726.       break;
  2727.     }
  2728.   }
  2729.   *to= ''';
  2730.   tmp_value.length(new_length);
  2731.   tmp_value.set_charset(collation.collation);
  2732.   null_value= 0;
  2733.   return &tmp_value;
  2735. null:
  2736.   null_value= 1;
  2737.   return 0;
  2738. }
  2740. longlong Item_func_uncompressed_length::val_int()
  2741. {
  2742.   DBUG_ASSERT(fixed == 1);
  2743.   String *res= args[0]->val_str(&value);
  2744.   if (!res)
  2745.   {
  2746.     null_value=1;
  2747.     return 0; /* purecov: inspected */
  2748.   }
  2749.   null_value=0;
  2750.   if (res->is_empty()) return 0;
  2752.   /*
  2753.     res->ptr() using is safe because we have tested that string is not empty,
  2754.     res->c_ptr() is not used because:
  2755.       - we do not need  terminated string to get first 4 bytes
  2756.       - c_ptr() tests simbol after string end (uninitialiozed memory) which
  2757.         confuse valgrind
  2758.   */
  2759.   return uint4korr(res->ptr()) & 0x3FFFFFFF;
  2760. }
  2762. longlong Item_func_crc32::val_int()
  2763. {
  2764.   DBUG_ASSERT(fixed == 1);
  2765.   String *res=args[0]->val_str(&value);
  2766.   if (!res)
  2767.   {
  2768.     null_value=1;
  2769.     return 0; /* purecov: inspected */
  2770.   }
  2771.   null_value=0;
  2772.   return (longlong) crc32(0L, (uchar*)res->ptr(), res->length());
  2773. }
  2775. #ifdef HAVE_COMPRESS
  2776. #include "zlib.h"
  2778. String *Item_func_compress::val_str(String *str)
  2779. {
  2780.   int err= Z_OK, code;
  2781.   ulong new_size;
  2782.   String *res;
  2783.   Byte *body;
  2784.   char *tmp, *last_char;
  2785.   DBUG_ASSERT(fixed == 1);
  2787.   if (!(res= args[0]->val_str(str)))
  2788.   {
  2789.     null_value= 1;
  2790.     return 0;
  2791.   }
  2792.   if (res->is_empty()) return res;
  2794.   /*
  2795.     Citation from zlib.h (comment for compress function):
  2797.     Compresses the source buffer into the destination buffer.  sourceLen is
  2798.     the byte length of the source buffer. Upon entry, destLen is the total
  2799.     size of the destination buffer, which must be at least 0.1% larger than
  2800.     sourceLen plus 12 bytes.
  2801.     We assume here that the buffer can't grow more than .25 %.
  2802.   */
  2803.   new_size= res->length() + res->length() / 5 + 12;
  2805.   // Check new_size overflow: new_size <= res->length()
  2806.   if (((uint32) (new_size+5) <= res->length()) || 
  2807.       buffer.realloc((uint32) new_size + 4 + 1))
  2808.   {
  2809.     null_value= 1;
  2810.     return 0;
  2811.   }
  2813.   body= ((Byte*)buffer.ptr()) + 4;
  2815.   // As far as we have checked res->is_empty() we can use ptr()
  2816.   if ((err= compress(body, &new_size,
  2817.      (const Bytef*)res->ptr(), res->length())) != Z_OK)
  2818.   {
  2819.     code= err==Z_MEM_ERROR ? ER_ZLIB_Z_MEM_ERROR : ER_ZLIB_Z_BUF_ERROR;
  2820.     push_warning(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,code,ER(code));
  2821.     null_value= 1;
  2822.     return 0;
  2823.   }
  2825.   tmp= (char*)buffer.ptr(); // int4store is a macro; avoid side effects
  2826.   int4store(tmp, res->length() & 0x3FFFFFFF);
  2828.   /* This is to ensure that things works for CHAR fields, which trim ' ': */
  2829.   last_char= ((char*)body)+new_size-1;
  2830.   if (*last_char == ' ')
  2831.   {
  2832.     *++last_char= '.';
  2833.     new_size++;
  2834.   }
  2836.   buffer.length((uint32)new_size + 4);
  2837.   return &buffer;
  2838. }
  2841. String *Item_func_uncompress::val_str(String *str)
  2842. {
  2843.   DBUG_ASSERT(fixed == 1);
  2844.   String *res= args[0]->val_str(str);
  2845.   ulong new_size;
  2846.   int err;
  2847.   uint code;
  2849.   if (!res)
  2850.     goto err;
  2851.   if (res->is_empty())
  2852.     return res;
  2854.   new_size= uint4korr(res->ptr()) & 0x3FFFFFFF;
  2855.   if (new_size > current_thd->variables.max_allowed_packet)
  2856.   {
  2857.     push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
  2858. ER_TOO_BIG_FOR_UNCOMPRESS,
  2859. ER(ER_TOO_BIG_FOR_UNCOMPRESS),
  2860.                         current_thd->variables.max_allowed_packet);
  2861.     goto err;
  2862.   }
  2863.   if (buffer.realloc((uint32)new_size))
  2864.     goto err;
  2866.   if ((err= uncompress((Byte*)buffer.ptr(), &new_size,
  2867.        ((const Bytef*)res->ptr())+4,res->length())) == Z_OK)
  2868.   {
  2869.     buffer.length((uint32) new_size);
  2870.     return &buffer;
  2871.   }
  2873.   code= ((err == Z_BUF_ERROR) ? ER_ZLIB_Z_BUF_ERROR :
  2874.  ((err == Z_MEM_ERROR) ? ER_ZLIB_Z_MEM_ERROR : ER_ZLIB_Z_DATA_ERROR));
  2875.   push_warning(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,code,ER(code));
  2877. err:
  2878.   null_value= 1;
  2879.   return 0;
  2880. }
  2881. #endif
  2883. /*
  2884.   UUID, as in
  2885.     DCE 1.1: Remote Procedure Call,
  2886.     Open Group Technical Standard Document Number C706, October 1997,
  2887.     (supersedes C309 DCE: Remote Procedure Call 8/1994,
  2888.     which was basis for ISO/IEC 11578:1996 specification)
  2889. */
  2891. static struct rand_struct uuid_rand;
  2892. static uint nanoseq;
  2893. static ulonglong uuid_time=0;
  2894. static char clock_seq_and_node_str[]="-0000-000000000000";
  2896. /* number of 100-nanosecond intervals between
  2897.    1582-10-15 00:00:00.00 and 1970-01-01 00:00:00.00 */
  2898. #define UUID_TIME_OFFSET ((ulonglong) 141427 * 24 * 60 * 60 * 1000 * 10 )
  2900. #define UUID_VERSION      0x1000
  2901. #define UUID_VARIANT      0x8000
  2903. static void tohex(char *to, uint from, uint len)
  2904. {
  2905.   to+= len;
  2906.   while (len--)
  2907.   {
  2908.     *--to= _dig_vec_lower[from & 15];
  2909.     from >>= 4;
  2910.   }
  2911. }
  2913. static void set_clock_seq_str()
  2914. {
  2915.   uint16 clock_seq= ((uint)(my_rnd(&uuid_rand)*16383)) | UUID_VARIANT;
  2916.   tohex(clock_seq_and_node_str+1, clock_seq, 4);
  2917.   nanoseq= 0;
  2918. }
  2920. String *Item_func_uuid::val_str(String *str)
  2921. {
  2922.   DBUG_ASSERT(fixed == 1);
  2923.   char *s;
  2924.   pthread_mutex_lock(&LOCK_uuid_generator);
  2925.   if (! uuid_time) /* first UUID() call. initializing data */
  2926.   {
  2927.     ulong tmp=sql_rnd_with_mutex();
  2928.     uchar mac[6];
  2929.     int i;
  2930.     if (my_gethwaddr(mac))
  2931.     {
  2932.       /*
  2933.         generating random "hardware addr"
  2934.         and because specs explicitly specify that it should NOT correlate
  2935.         with a clock_seq value (initialized random below), we use a separate
  2936.         randominit() here
  2937.       */
  2938.       randominit(&uuid_rand, tmp + (ulong)current_thd, tmp + query_id);
  2939.       for (i=0; i < (int)sizeof(mac); i++)
  2940.         mac[i]=(uchar)(my_rnd(&uuid_rand)*255);
  2941.     }
  2942.     s=clock_seq_and_node_str+sizeof(clock_seq_and_node_str)-1;
  2943.     for (i=sizeof(mac)-1 ; i>=0 ; i--)
  2944.     {
  2945.       *--s=_dig_vec_lower[mac[i] & 15];
  2946.       *--s=_dig_vec_lower[mac[i] >> 4];
  2947.     }
  2948.     randominit(&uuid_rand, tmp + (ulong)start_time, tmp + bytes_sent);
  2949.     set_clock_seq_str();
  2950.   }
  2952.   ulonglong tv=my_getsystime() + UUID_TIME_OFFSET + nanoseq;
  2953.   if (unlikely(tv < uuid_time))
  2954.     set_clock_seq_str();
  2955.   else
  2956.   if (unlikely(tv == uuid_time))
  2957.   { /* special protection from low-res system clocks */
  2958.     nanoseq++;
  2959.     tv++;
  2960.   }
  2961.   else
  2962.   {
  2963.     if (nanoseq)
  2964.     {
  2965.       tv-=nanoseq;
  2966.       nanoseq=0;
  2967.     }
  2968.     DBUG_ASSERT(tv > uuid_time);
  2969.   }
  2970.   uuid_time=tv;
  2971.   pthread_mutex_unlock(&LOCK_uuid_generator);
  2973.   uint32 time_low=            (uint32) (tv & 0xFFFFFFFF);
  2974.   uint16 time_mid=            (uint16) ((tv >> 32) & 0xFFFF);
  2975.   uint16 time_hi_and_version= (uint16) ((tv >> 48) | UUID_VERSION);
  2977.   str->realloc(UUID_LENGTH+1);
  2978.   str->length(UUID_LENGTH);
  2979.   str->set_charset(system_charset_info);
  2980.   s=(char *) str->ptr();
  2981.   s[8]=s[13]='-';
  2982.   tohex(s, time_low, 8);
  2983.   tohex(s+9, time_mid, 4);
  2984.   tohex(s+14, time_hi_and_version, 4);
  2985.   strmov(s+18, clock_seq_and_node_str);
  2986.   return str;
  2987. }