item_strfunc.cc 78.5 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14 15 16 17 18 19
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* This file defines all string functions
** Warning: Some string functions doesn't always put and end-null on a String
20
** (This shouldn't be needed)
unknown's avatar
unknown committed
21 22
*/

23
#ifdef USE_PRAGMA_IMPLEMENTATION
unknown's avatar
unknown committed
24 25 26 27 28
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include <m_ctype.h>
29 30 31
#ifdef HAVE_OPENSSL
#include <openssl/des.h>
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
32
#include "md5.h"
33 34
#include "sha1.h"
#include "my_aes.h"
unknown's avatar
unknown committed
35
C_MODE_START
36
#include "../mysys/my_static.h"			// For soundex_map
unknown's avatar
unknown committed
37
C_MODE_END
unknown's avatar
unknown committed
38

unknown's avatar
SCRUM  
unknown committed
39
String my_empty_string("",default_charset_info);
unknown's avatar
unknown committed
40

unknown's avatar
unknown committed
41 42
static void my_coll_agg_error(DTCollation &c1, DTCollation &c2,
                              const char *fname)
43
{
44 45 46 47
  my_error(ER_CANT_AGGREGATE_2COLLATIONS, MYF(0),
           c1.collation->name, c1.derivation_name(),
           c2.collation->name, c2.derivation_name(),
           fname);
48 49
}

50

51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
String *Item_str_func::check_well_formed_result(String *str)
{
  /* Check whether we got a well-formed string */
  CHARSET_INFO *cs= str->charset();
  int well_formed_error;
  uint wlen= cs->cset->well_formed_len(cs,
                                       str->ptr(), str->ptr() + str->length(),
                                       str->length(), &well_formed_error);
  if (wlen < str->length())
  {
    THD *thd= current_thd;
    char hexbuf[7];
    enum MYSQL_ERROR::enum_warning_level level;
    uint diff= str->length() - wlen;
    set_if_smaller(diff, 3);
    octet2hex(hexbuf, str->ptr() + wlen, diff);
    if (thd->variables.sql_mode &
        (MODE_STRICT_TRANS_TABLES | MODE_STRICT_ALL_TABLES))
    {
      level= MYSQL_ERROR::WARN_LEVEL_ERROR;
      null_value= 1;
      str= 0;
    }
    else
      level= MYSQL_ERROR::WARN_LEVEL_WARN;
    push_warning_printf(thd, level, ER_INVALID_CHARACTER_STRING,
                        ER(ER_INVALID_CHARACTER_STRING), cs->csname, hexbuf);
  }
  return str;
}


83 84 85 86 87 88 89 90 91 92 93 94 95 96
my_decimal *Item_str_func::val_decimal(my_decimal *decimal_value)
{
  DBUG_ASSERT(fixed == 1);
  char buff[64];
  String *res, tmp(buff,sizeof(buff), &my_charset_bin);
  res= val_str(&tmp);
  if (!res)
    return 0;
  (void)str2my_decimal(E_DEC_FATAL_ERROR, (char*) res->ptr(),
                       res->length(), res->charset(), decimal_value);
  return decimal_value;
}


97
double Item_str_func::val_real()
unknown's avatar
unknown committed
98
{
99
  DBUG_ASSERT(fixed == 1);
100 101
  int err_not_used;
  char *end_not_used, buff[64];
unknown's avatar
unknown committed
102 103
  String *res, tmp(buff,sizeof(buff), &my_charset_bin);
  res= val_str(&tmp);
104 105
  return res ? my_strntod(res->charset(), (char*) res->ptr(), res->length(),
			  &end_not_used, &err_not_used) : 0.0;
unknown's avatar
unknown committed
106 107
}

108

unknown's avatar
unknown committed
109 110
longlong Item_str_func::val_int()
{
111
  DBUG_ASSERT(fixed == 1);
112
  int err;
unknown's avatar
unknown committed
113 114 115
  char buff[22];
  String *res, tmp(buff,sizeof(buff), &my_charset_bin);
  res= val_str(&tmp);
unknown's avatar
unknown committed
116 117 118 119
  return (res ?
	  my_strntoll(res->charset(), res->ptr(), res->length(), 10, NULL,
		      &err) :
	  (longlong) 0);
unknown's avatar
unknown committed
120 121 122 123 124
}


String *Item_func_md5::val_str(String *str)
{
125
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
126 127 128
  String * sptr= args[0]->val_str(str);
  if (sptr)
  {
129
    my_MD5_CTX context;
unknown's avatar
unknown committed
130 131 132
    unsigned char digest[16];

    null_value=0;
133 134 135
    my_MD5Init (&context);
    my_MD5Update (&context,(unsigned char *) sptr->ptr(), sptr->length());
    my_MD5Final (digest, &context);
unknown's avatar
unknown committed
136 137 138 139 140
    if (str->alloc(32))				// Ensure that memory is free
    {
      null_value=1;
      return 0;
    }
unknown's avatar
unknown committed
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
    sprintf((char *) str->ptr(),
	    "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
	    digest[0], digest[1], digest[2], digest[3],
	    digest[4], digest[5], digest[6], digest[7],
	    digest[8], digest[9], digest[10], digest[11],
	    digest[12], digest[13], digest[14], digest[15]);
    str->length((uint) 32);
    return str;
  }
  null_value=1;
  return 0;
}


void Item_func_md5::fix_length_and_dec()
{
157 158 159 160 161 162 163 164 165
  max_length=32;
  /*
    The MD5() function treats its parameter as being a case sensitive. Thus
    we set binary collation on it so different instances of MD5() will be
    compared properly.
  */
  args[0]->collation.set(
      get_charset_by_csname(args[0]->collation.collation->csname,
                            MY_CS_BINSORT,MYF(0)), DERIVATION_COERCIBLE);
unknown's avatar
unknown committed
166 167
}

168 169 170

String *Item_func_sha::val_str(String *str)
{
171
  DBUG_ASSERT(fixed == 1);
172 173 174 175
  String * sptr= args[0]->val_str(str);
  if (sptr)  /* If we got value different from NULL */
  {
    SHA1_CONTEXT context;  /* Context used to generate SHA1 hash */
176
    /* Temporary buffer to store 160bit digest */
unknown's avatar
unknown committed
177
    uint8 digest[SHA1_HASH_SIZE];
178
    mysql_sha1_reset(&context);  /* We do not have to check for error here */
179
    /* No need to check error as the only case would be too long message */
180 181
    mysql_sha1_input(&context,
                     (const unsigned char *) sptr->ptr(), sptr->length());
182
    /* Ensure that memory is free and we got result */
183 184
    if (!( str->alloc(SHA1_HASH_SIZE*2) ||
           (mysql_sha1_result(&context,digest))))
185
    {
186 187
      sprintf((char *) str->ptr(),
      "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\
188 189 190 191 192 193
%02x%02x%02x%02x%02x%02x%02x%02x",
           digest[0], digest[1], digest[2], digest[3],
           digest[4], digest[5], digest[6], digest[7],
           digest[8], digest[9], digest[10], digest[11],
           digest[12], digest[13], digest[14], digest[15],
           digest[16], digest[17], digest[18], digest[19]);
194

195 196 197 198
      str->length((uint)  SHA1_HASH_SIZE*2);
      null_value=0;
      return str;
    }
199
  }
200 201 202 203 204 205
  null_value=1;
  return 0;
}

void Item_func_sha::fix_length_and_dec()
{
206 207 208 209 210 211 212 213 214
  max_length=SHA1_HASH_SIZE*2; // size of hex representation of hash
  /*
    The SHA() function treats its parameter as being a case sensitive. Thus
    we set binary collation on it so different instances of MD5() will be
    compared properly.
  */
  args[0]->collation.set(
      get_charset_by_csname(args[0]->collation.collation->csname,
                            MY_CS_BINSORT,MYF(0)), DERIVATION_COERCIBLE);
215
}
216 217 218 219


/* Implementation of AES encryption routines */

220 221
String *Item_func_aes_encrypt::val_str(String *str)
{
222
  DBUG_ASSERT(fixed == 1);
223
  char key_buff[80];
224
  String tmp_key_value(key_buff, sizeof(key_buff), system_charset_info);
225 226
  String *sptr= args[0]->val_str(str);			// String to encrypt
  String *key=  args[1]->val_str(&tmp_key_value);	// key
227 228 229 230
  int aes_length;
  if (sptr && key) // we need both arguments to be not NULL
  {
    null_value=0;
231
    aes_length=my_aes_get_size(sptr->length()); // Calculate result length
232

233
    if (!str_value.alloc(aes_length))		// Ensure that memory is free
234 235
    {
      // finally encrypt directly to allocated buffer.
236
      if (my_aes_encrypt(sptr->ptr(),sptr->length(), (char*) str_value.ptr(),
237
			 key->ptr(), key->length()) == aes_length)
238
      {
239
	// We got the expected result length
240 241
	str_value.length((uint) aes_length);
	return &str_value;
242 243 244 245 246 247 248
      }
    }
  }
  null_value=1;
  return 0;
}

249

250 251
void Item_func_aes_encrypt::fix_length_and_dec()
{
252
  max_length=my_aes_get_size(args[0]->max_length);
253 254 255 256 257
}


String *Item_func_aes_decrypt::val_str(String *str)
{
258
  DBUG_ASSERT(fixed == 1);
259
  char key_buff[80];
260 261
  String tmp_key_value(key_buff, sizeof(key_buff), system_charset_info);
  String *sptr, *key;
262 263 264 265 266
  DBUG_ENTER("Item_func_aes_decrypt::val_str");

  sptr= args[0]->val_str(str);			// String to decrypt
  key=  args[1]->val_str(&tmp_key_value);	// Key
  if (sptr && key)  			// Need to have both arguments not NULL
267 268
  {
    null_value=0;
269
    if (!str_value.alloc(sptr->length()))  // Ensure that memory is free
270
    {
271
      // finally decrypt directly to allocated buffer.
272 273 274
      int length;
      length=my_aes_decrypt(sptr->ptr(), sptr->length(),
			    (char*) str_value.ptr(),
275 276
                            key->ptr(), key->length());
      if (length >= 0)  // if we got correct data data
277
      {
278 279
        str_value.length((uint) length);
        DBUG_RETURN(&str_value);
280
      }
281 282 283 284
    }
  }
  // Bad parameters. No memory or bad data will all go here
  null_value=1;
285
  DBUG_RETURN(0);
286 287
}

288

289 290 291
void Item_func_aes_decrypt::fix_length_and_dec()
{
   max_length=args[0]->max_length;
unknown's avatar
unknown committed
292
   maybe_null= 1;
293
}
294 295


unknown's avatar
unknown committed
296
/*
297 298 299
  Concatenate args with the following premises:
  If only one arg (which is ok), return value of arg
  Don't reallocate val_str() if not absolute necessary.
unknown's avatar
unknown committed
300 301 302 303
*/

String *Item_func_concat::val_str(String *str)
{
304
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
305 306
  String *res,*res2,*use_as_buff;
  uint i;
307
  bool is_const= 0;
unknown's avatar
unknown committed
308 309 310 311 312

  null_value=0;
  if (!(res=args[0]->val_str(str)))
    goto null;
  use_as_buff= &tmp_value;
unknown's avatar
unknown committed
313 314
  /* Item_subselect in --ps-protocol mode will state it as a non-const */
  is_const= args[0]->const_item() || !args[0]->used_tables();
unknown's avatar
unknown committed
315 316 317 318 319 320 321 322 323 324 325 326 327
  for (i=1 ; i < arg_count ; i++)
  {
    if (res->length() == 0)
    {
      if (!(res=args[i]->val_str(str)))
	goto null;
    }
    else
    {
      if (!(res2=args[i]->val_str(use_as_buff)))
	goto null;
      if (res2->length() == 0)
	continue;
unknown's avatar
unknown committed
328 329
      if (res->length()+res2->length() >
	  current_thd->variables.max_allowed_packet)
330 331 332
      {
	push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			    ER_WARN_ALLOWED_PACKET_OVERFLOWED,
333 334
			    ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
			    current_thd->variables.max_allowed_packet);
335 336
	goto null;
      }
337
      if (!is_const && res->alloced_length() >= res->length()+res2->length())
unknown's avatar
unknown committed
338 339 340 341 342 343 344 345 346 347 348 349
      {						// Use old buffer
	res->append(*res2);
      }
      else if (str->alloced_length() >= res->length()+res2->length())
      {
	if (str == res2)
	  str->replace(0,0,*res);
	else
	{
	  str->copy(*res);
	  str->append(*res2);
	}
350 351
        res= str;
        use_as_buff= &tmp_value;
unknown's avatar
unknown committed
352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
      }
      else if (res == &tmp_value)
      {
	if (res->append(*res2))			// Must be a blob
	  goto null;
      }
      else if (res2 == &tmp_value)
      {						// This can happend only 1 time
	if (tmp_value.replace(0,0,*res))
	  goto null;
	res= &tmp_value;
	use_as_buff=str;			// Put next arg here
      }
      else if (tmp_value.is_alloced() && res2->ptr() >= tmp_value.ptr() &&
	       res2->ptr() <= tmp_value.ptr() + tmp_value.alloced_length())
      {
	/*
	  This happens really seldom:
	  In this case res2 is sub string of tmp_value.  We will
	  now work in place in tmp_value to set it to res | res2
	*/
	/* Chop the last characters in tmp_value that isn't in res2 */
	tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
			 res2->length());
	/* Place res2 at start of tmp_value, remove chars before res2 */
	if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
			      *res))
	  goto null;
	res= &tmp_value;
	use_as_buff=str;			// Put next arg here
      }
      else
      {						// Two big const strings
	if (tmp_value.alloc(max_length) ||
	    tmp_value.copy(*res) ||
	    tmp_value.append(*res2))
	  goto null;
	res= &tmp_value;
	use_as_buff=str;
      }
392
      is_const= 0;
unknown's avatar
unknown committed
393 394
    }
  }
395
  res->set_charset(collation.collation);
unknown's avatar
unknown committed
396 397 398 399 400 401 402 403 404 405
  return res;

null:
  null_value=1;
  return 0;
}


void Item_func_concat::fix_length_and_dec()
{
406
  ulonglong max_result_length= 0;
407

408
  if (agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV, 1))
unknown's avatar
unknown committed
409 410
    return;

unknown's avatar
unknown committed
411
  for (uint i=0 ; i < arg_count ; i++)
412 413 414 415 416 417 418 419
  {
    if (args[i]->collation.collation->mbmaxlen != collation.collation->mbmaxlen)
      max_result_length+= (args[i]->max_length /
                           args[i]->collation.collation->mbmaxlen) *
                           collation.collation->mbmaxlen;
    else
      max_result_length+= args[i]->max_length;
  }
420

421
  if (max_result_length >= MAX_BLOB_WIDTH)
unknown's avatar
unknown committed
422
  {
423 424
    max_result_length= MAX_BLOB_WIDTH;
    maybe_null= 1;
unknown's avatar
unknown committed
425
  }
426
  max_length= (ulong) max_result_length;
unknown's avatar
unknown committed
427 428
}

429
/*
unknown's avatar
unknown committed
430 431
  Function des_encrypt() by tonu@spam.ee & monty
  Works only if compiled with OpenSSL library support.
432
  This returns a binary string where first character is CHAR(128 | key-number).
unknown's avatar
unknown committed
433
  If one uses a string key key_number is 127.
434
  Encryption result is longer than original by formula:
unknown's avatar
unknown committed
435
  new_length= org_length + (8-(org_length % 8))+1
436 437
*/

438 439
String *Item_func_des_encrypt::val_str(String *str)
{
440
  DBUG_ASSERT(fixed == 1);
441
#ifdef HAVE_OPENSSL
442
  uint code= ER_WRONG_PARAMETERS_TO_PROCEDURE;
443
  DES_cblock ivec;
unknown's avatar
unknown committed
444 445
  struct st_des_keyblock keyblock;
  struct st_des_keyschedule keyschedule;
unknown's avatar
unknown committed
446 447
  const char *append_str="********";
  uint key_number, res_length, tail;
unknown's avatar
unknown committed
448
  String *res= args[0]->val_str(str);
449

unknown's avatar
unknown committed
450 451
  if ((null_value= args[0]->null_value))
    return 0;                                   // ENCRYPT(NULL) == NULL
unknown's avatar
unknown committed
452
  if ((res_length=res->length()) == 0)
unknown's avatar
SCRUM  
unknown committed
453
    return &my_empty_string;
unknown's avatar
unknown committed
454

unknown's avatar
unknown committed
455
  if (arg_count == 1)
unknown's avatar
unknown committed
456 457 458 459 460 461
  {
    /* Protect against someone doing FLUSH DES_KEY_FILE */
    VOID(pthread_mutex_lock(&LOCK_des_key_file));
    keyschedule= des_keyschedule[key_number=des_default_key];
    VOID(pthread_mutex_unlock(&LOCK_des_key_file));
  }
unknown's avatar
unknown committed
462
  else if (args[1]->result_type() == INT_RESULT)
unknown's avatar
unknown committed
463 464 465 466
  {
    key_number= (uint) args[1]->val_int();
    if (key_number > 9)
      goto error;
unknown's avatar
unknown committed
467 468 469
    VOID(pthread_mutex_lock(&LOCK_des_key_file));
    keyschedule= des_keyschedule[key_number];
    VOID(pthread_mutex_unlock(&LOCK_des_key_file));
470
  }
unknown's avatar
unknown committed
471 472 473 474 475
  else
  {
    String *keystr=args[1]->val_str(&tmp_value);
    if (!keystr)
      goto error;
unknown's avatar
unknown committed
476
    key_number=127;				// User key string
unknown's avatar
unknown committed
477 478

    /* We make good 24-byte (168 bit) key from given plaintext key with MD5 */
unknown's avatar
unknown committed
479
    bzero((char*) &ivec,sizeof(ivec));
unknown's avatar
unknown committed
480 481 482
    EVP_BytesToKey(EVP_des_ede3_cbc(),EVP_md5(),NULL,
		   (uchar*) keystr->ptr(), (int) keystr->length(),
		   1, (uchar*) &keyblock,ivec);
483 484 485
    DES_set_key_unchecked(&keyblock.key1,&keyschedule.ks1);
    DES_set_key_unchecked(&keyblock.key2,&keyschedule.ks2);
    DES_set_key_unchecked(&keyblock.key3,&keyschedule.ks3);
unknown's avatar
unknown committed
486 487
  }

488
  /*
unknown's avatar
unknown committed
489
     The problem: DES algorithm requires original data to be in 8-bytes
490 491
     chunks. Missing bytes get filled with '*'s and result of encryption
     can be up to 8 bytes longer than original string. When decrypted,
unknown's avatar
unknown committed
492
     we do not know the size of original string :(
unknown's avatar
unknown committed
493 494
     We add one byte with value 0x1..0x8 as the last byte of the padded
     string marking change of string length.
unknown's avatar
unknown committed
495 496
  */

unknown's avatar
unknown committed
497 498
  tail=  (8-(res_length) % 8);			// 1..8 marking extra length
  res_length+=tail;
499
  code= ER_OUT_OF_RESOURCES;
unknown's avatar
unknown committed
500
  if (tail && res->append(append_str, tail) || tmp_value.alloc(res_length+1))
unknown's avatar
unknown committed
501
    goto error;
unknown's avatar
unknown committed
502 503 504
  (*res)[res_length-1]=tail;			// save extra length
  tmp_value.length(res_length+1);
  tmp_value[0]=(char) (128 | key_number);
unknown's avatar
unknown committed
505
  // Real encryption
unknown's avatar
unknown committed
506
  bzero((char*) &ivec,sizeof(ivec));
507
  DES_ede3_cbc_encrypt((const uchar*) (res->ptr()),
unknown's avatar
unknown committed
508
		       (uchar*) (tmp_value.ptr()+1),
unknown's avatar
unknown committed
509
		       res_length,
510 511 512
		       &keyschedule.ks1,
		       &keyschedule.ks2,
		       &keyschedule.ks3,
unknown's avatar
unknown committed
513 514 515 516
		       &ivec, TRUE);
  return &tmp_value;

error:
517 518 519 520 521 522 523
  push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
                          code, ER(code),
                          "des_encrypt");
#else
  push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
                      ER_FEATURE_DISABLED, ER(ER_FEATURE_DISABLED),
                      "des_encrypt","--with-openssl");
unknown's avatar
unknown committed
524
#endif	/* HAVE_OPENSSL */
525 526 527 528
  null_value=1;
  return 0;
}

unknown's avatar
unknown committed
529

530 531
String *Item_func_des_decrypt::val_str(String *str)
{
532
  DBUG_ASSERT(fixed == 1);
533
#ifdef HAVE_OPENSSL
534
  uint code= ER_WRONG_PARAMETERS_TO_PROCEDURE;
535
  DES_cblock ivec;
unknown's avatar
unknown committed
536 537
  struct st_des_keyblock keyblock;
  struct st_des_keyschedule keyschedule;
unknown's avatar
unknown committed
538
  String *res= args[0]->val_str(str);
539
  uint length,tail;
540

541
  if ((null_value= args[0]->null_value))
unknown's avatar
unknown committed
542
    return 0;
543
  length= res->length();
unknown's avatar
unknown committed
544
  if (length < 9 || (length % 8) != 1 || !((*res)[0] & 128))
unknown's avatar
unknown committed
545
    return res;				// Skip decryption if not encrypted
unknown's avatar
unknown committed
546

unknown's avatar
unknown committed
547
  if (arg_count == 1)			// If automatic uncompression
548
  {
unknown's avatar
unknown committed
549
    uint key_number=(uint) (*res)[0] & 127;
unknown's avatar
unknown committed
550
    // Check if automatic key and that we have privilege to uncompress using it
551 552
    if (!(current_thd->security_ctx->master_access & SUPER_ACL) ||
        key_number > 9)
unknown's avatar
unknown committed
553
      goto error;
554

unknown's avatar
unknown committed
555 556 557
    VOID(pthread_mutex_lock(&LOCK_des_key_file));
    keyschedule= des_keyschedule[key_number];
    VOID(pthread_mutex_unlock(&LOCK_des_key_file));
558
  }
unknown's avatar
unknown committed
559 560 561 562
  else
  {
    // We make good 24-byte (168 bit) key from given plaintext key with MD5
    String *keystr=args[1]->val_str(&tmp_value);
unknown's avatar
unknown committed
563
    if (!keystr)
unknown's avatar
unknown committed
564
      goto error;
unknown's avatar
unknown committed
565

unknown's avatar
unknown committed
566
    bzero((char*) &ivec,sizeof(ivec));
unknown's avatar
unknown committed
567 568 569 570
    EVP_BytesToKey(EVP_des_ede3_cbc(),EVP_md5(),NULL,
		   (uchar*) keystr->ptr(),(int) keystr->length(),
		   1,(uchar*) &keyblock,ivec);
    // Here we set all 64-bit keys (56 effective) one by one
571 572
    DES_set_key_unchecked(&keyblock.key1,&keyschedule.ks1);
    DES_set_key_unchecked(&keyblock.key2,&keyschedule.ks2);
unknown's avatar
unknown committed
573
    DES_set_key_unchecked(&keyblock.key3,&keyschedule.ks3);
unknown's avatar
unknown committed
574
  }
575
  code= ER_OUT_OF_RESOURCES;
unknown's avatar
unknown committed
576
  if (tmp_value.alloc(length-1))
unknown's avatar
unknown committed
577
    goto error;
unknown's avatar
unknown committed
578 579

  bzero((char*) &ivec,sizeof(ivec));
580
  DES_ede3_cbc_encrypt((const uchar*) res->ptr()+1,
unknown's avatar
unknown committed
581
		       (uchar*) (tmp_value.ptr()),
unknown's avatar
unknown committed
582
		       length-1,
583 584 585
		       &keyschedule.ks1,
		       &keyschedule.ks2,
		       &keyschedule.ks3,
unknown's avatar
unknown committed
586
		       &ivec, FALSE);
unknown's avatar
unknown committed
587 588
  /* Restore old length of key */
  if ((tail=(uint) (uchar) tmp_value[length-2]) > 8)
589
    goto wrong_key;				     // Wrong key
unknown's avatar
unknown committed
590
  tmp_value.length(length-1-tail);
unknown's avatar
unknown committed
591 592 593
  return &tmp_value;

error:
594 595 596 597 598 599 600 601
  push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
                          code, ER(code),
                          "des_decrypt");
wrong_key:
#else
  push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
                      ER_FEATURE_DISABLED, ER(ER_FEATURE_DISABLED),
                      "des_decrypt","--with-openssl");
unknown's avatar
unknown committed
602
#endif	/* HAVE_OPENSSL */
603 604 605 606 607
  null_value=1;
  return 0;
}


608
/*
unknown's avatar
unknown committed
609 610
  concat with separator. First arg is the separator
  concat_ws takes at least two arguments.
unknown's avatar
unknown committed
611 612 613 614
*/

String *Item_func_concat_ws::val_str(String *str)
{
615
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
616
  char tmp_str_buff[10];
617
  String tmp_sep_str(tmp_str_buff, sizeof(tmp_str_buff),default_charset_info),
unknown's avatar
unknown committed
618 619 620 621
         *sep_str, *res, *res2,*use_as_buff;
  uint i;

  null_value=0;
622
  if (!(sep_str= args[0]->val_str(&tmp_sep_str)))
unknown's avatar
unknown committed
623 624 625
    goto null;

  use_as_buff= &tmp_value;
unknown's avatar
unknown committed
626
  str->length(0);				// QQ; Should be removed
unknown's avatar
unknown committed
627 628
  res=str;

629
  // Skip until non-null argument is found.
unknown's avatar
unknown committed
630
  // If not, return the empty string
631
  for (i=1; i < arg_count; i++)
632
    if ((res= args[i]->val_str(str)))
633
      break;
unknown's avatar
unknown committed
634
  if (i ==  arg_count)
unknown's avatar
SCRUM  
unknown committed
635
    return &my_empty_string;
unknown's avatar
unknown committed
636 637 638

  for (i++; i < arg_count ; i++)
  {
639 640
    if (!(res2= args[i]->val_str(use_as_buff)))
      continue;					// Skip NULL
unknown's avatar
unknown committed
641 642

    if (res->length() + sep_str->length() + res2->length() >
unknown's avatar
unknown committed
643
	current_thd->variables.max_allowed_packet)
644 645 646
    {
      push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			  ER_WARN_ALLOWED_PACKET_OVERFLOWED,
647 648
			  ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
			  current_thd->variables.max_allowed_packet);
649 650
      goto null;
    }
unknown's avatar
unknown committed
651 652 653 654 655 656 657 658
    if (res->alloced_length() >=
	res->length() + sep_str->length() + res2->length())
    {						// Use old buffer
      res->append(*sep_str);			// res->length() > 0 always
      res->append(*res2);
    }
    else if (str->alloced_length() >=
	     res->length() + sep_str->length() + res2->length())
unknown's avatar
unknown committed
659
    {
660 661 662 663 664 665 666 667 668 669 670 671
      /* We have room in str;  We can't get any errors here */
      if (str == res2)
      {						// This is quote uncommon!
	str->replace(0,0,*sep_str);
	str->replace(0,0,*res);
      }
      else
      {
	str->copy(*res);
	str->append(*sep_str);
	str->append(*res2);
      }
unknown's avatar
unknown committed
672 673 674 675 676
      res=str;
      use_as_buff= &tmp_value;
    }
    else if (res == &tmp_value)
    {
677
      if (res->append(*sep_str) || res->append(*res2))
unknown's avatar
unknown committed
678 679
	goto null; // Must be a blob
    }
680 681 682 683 684 685 686
    else if (res2 == &tmp_value)
    {						// This can happend only 1 time
      if (tmp_value.replace(0,0,*sep_str) || tmp_value.replace(0,0,*res))
	goto null;
      res= &tmp_value;
      use_as_buff=str;				// Put next arg here
    }
unknown's avatar
unknown committed
687
    else if (tmp_value.is_alloced() && res2->ptr() >= tmp_value.ptr() &&
688
	     res2->ptr() < tmp_value.ptr() + tmp_value.alloced_length())
unknown's avatar
unknown committed
689 690 691 692
    {
      /*
	This happens really seldom:
	In this case res2 is sub string of tmp_value.  We will
693
	now work in place in tmp_value to set it to res | sep_str | res2
unknown's avatar
unknown committed
694 695 696 697 698 699
      */
      /* Chop the last characters in tmp_value that isn't in res2 */
      tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
		       res2->length());
      /* Place res2 at start of tmp_value, remove chars before res2 */
      if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
700 701
			    *res) ||
	  tmp_value.replace(res->length(),0, *sep_str))
unknown's avatar
unknown committed
702 703 704 705 706 707 708 709 710 711 712 713 714
	goto null;
      res= &tmp_value;
      use_as_buff=str;			// Put next arg here
    }
    else
    {						// Two big const strings
      if (tmp_value.alloc(max_length) ||
	  tmp_value.copy(*res) ||
	  tmp_value.append(*sep_str) ||
	  tmp_value.append(*res2))
	goto null;
      res= &tmp_value;
      use_as_buff=str;
unknown's avatar
unknown committed
715 716
    }
  }
717
  res->set_charset(collation.collation);
unknown's avatar
unknown committed
718 719 720 721 722 723 724 725 726 727
  return res;

null:
  null_value=1;
  return 0;
}


void Item_func_concat_ws::fix_length_and_dec()
{
728
  ulonglong max_result_length;
729

730
  if (agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV, 1))
731 732
    return;

unknown's avatar
unknown committed
733 734 735 736 737
  /*
     arg_count cannot be less than 2,
     it is done on parser level in sql_yacc.yy
     so, (arg_count - 2) is safe here.
  */
738
  max_result_length= (ulonglong) args[0]->max_length * (arg_count - 2);
739
  for (uint i=1 ; i < arg_count ; i++)
740
    max_result_length+=args[i]->max_length;
741

742
  if (max_result_length >= MAX_BLOB_WIDTH)
unknown's avatar
unknown committed
743
  {
744 745
    max_result_length= MAX_BLOB_WIDTH;
    maybe_null= 1;
unknown's avatar
unknown committed
746
  }
747
  max_length= (ulong) max_result_length;
unknown's avatar
unknown committed
748 749
}

unknown's avatar
unknown committed
750 751 752

String *Item_func_reverse::val_str(String *str)
{
753
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
754
  String *res = args[0]->val_str(str);
unknown's avatar
unknown committed
755
  char *ptr, *end, *tmp;
unknown's avatar
unknown committed
756 757 758 759 760

  if ((null_value=args[0]->null_value))
    return 0;
  /* An empty string is a special case as the string pointer may be null */
  if (!res->length())
unknown's avatar
SCRUM  
unknown committed
761
    return &my_empty_string;
unknown's avatar
unknown committed
762 763 764 765 766 767 768 769 770 771 772
  if (tmp_value.alloced_length() < res->length() &&
      tmp_value.realloc(res->length()))
  {
    null_value= 1;
    return 0;
  }
  tmp_value.length(res->length());
  tmp_value.set_charset(res->charset());
  ptr= (char *) res->ptr();
  end= ptr + res->length();
  tmp= (char *) tmp_value.ptr() + tmp_value.length();
unknown's avatar
unknown committed
773
#ifdef USE_MB
774
  if (use_mb(res->charset()))
unknown's avatar
unknown committed
775 776 777 778
  {
    register uint32 l;
    while (ptr < end)
    {
unknown's avatar
unknown committed
779 780 781 782 783 784
      if ((l= my_ismbchar(res->charset(),ptr,end)))
      {
        tmp-= l;
        memcpy(tmp,ptr,l);
        ptr+= l;
      }
unknown's avatar
unknown committed
785
      else
unknown's avatar
unknown committed
786
        *--tmp= *ptr++;
unknown's avatar
unknown committed
787 788 789 790 791 792
    }
  }
  else
#endif /* USE_MB */
  {
    while (ptr < end)
unknown's avatar
unknown committed
793
      *--tmp= *ptr++;
unknown's avatar
unknown committed
794
  }
unknown's avatar
unknown committed
795
  return &tmp_value;
unknown's avatar
unknown committed
796 797 798 799 800
}


void Item_func_reverse::fix_length_and_dec()
{
801
  collation.set(args[0]->collation);
unknown's avatar
unknown committed
802 803 804 805 806
  max_length = args[0]->max_length;
}

/*
** Replace all occurences of string2 in string1 with string3.
807
** Don't reallocate val_str() if not needed
unknown's avatar
unknown committed
808 809 810 811 812 813
*/

/* TODO: Fix that this works with binary strings when using USE_MB */

String *Item_func_replace::val_str(String *str)
{
814
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
815
  String *res,*res2,*res3;
unknown's avatar
unknown committed
816
  int offset;
unknown's avatar
unknown committed
817 818 819 820 821
  uint from_length,to_length;
  bool alloced=0;
#ifdef USE_MB
  const char *ptr,*end,*strend,*search,*search_end;
  register uint32 l;
822
  bool binary_cmp;
unknown's avatar
unknown committed
823 824 825 826 827 828 829 830 831 832
#endif

  null_value=0;
  res=args[0]->val_str(str);
  if (args[0]->null_value)
    goto null;
  res2=args[1]->val_str(&tmp_value);
  if (args[1]->null_value)
    goto null;

833 834
  res->set_charset(collation.collation);

835
#ifdef USE_MB
836
  binary_cmp = ((res->charset()->state & MY_CS_BINSORT) || !use_mb(res->charset()));
837 838
#endif

unknown's avatar
unknown committed
839 840 841 842 843 844
  if (res2->length() == 0)
    return res;
#ifndef USE_MB
  if ((offset=res->strstr(*res2)) < 0)
    return res;
#else
unknown's avatar
unknown committed
845
  offset=0;
846
  if (binary_cmp && (offset=res->strstr(*res2)) < 0)
unknown's avatar
unknown committed
847 848 849 850 851 852 853 854
    return res;
#endif
  if (!(res3=args[2]->val_str(&tmp_value2)))
    goto null;
  from_length= res2->length();
  to_length=   res3->length();

#ifdef USE_MB
855
  if (!binary_cmp)
unknown's avatar
unknown committed
856 857 858 859 860 861 862 863 864 865 866 867 868 869
  {
    search=res2->ptr();
    search_end=search+from_length;
redo:
    ptr=res->ptr()+offset;
    strend=res->ptr()+res->length();
    end=strend-from_length+1;
    while (ptr < end)
    {
        if (*ptr == *search)
        {
          register char *i,*j;
          i=(char*) ptr+1; j=(char*) search+1;
          while (j != search_end)
870
            if (*i++ != *j++) goto skip;
unknown's avatar
unknown committed
871
          offset= (int) (ptr-res->ptr());
unknown's avatar
unknown committed
872 873
          if (res->length()-from_length + to_length >
	      current_thd->variables.max_allowed_packet)
874 875 876 877
	  {
	    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
				ER_WARN_ALLOWED_PACKET_OVERFLOWED,
				ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
878 879
				func_name(),
				current_thd->variables.max_allowed_packet);
880

unknown's avatar
unknown committed
881
            goto null;
882
	  }
unknown's avatar
unknown committed
883 884 885 886 887 888
          if (!alloced)
          {
            alloced=1;
            res=copy_if_not_alloced(str,res,res->length()+to_length);
          }
          res->replace((uint) offset,from_length,*res3);
unknown's avatar
unknown committed
889
	  offset+=(int) to_length;
unknown's avatar
unknown committed
890 891
          goto redo;
        }
892
skip:
893
        if ((l=my_ismbchar(res->charset(), ptr,strend))) ptr+=l;
unknown's avatar
unknown committed
894 895 896 897 898 899 900
        else ++ptr;
    }
  }
  else
#endif /* USE_MB */
    do
    {
unknown's avatar
unknown committed
901 902
      if (res->length()-from_length + to_length >
	  current_thd->variables.max_allowed_packet)
903 904 905
      {
	push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			    ER_WARN_ALLOWED_PACKET_OVERFLOWED,
906 907
			    ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
			    current_thd->variables.max_allowed_packet);
unknown's avatar
unknown committed
908
        goto null;
909
      }
unknown's avatar
unknown committed
910 911 912 913 914 915 916 917
      if (!alloced)
      {
        alloced=1;
        res=copy_if_not_alloced(str,res,res->length()+to_length);
      }
      res->replace((uint) offset,from_length,*res3);
      offset+=(int) to_length;
    }
918
    while ((offset=res->strstr(*res2,(uint) offset)) >= 0);
unknown's avatar
unknown committed
919 920 921 922 923 924 925 926 927 928
  return res;

null:
  null_value=1;
  return 0;
}


void Item_func_replace::fix_length_and_dec()
{
929
  ulonglong max_result_length= args[0]->max_length;
unknown's avatar
unknown committed
930 931 932
  int diff=(int) (args[2]->max_length - args[1]->max_length);
  if (diff > 0 && args[1]->max_length)
  {						// Calculate of maxreplaces
933 934
    ulonglong max_substrs= max_result_length/args[1]->max_length;
    max_result_length+= max_substrs * (uint) diff;
unknown's avatar
unknown committed
935
  }
936
  if (max_result_length >= MAX_BLOB_WIDTH)
unknown's avatar
unknown committed
937
  {
938 939
    max_result_length= MAX_BLOB_WIDTH;
    maybe_null= 1;
unknown's avatar
unknown committed
940
  }
941
  max_length= (ulong) max_result_length;
942
  
943
  if (agg_arg_charsets(collation, args, 3, MY_COLL_CMP_CONV, 1))
unknown's avatar
unknown committed
944
    return;
unknown's avatar
unknown committed
945 946 947 948 949
}


String *Item_func_insert::val_str(String *str)
{
950
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
951 952 953 954 955 956 957 958 959 960 961
  String *res,*res2;
  uint start,length;

  null_value=0;
  res=args[0]->val_str(str);
  res2=args[3]->val_str(&tmp_value);
  start=(uint) args[1]->val_int()-1;
  length=(uint) args[2]->val_int();
  if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
      args[3]->null_value)
    goto null; /* purecov: inspected */
unknown's avatar
unknown committed
962 963
  start=res->charpos(start);
  length=res->charpos(length,start);
unknown's avatar
unknown committed
964
  if (start > res->length()+1)
unknown's avatar
unknown committed
965
    return res;					// Wrong param; skip insert
unknown's avatar
unknown committed
966 967
  if (length > res->length()-start)
    length=res->length()-start;
unknown's avatar
unknown committed
968 969
  if (res->length() - length + res2->length() >
      current_thd->variables.max_allowed_packet)
970 971 972
  {
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			ER_WARN_ALLOWED_PACKET_OVERFLOWED,
973 974
			ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
			func_name(), current_thd->variables.max_allowed_packet);
975 976
    goto null;
  }
unknown's avatar
unknown committed
977 978 979 980 981 982 983 984 985 986 987
  res=copy_if_not_alloced(str,res,res->length());
  res->replace(start,length,*res2);
  return res;
null:
  null_value=1;
  return 0;
}


void Item_func_insert::fix_length_and_dec()
{
988 989
  ulonglong max_result_length;

990 991
  // Handle character set for args[0] and args[3].
  if (agg_arg_charsets(collation, &args[0], 2, MY_COLL_ALLOW_CONV, 3))
unknown's avatar
unknown committed
992
    return;
993 994 995
  max_result_length= ((ulonglong) args[0]->max_length+
                      (ulonglong) args[3]->max_length);
  if (max_result_length >= MAX_BLOB_WIDTH)
unknown's avatar
unknown committed
996
  {
997 998
    max_result_length= MAX_BLOB_WIDTH;
    maybe_null= 1;
unknown's avatar
unknown committed
999
  }
1000
  max_length= (ulong) max_result_length;
unknown's avatar
unknown committed
1001 1002 1003
}


1004
String *Item_str_conv::val_str(String *str)
unknown's avatar
unknown committed
1005
{
1006
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1007 1008 1009 1010 1011 1012 1013
  String *res;
  if (!(res=args[0]->val_str(str)))
  {
    null_value=1; /* purecov: inspected */
    return 0; /* purecov: inspected */
  }
  null_value=0;
1014
  if (multiply == 1)
unknown's avatar
unknown committed
1015
  {
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031
    uint len;
    res= copy_if_not_alloced(str,res,res->length());
    len= converter(collation.collation, (char*) res->ptr(), res->length(),
                                        (char*) res->ptr(), res->length());
    DBUG_ASSERT(len <= res->length());
    res->length(len);
  }
  else
  {
    uint len= res->length() * multiply;
    tmp_value.alloc(len);
    tmp_value.set_charset(collation.collation);
    len= converter(collation.collation, (char*) res->ptr(), res->length(),
                                        (char*) tmp_value.ptr(), len);
    tmp_value.length(len);
    res= &tmp_value;
unknown's avatar
unknown committed
1032 1033 1034 1035 1036 1037 1038
  }
  return res;
}


String *Item_func_left::val_str(String *str)
{
1039
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1040 1041
  String *res  =args[0]->val_str(str);
  long length  =(long) args[1]->val_int();
1042
  uint char_pos;
unknown's avatar
unknown committed
1043

unknown's avatar
unknown committed
1044
  if ((null_value=(args[0]->null_value || args[1]->null_value)))
unknown's avatar
unknown committed
1045 1046
    return 0;
  if (length <= 0)
unknown's avatar
SCRUM  
unknown committed
1047
    return &my_empty_string;
1048 1049
  if (res->length() <= (uint) length ||
      res->length() <= (char_pos= res->charpos(length)))
unknown's avatar
a fix  
unknown committed
1050
    return res;
1051 1052 1053

  tmp_value.set(*res, 0, char_pos);
  return &tmp_value;
unknown's avatar
unknown committed
1054 1055 1056 1057 1058 1059 1060 1061
}


void Item_str_func::left_right_max_length()
{
  max_length=args[0]->max_length;
  if (args[1]->const_item())
  {
1062
    int length=(int) args[1]->val_int()*collation.collation->mbmaxlen;
unknown's avatar
unknown committed
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
    if (length <= 0)
      max_length=0;
    else
      set_if_smaller(max_length,(uint) length);
  }
}


void Item_func_left::fix_length_and_dec()
{
1073
  collation.set(args[0]->collation);
unknown's avatar
unknown committed
1074 1075 1076 1077 1078 1079
  left_right_max_length();
}


String *Item_func_right::val_str(String *str)
{
1080
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1081 1082 1083
  String *res  =args[0]->val_str(str);
  long length  =(long) args[1]->val_int();

unknown's avatar
unknown committed
1084
  if ((null_value=(args[0]->null_value || args[1]->null_value)))
unknown's avatar
unknown committed
1085 1086
    return 0; /* purecov: inspected */
  if (length <= 0)
unknown's avatar
SCRUM  
unknown committed
1087
    return &my_empty_string; /* purecov: inspected */
unknown's avatar
unknown committed
1088 1089
  if (res->length() <= (uint) length)
    return res; /* purecov: inspected */
unknown's avatar
unknown committed
1090

unknown's avatar
unknown committed
1091 1092
  uint start=res->numchars();
  if (start <= (uint) length)
unknown's avatar
unknown committed
1093
    return res;
unknown's avatar
unknown committed
1094
  start=res->charpos(start - (uint) length);
unknown's avatar
unknown committed
1095
  tmp_value.set(*res,start,res->length()-start);
unknown's avatar
unknown committed
1096 1097 1098 1099 1100 1101
  return &tmp_value;
}


void Item_func_right::fix_length_and_dec()
{
1102
  collation.set(args[0]->collation);
unknown's avatar
unknown committed
1103 1104 1105 1106 1107 1108
  left_right_max_length();
}


String *Item_func_substr::val_str(String *str)
{
1109
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1110
  String *res  = args[0]->val_str(str);
1111
  int32 start	= (int32) args[1]->val_int();
unknown's avatar
unknown committed
1112 1113 1114 1115 1116 1117
  int32 length	= arg_count == 3 ? (int32) args[2]->val_int() : INT_MAX32;
  int32 tmp_length;

  if ((null_value=(args[0]->null_value || args[1]->null_value ||
		   (arg_count == 3 && args[2]->null_value))))
    return 0; /* purecov: inspected */
1118
  start= (int32)((start < 0) ? res->numchars() + start : start -1);
unknown's avatar
unknown committed
1119 1120
  start=res->charpos(start);
  length=res->charpos(length,start);
unknown's avatar
unknown committed
1121
  if (start < 0 || (uint) start+1 > res->length() || length <= 0)
unknown's avatar
SCRUM  
unknown committed
1122
    return &my_empty_string;
unknown's avatar
unknown committed
1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137

  tmp_length=(int32) res->length()-start;
  length=min(length,tmp_length);

  if (!start && res->length() == (uint) length)
    return res;
  tmp_value.set(*res,(uint) start,(uint) length);
  return &tmp_value;
}


void Item_func_substr::fix_length_and_dec()
{
  max_length=args[0]->max_length;

1138
  collation.set(args[0]->collation);
unknown's avatar
unknown committed
1139 1140
  if (args[1]->const_item())
  {
1141 1142
    int32 start= (int32) args[1]->val_int();
    start= (int32)((start < 0) ? max_length + start : start - 1);
unknown's avatar
unknown committed
1143 1144 1145 1146 1147 1148 1149
    if (start < 0 || start >= (int32) max_length)
      max_length=0; /* purecov: inspected */
    else
      max_length-= (uint) start;
  }
  if (arg_count == 3 && args[2]->const_item())
  {
1150
    int32 length= (int32) args[2]->val_int() * collation.collation->mbmaxlen;
unknown's avatar
unknown committed
1151 1152 1153 1154 1155 1156 1157 1158
    if (length <= 0)
      max_length=0; /* purecov: inspected */
    else
      set_if_smaller(max_length,(uint) length);
  }
}


1159 1160 1161
void Item_func_substr_index::fix_length_and_dec()
{ 
  max_length= args[0]->max_length;
unknown's avatar
unknown committed
1162

1163
  if (agg_arg_charsets(collation, args, 2, MY_COLL_CMP_CONV, 1))
unknown's avatar
unknown committed
1164
    return;
1165 1166 1167
}


unknown's avatar
unknown committed
1168 1169
String *Item_func_substr_index::val_str(String *str)
{
1170
  DBUG_ASSERT(fixed == 1);
1171 1172 1173
  String *res= args[0]->val_str(str);
  String *delimiter= args[1]->val_str(&tmp_value);
  int32 count= (int32) args[2]->val_int();
unknown's avatar
unknown committed
1174 1175 1176 1177 1178 1179 1180 1181
  uint offset;

  if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
  {					// string and/or delim are null
    null_value=1;
    return 0;
  }
  null_value=0;
1182 1183
  uint delimiter_length= delimiter->length();
  if (!res->length() || !delimiter_length || !count)
unknown's avatar
SCRUM  
unknown committed
1184
    return &my_empty_string;		// Wrong parameters
unknown's avatar
unknown committed
1185

1186 1187
  res->set_charset(collation.collation);

unknown's avatar
unknown committed
1188
#ifdef USE_MB
1189
  if (use_mb(res->charset()))
unknown's avatar
unknown committed
1190
  {
1191 1192 1193 1194 1195
    const char *ptr= res->ptr();
    const char *strend= ptr+res->length();
    const char *end= strend-delimiter_length+1;
    const char *search= delimiter->ptr();
    const char *search_end= search+delimiter_length;
unknown's avatar
unknown committed
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
    int32 n=0,c=count,pass;
    register uint32 l;
    for (pass=(count>0);pass<2;++pass)
    {
      while (ptr < end)
      {
        if (*ptr == *search)
        {
	  register char *i,*j;
	  i=(char*) ptr+1; j=(char*) search+1;
	  while (j != search_end)
1207
	    if (*i++ != *j++) goto skip;
unknown's avatar
unknown committed
1208 1209
	  if (pass==0) ++n;
	  else if (!--c) break;
1210
	  ptr+= delimiter_length;
unknown's avatar
unknown committed
1211 1212
	  continue;
	}
1213
    skip:
1214
        if ((l=my_ismbchar(res->charset(), ptr,strend))) ptr+=l;
unknown's avatar
unknown committed
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227
        else ++ptr;
      } /* either not found or got total number when count<0 */
      if (pass == 0) /* count<0 */
      {
        c+=n+1;
        if (c<=0) return res; /* not found, return original string */
        ptr=res->ptr();
      }
      else
      {
        if (c) return res; /* Not found, return original string */
        if (count>0) /* return left part */
        {
unknown's avatar
unknown committed
1228
	  tmp_value.set(*res,0,(ulong) (ptr-res->ptr()));
unknown's avatar
unknown committed
1229 1230 1231
        }
        else /* return right part */
        {
1232
	  ptr+= delimiter_length;
unknown's avatar
unknown committed
1233
	  tmp_value.set(*res,(ulong) (ptr-res->ptr()), (ulong) (strend-ptr));
unknown's avatar
unknown committed
1234 1235 1236 1237 1238 1239 1240 1241 1242
        }
      }
    }
  }
  else
#endif /* USE_MB */
  {
    if (count > 0)
    {					// start counting from the beginning
1243
      for (offset=0; ; offset+= delimiter_length)
unknown's avatar
unknown committed
1244
      {
1245
	if ((int) (offset= res->strstr(*delimiter, offset)) < 0)
unknown's avatar
unknown committed
1246 1247 1248 1249 1250 1251 1252 1253 1254
	  return res;			// Didn't find, return org string
	if (!--count)
	{
	  tmp_value.set(*res,0,offset);
	  break;
	}
      }
    }
    else
1255
    {
unknown's avatar
unknown committed
1256 1257 1258 1259
      /*
        Negative index, start counting at the end
      */
      for (offset=res->length(); offset ;)
unknown's avatar
unknown committed
1260
      {
unknown's avatar
unknown committed
1261 1262 1263 1264 1265
        /* 
          this call will result in finding the position pointing to one 
          address space less than where the found substring is located
          in res
        */
1266
	if ((int) (offset= res->strrstr(*delimiter, offset)) < 0)
unknown's avatar
unknown committed
1267
	  return res;			// Didn't find, return org string
unknown's avatar
unknown committed
1268 1269 1270 1271
        /*
          At this point, we've searched for the substring
          the number of times as supplied by the index value
        */
unknown's avatar
unknown committed
1272 1273
	if (!++count)
	{
1274
	  offset+= delimiter_length;
unknown's avatar
unknown committed
1275 1276 1277 1278 1279 1280
	  tmp_value.set(*res,offset,res->length()- offset);
	  break;
	}
      }
    }
  }
1281 1282 1283 1284 1285 1286
  /*
    We always mark tmp_value as const so that if val_str() is called again
    on this object, we don't disrupt the contents of tmp_value when it was
    derived from another String.
  */
  tmp_value.mark_as_const();
unknown's avatar
unknown committed
1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
  return (&tmp_value);
}

/*
** The trim functions are extension to ANSI SQL because they trim substrings
** They ltrim() and rtrim() functions are optimized for 1 byte strings
** They also return the original string if possible, else they return
** a substring that points at the original string.
*/


String *Item_func_ltrim::val_str(String *str)
{
1300
  DBUG_ASSERT(fixed == 1);
1301 1302 1303
  char buff[MAX_FIELD_WIDTH], *ptr, *end;
  String tmp(buff,sizeof(buff),system_charset_info);
  String *res, *remove_str;
unknown's avatar
unknown committed
1304 1305 1306
  uint remove_length;
  LINT_INIT(remove_length);

1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
  res= args[0]->val_str(str);
  if ((null_value=args[0]->null_value))
    return 0;
  remove_str= &remove;                          /* Default value. */
  if (arg_count == 2)
  {
    remove_str= args[1]->val_str(&tmp);
    if ((null_value= args[1]->null_value))
      return 0;
  }

  if ((remove_length= remove_str->length()) == 0 ||
unknown's avatar
unknown committed
1319 1320 1321
      remove_length > res->length())
    return res;

1322 1323
  ptr= (char*) res->ptr();
  end= ptr+res->length();
unknown's avatar
unknown committed
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
  if (remove_length == 1)
  {
    char chr=(*remove_str)[0];
    while (ptr != end && *ptr == chr)
      ptr++;
  }
  else
  {
    const char *r_ptr=remove_str->ptr();
    end-=remove_length;
1334
    while (ptr <= end && !memcmp(ptr, r_ptr, remove_length))
unknown's avatar
unknown committed
1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346
      ptr+=remove_length;
    end+=remove_length;
  }
  if (ptr == res->ptr())
    return res;
  tmp_value.set(*res,(uint) (ptr - res->ptr()),(uint) (end-ptr));
  return &tmp_value;
}


String *Item_func_rtrim::val_str(String *str)
{
1347
  DBUG_ASSERT(fixed == 1);
1348 1349 1350
  char buff[MAX_FIELD_WIDTH], *ptr, *end;
  String tmp(buff, sizeof(buff), system_charset_info);
  String *res, *remove_str;
unknown's avatar
unknown committed
1351 1352 1353
  uint remove_length;
  LINT_INIT(remove_length);

1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365
  res= args[0]->val_str(str);
  if ((null_value=args[0]->null_value))
    return 0;
  remove_str= &remove;                          /* Default value. */
  if (arg_count == 2)
  {
    remove_str= args[1]->val_str(&tmp);
    if ((null_value= args[1]->null_value))
      return 0;
  }

  if ((remove_length= remove_str->length()) == 0 ||
unknown's avatar
unknown committed
1366 1367 1368
      remove_length > res->length())
    return res;

1369 1370
  ptr= (char*) res->ptr();
  end= ptr+res->length();
unknown's avatar
unknown committed
1371 1372 1373 1374 1375 1376 1377 1378
#ifdef USE_MB
  char *p=ptr;
  register uint32 l;
#endif
  if (remove_length == 1)
  {
    char chr=(*remove_str)[0];
#ifdef USE_MB
1379
    if (use_mb(res->charset()))
unknown's avatar
unknown committed
1380 1381 1382
    {
      while (ptr < end)
      {
1383
	if ((l=my_ismbchar(res->charset(), ptr,end))) ptr+=l,p=ptr;
unknown's avatar
unknown committed
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
	else ++ptr;
      }
      ptr=p;
    }
#endif
    while (ptr != end  && end[-1] == chr)
      end--;
  }
  else
  {
    const char *r_ptr=remove_str->ptr();
#ifdef USE_MB
1396
    if (use_mb(res->charset()))
unknown's avatar
unknown committed
1397 1398 1399 1400
    {
  loop:
      while (ptr + remove_length < end)
      {
1401
	if ((l=my_ismbchar(res->charset(), ptr,end))) ptr+=l;
unknown's avatar
unknown committed
1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
	else ++ptr;
      }
      if (ptr + remove_length == end && !memcmp(ptr,r_ptr,remove_length))
      {
	end-=remove_length;
	ptr=p;
	goto loop;
      }
    }
    else
#endif /* USE_MB */
    {
1414 1415
      while (ptr + remove_length <= end &&
	     !memcmp(end-remove_length, r_ptr, remove_length))
unknown's avatar
unknown committed
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
	end-=remove_length;
    }
  }
  if (end == res->ptr()+res->length())
    return res;
  tmp_value.set(*res,0,(uint) (end-res->ptr()));
  return &tmp_value;
}


String *Item_func_trim::val_str(String *str)
{
1428
  DBUG_ASSERT(fixed == 1);
1429 1430 1431 1432
  char buff[MAX_FIELD_WIDTH], *ptr, *end;
  const char *r_ptr;
  String tmp(buff, sizeof(buff), system_charset_info);
  String *res, *remove_str;
unknown's avatar
unknown committed
1433 1434
  uint remove_length;
  LINT_INIT(remove_length);
unknown's avatar
unknown committed
1435

1436 1437 1438 1439
  res= args[0]->val_str(str);
  if ((null_value=args[0]->null_value))
    return 0;
  remove_str= &remove;                          /* Default value. */
unknown's avatar
unknown committed
1440 1441 1442 1443 1444 1445
  if (arg_count == 2)
  {
    remove_str= args[1]->val_str(&tmp);
    if ((null_value= args[1]->null_value))
      return 0;
  }
unknown's avatar
unknown committed
1446

1447
  if ((remove_length= remove_str->length()) == 0 ||
unknown's avatar
unknown committed
1448 1449 1450
      remove_length > res->length())
    return res;

1451 1452 1453
  ptr= (char*) res->ptr();
  end= ptr+res->length();
  r_ptr= remove_str->ptr();
1454
  while (ptr+remove_length <= end && !memcmp(ptr,r_ptr,remove_length))
unknown's avatar
unknown committed
1455 1456
    ptr+=remove_length;
#ifdef USE_MB
1457
  if (use_mb(res->charset()))
unknown's avatar
unknown committed
1458 1459 1460 1461 1462 1463
  {
    char *p=ptr;
    register uint32 l;
 loop:
    while (ptr + remove_length < end)
    {
1464
      if ((l=my_ismbchar(res->charset(), ptr,end))) ptr+=l;
unknown's avatar
unknown committed
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
      else ++ptr;
    }
    if (ptr + remove_length == end && !memcmp(ptr,r_ptr,remove_length))
    {
      end-=remove_length;
      ptr=p;
      goto loop;
    }
    ptr=p;
  }
  else
#endif /* USE_MB */
  {
1478
    while (ptr + remove_length <= end &&
unknown's avatar
unknown committed
1479 1480 1481 1482 1483 1484 1485 1486 1487
	   !memcmp(end-remove_length,r_ptr,remove_length))
      end-=remove_length;
  }
  if (ptr == res->ptr() && end == ptr+res->length())
    return res;
  tmp_value.set(*res,(uint) (ptr - res->ptr()),(uint) (end-ptr));
  return &tmp_value;
}

1488 1489 1490 1491 1492
void Item_func_trim::fix_length_and_dec()
{
  max_length= args[0]->max_length;
  if (arg_count == 1)
  {
1493
    collation.set(args[0]->collation);
1494
    remove.set_charset(collation.collation);
1495 1496 1497 1498
    remove.set_ascii(" ",1);
  }
  else
  {
1499 1500 1501
    // Handle character set for args[1] and args[0].
    // Note that we pass args[1] as the first item, and args[0] as the second.
    if (agg_arg_charsets(collation, &args[1], 2, MY_COLL_CMP_CONV, -1))
unknown's avatar
unknown committed
1502
      return;
1503 1504 1505 1506
  }
}


1507
/* Item_func_password */
unknown's avatar
unknown committed
1508 1509 1510

String *Item_func_password::val_str(String *str)
{
1511
  DBUG_ASSERT(fixed == 1);
1512
  String *res= args[0]->val_str(str); 
unknown's avatar
unknown committed
1513 1514
  if ((null_value=args[0]->null_value))
    return 0;
1515
  if (res->length() == 0)
unknown's avatar
SCRUM  
unknown committed
1516
    return &my_empty_string;
1517 1518 1519
  make_scrambled_password(tmp_value, res->c_ptr());
  str->set(tmp_value, SCRAMBLED_PASSWORD_CHAR_LENGTH, res->charset());
  return str;
unknown's avatar
unknown committed
1520 1521
}

unknown's avatar
unknown committed
1522 1523 1524 1525 1526 1527 1528 1529
char *Item_func_password::alloc(THD *thd, const char *password)
{
  char *buff= (char *) thd->alloc(SCRAMBLED_PASSWORD_CHAR_LENGTH+1);
  if (buff)
    make_scrambled_password(buff, password);
  return buff;
}

1530 1531
/* Item_func_old_password */

1532 1533
String *Item_func_old_password::val_str(String *str)
{
1534
  DBUG_ASSERT(fixed == 1);
1535
  String *res= args[0]->val_str(str);
1536 1537 1538
  if ((null_value=args[0]->null_value))
    return 0;
  if (res->length() == 0)
unknown's avatar
SCRUM  
unknown committed
1539
    return &my_empty_string;
1540 1541
  make_scrambled_password_323(tmp_value, res->c_ptr());
  str->set(tmp_value, SCRAMBLED_PASSWORD_CHAR_LENGTH_323, res->charset());
1542 1543 1544
  return str;
}

unknown's avatar
unknown committed
1545 1546 1547 1548 1549 1550 1551
char *Item_func_old_password::alloc(THD *thd, const char *password)
{
  char *buff= (char *) thd->alloc(SCRAMBLED_PASSWORD_CHAR_LENGTH_323+1);
  if (buff)
    make_scrambled_password_323(buff, password);
  return buff;
}
1552 1553


unknown's avatar
unknown committed
1554
#define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
unknown's avatar
unknown committed
1555 1556 1557

String *Item_func_encrypt::val_str(String *str)
{
1558
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1559 1560 1561 1562 1563 1564 1565
  String *res  =args[0]->val_str(str);

#ifdef HAVE_CRYPT
  char salt[3],*salt_ptr;
  if ((null_value=args[0]->null_value))
    return 0;
  if (res->length() == 0)
unknown's avatar
SCRUM  
unknown committed
1566
    return &my_empty_string;
unknown's avatar
unknown committed
1567 1568 1569 1570

  if (arg_count == 1)
  {					// generate random salt
    time_t timestamp=current_thd->query_start();
unknown's avatar
unknown committed
1571 1572
    salt[0] = bin_to_ascii( (ulong) timestamp & 0x3f);
    salt[1] = bin_to_ascii(( (ulong) timestamp >> 5) & 0x3f);
unknown's avatar
unknown committed
1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
    salt[2] = 0;
    salt_ptr=salt;
  }
  else
  {					// obtain salt from the first two bytes
    String *salt_str=args[1]->val_str(&tmp_value);
    if ((null_value= (args[1]->null_value || salt_str->length() < 2)))
      return 0;
    salt_ptr= salt_str->c_ptr();
  }
  pthread_mutex_lock(&LOCK_crypt);
1584 1585 1586 1587 1588 1589 1590
  char *tmp= crypt(res->c_ptr(),salt_ptr);
  if (!tmp)
  {
    pthread_mutex_unlock(&LOCK_crypt);
    null_value= 1;
    return 0;
  }
1591
  str->set(tmp,(uint) strlen(tmp),res->charset());
unknown's avatar
unknown committed
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604
  str->copy();
  pthread_mutex_unlock(&LOCK_crypt);
  return str;
#else
  null_value=1;
  return 0;
#endif	/* HAVE_CRYPT */
}

void Item_func_encode::fix_length_and_dec()
{
  max_length=args[0]->max_length;
  maybe_null=args[0]->maybe_null;
1605
  collation.set(&my_charset_bin);
unknown's avatar
unknown committed
1606 1607 1608 1609
}

String *Item_func_encode::val_str(String *str)
{
1610
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1611 1612 1613 1614 1615 1616 1617 1618 1619 1620
  String *res;
  if (!(res=args[0]->val_str(str)))
  {
    null_value=1; /* purecov: inspected */
    return 0; /* purecov: inspected */
  }
  null_value=0;
  res=copy_if_not_alloced(str,res,res->length());
  sql_crypt.init();
  sql_crypt.encode((char*) res->ptr(),res->length());
1621
  res->set_charset(&my_charset_bin);
unknown's avatar
unknown committed
1622 1623 1624 1625 1626
  return res;
}

String *Item_func_decode::val_str(String *str)
{
1627
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
  String *res;
  if (!(res=args[0]->val_str(str)))
  {
    null_value=1; /* purecov: inspected */
    return 0; /* purecov: inspected */
  }
  null_value=0;
  res=copy_if_not_alloced(str,res,res->length());
  sql_crypt.init();
  sql_crypt.decode((char*) res->ptr(),res->length());
  return res;
}


1642 1643 1644 1645 1646 1647
Item *Item_func_sysconst::safe_charset_converter(CHARSET_INFO *tocs)
{
  Item_string *conv;
  uint conv_errors;
  String tmp, cstr, *ostr= val_str(&tmp);
  cstr.copy(ostr->ptr(), ostr->length(), ostr->charset(), tocs, &conv_errors);
1648 1649 1650 1651 1652
  if (conv_errors ||
      !(conv= new Item_static_string_func(fully_qualified_func_name(),
                                          cstr.ptr(), cstr.length(),
                                          cstr.charset(),
                                          collation.derivation)))
1653 1654 1655 1656
  {
    return NULL;
  }
  conv->str_value.copy();
unknown's avatar
unknown committed
1657
  conv->str_value.mark_as_const();
1658 1659 1660 1661
  return conv;
}


unknown's avatar
unknown committed
1662 1663
String *Item_func_database::val_str(String *str)
{
1664
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1665
  THD *thd= current_thd;
unknown's avatar
unknown committed
1666
  if (thd->db == NULL)
1667
  {
1668 1669
    null_value= 1;
    return 0;
1670
  }
unknown's avatar
unknown committed
1671
  else
unknown's avatar
unknown committed
1672
    str->copy(thd->db, thd->db_length, system_charset_info);
unknown's avatar
unknown committed
1673 1674 1675
  return str;
}

unknown's avatar
unknown committed
1676

1677 1678 1679 1680
/*
  TODO: make USER() replicate properly (currently it is replicated to "")
*/
bool Item_func_user::init(const char *user, const char *host)
unknown's avatar
unknown committed
1681
{
1682
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1683

1684 1685
  // For system threads (e.g. replication SQL thread) user may be empty
  if (user)
1686
  {
1687 1688
    CHARSET_INFO *cs= str_value.charset();
    uint res_length= (strlen(user)+strlen(host)+2) * cs->mbmaxlen;
1689

1690 1691 1692 1693 1694
    if (str_value.alloc(res_length))
    {
      null_value=1;
      return TRUE;
    }
1695

1696 1697 1698 1699
    res_length=cs->cset->snprintf(cs, (char*)str_value.ptr(), res_length,
                                  "%s@%s", user, host);
    str_value.length(res_length);
    str_value.mark_as_const();
1700
  }
1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
  return FALSE;
}


bool Item_func_user::fix_fields(THD *thd, Item **ref)
{
  return (Item_func_sysconst::fix_fields(thd, ref) ||
          init(thd->main_security_ctx.user,
               thd->main_security_ctx.host_or_ip));
}


bool Item_func_current_user::fix_fields(THD *thd, Item **ref)
{
  if (Item_func_sysconst::fix_fields(thd, ref))
    return TRUE;

  Security_context *ctx= (context->security_ctx
                          ? context->security_ctx : thd->security_ctx);
  return init(ctx->priv_user, ctx->priv_host);
unknown's avatar
unknown committed
1721 1722
}

1723

unknown's avatar
unknown committed
1724 1725
void Item_func_soundex::fix_length_and_dec()
{
1726
  collation.set(args[0]->collation);
unknown's avatar
unknown committed
1727 1728 1729 1730 1731
  max_length=args[0]->max_length;
  set_if_bigger(max_length,4);
}


1732 1733 1734 1735 1736
/*
  If alpha, map input letter to soundex code.
  If not alpha and remove_garbage is set then skip to next char
  else return 0
*/
unknown's avatar
unknown committed
1737

1738
static char soundex_toupper(char ch)
unknown's avatar
unknown committed
1739
{
1740 1741 1742 1743 1744 1745
  return (ch >= 'a' && ch <= 'z') ? ch - 'a' + 'A' : ch;
}

static char get_scode(char *ptr)
{
  uchar ch= soundex_toupper(*ptr);
unknown's avatar
unknown committed
1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756
  if (ch < 'A' || ch > 'Z')
  {
					// Thread extended alfa (country spec)
    return '0';				// as vokal
  }
  return(soundex_map[ch-'A']);
}


String *Item_func_soundex::val_str(String *str)
{
1757
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1758 1759
  String *res  =args[0]->val_str(str);
  char last_ch,ch;
1760
  CHARSET_INFO *cs= collation.collation;
unknown's avatar
unknown committed
1761

unknown's avatar
unknown committed
1762 1763 1764
  if ((null_value=args[0]->null_value))
    return 0; /* purecov: inspected */

unknown's avatar
unknown committed
1765
  if (tmp_value.alloc(max(res->length(),4)))
unknown's avatar
unknown committed
1766
    return str; /* purecov: inspected */
unknown's avatar
unknown committed
1767
  char *to= (char *) tmp_value.ptr();
unknown's avatar
unknown committed
1768
  char *from= (char *) res->ptr(), *end=from+res->length();
unknown's avatar
unknown committed
1769 1770
  tmp_value.set_charset(cs);
  
unknown's avatar
unknown committed
1771
  while (from != end && !my_isalpha(cs,*from)) // Skip pre-space
unknown's avatar
unknown committed
1772 1773
    from++; /* purecov: inspected */
  if (from == end)
unknown's avatar
SCRUM  
unknown committed
1774
    return &my_empty_string;		// No alpha characters.
1775 1776
  *to++ = soundex_toupper(*from);	// Copy first letter
  last_ch = get_scode(from);		// code of the first letter
unknown's avatar
unknown committed
1777 1778 1779 1780 1781 1782
					// for the first 'double-letter check.
					// Loop on input letters until
					// end of input (null) or output
					// letter code count = 3
  for (from++ ; from < end ; from++)
  {
unknown's avatar
unknown committed
1783
    if (!my_isalpha(cs,*from))
unknown's avatar
unknown committed
1784
      continue;
1785
    ch=get_scode(from);
unknown's avatar
unknown committed
1786 1787 1788 1789 1790 1791
    if ((ch != '0') && (ch != last_ch)) // if not skipped or double
    {
       *to++ = ch;			// letter, copy to output
       last_ch = ch;			// save code of last input letter
    }					// for next double-letter check
  }
unknown's avatar
unknown committed
1792
  for (end=(char*) tmp_value.ptr()+4 ; to < end ; to++)
unknown's avatar
unknown committed
1793 1794
    *to = '0';
  *to=0;				// end string
unknown's avatar
unknown committed
1795 1796
  tmp_value.length((uint) (to-tmp_value.ptr()));
  return &tmp_value;
unknown's avatar
unknown committed
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810
}


/*
** Change a number to format '3,333,333,333.000'
** This should be 'internationalized' sometimes.
*/

Item_func_format::Item_func_format(Item *org,int dec) :Item_str_func(org)
{
  decimals=(uint) set_zone(dec,0,30);
}


unknown's avatar
unknown committed
1811 1812 1813 1814 1815
/*
  TODO: This needs to be fixed for multi-byte character set where numbers
  are stored in more than one byte
*/

unknown's avatar
unknown committed
1816 1817
String *Item_func_format::val_str(String *str)
{
1818
  uint32 length, str_length ,dec;
1819
  int diff;
1820
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1821
  dec= decimals ? decimals+1 : 0;
1822

1823 1824 1825 1826 1827
  if (args[0]->result_type() == DECIMAL_RESULT ||
      args[0]->result_type() == INT_RESULT)
  {
    my_decimal dec_val, rnd_dec, *res;
    res= args[0]->val_decimal(&dec_val);
1828 1829
    if ((null_value=args[0]->null_value))
      return 0; /* purecov: inspected */
1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849
    my_decimal_round(E_DEC_FATAL_ERROR, res, decimals, false, &rnd_dec);
    my_decimal2string(E_DEC_FATAL_ERROR, &rnd_dec, 0, 0, 0, str);
    str_length= str->length();
    if (rnd_dec.sign())
      str_length--;
  }
  else
  {
    double nr= args[0]->val_real();
    if ((null_value=args[0]->null_value))
      return 0; /* purecov: inspected */
    nr= my_double_round(nr, decimals, FALSE);
    /* Here default_charset() is right as this is not an automatic conversion */
    str->set(nr,decimals, default_charset());
    if (isnan(nr))
      return str;
    str_length=str->length();
    if (nr < 0)
      str_length--;				// Don't count sign
  }
1850 1851
  /* We need this test to handle 'nan' values */
  if (str_length >= dec+4)
unknown's avatar
unknown committed
1852 1853
  {
    char *tmp,*pos;
unknown's avatar
unknown committed
1854
    length= str->length()+(diff=((int)(str_length- dec-1))/3);
1855
    str= copy_if_not_alloced(&tmp_str,str,length);
unknown's avatar
unknown committed
1856
    str->length(length);
1857
    tmp= (char*) str->ptr()+length - dec-1;
unknown's avatar
unknown committed
1858
    for (pos= (char*) str->ptr()+length-1; pos != tmp; pos--)
1859
      pos[0]= pos[-diff];
unknown's avatar
unknown committed
1860 1861
    while (diff)
    {
1862 1863 1864 1865 1866 1867
      *pos= *(pos - diff);
      pos--;
      *pos= *(pos - diff);
      pos--;
      *pos= *(pos - diff);
      pos--;
unknown's avatar
unknown committed
1868 1869 1870 1871 1872 1873 1874 1875 1876
      pos[0]=',';
      pos--;
      diff--;
    }
  }
  return str;
}


1877 1878
void Item_func_format::print(String *str)
{
1879
  str->append(STRING_WITH_LEN("format("));
1880 1881
  args[0]->print(str);
  str->append(',');  
unknown's avatar
unknown committed
1882
  // my_charset_bin is good enough for numbers
1883
  char buffer[20];
unknown's avatar
unknown committed
1884 1885
  String st(buffer, sizeof(buffer), &my_charset_bin);
  st.set((ulonglong)decimals, &my_charset_bin);
1886 1887 1888 1889
  str->append(st);
  str->append(')');
}

unknown's avatar
unknown committed
1890 1891 1892 1893
void Item_func_elt::fix_length_and_dec()
{
  max_length=0;
  decimals=0;
1894

1895
  if (agg_arg_charsets(collation, args+1, arg_count-1, MY_COLL_ALLOW_CONV, 1))
unknown's avatar
unknown committed
1896 1897
    return;

1898
  for (uint i= 1 ; i < arg_count ; i++)
unknown's avatar
unknown committed
1899 1900 1901 1902 1903 1904 1905 1906
  {
    set_if_bigger(max_length,args[i]->max_length);
    set_if_bigger(decimals,args[i]->decimals);
  }
  maybe_null=1;					// NULL if wrong first arg
}


1907
double Item_func_elt::val_real()
unknown's avatar
unknown committed
1908
{
1909
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1910
  uint tmp;
1911
  null_value=1;
1912
  if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
unknown's avatar
unknown committed
1913
    return 0.0;
1914
  double result= args[tmp]->val_real();
unknown's avatar
unknown committed
1915
  null_value= args[tmp]->null_value;
1916
  return result;
unknown's avatar
unknown committed
1917 1918
}

unknown's avatar
unknown committed
1919

unknown's avatar
unknown committed
1920 1921
longlong Item_func_elt::val_int()
{
1922
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1923
  uint tmp;
1924
  null_value=1;
1925
  if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
unknown's avatar
unknown committed
1926
    return 0;
unknown's avatar
unknown committed
1927 1928 1929

  longlong result= args[tmp]->val_int();
  null_value= args[tmp]->null_value;
1930
  return result;
unknown's avatar
unknown committed
1931 1932
}

unknown's avatar
unknown committed
1933

unknown's avatar
unknown committed
1934 1935
String *Item_func_elt::val_str(String *str)
{
1936
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1937
  uint tmp;
1938
  null_value=1;
1939
  if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
unknown's avatar
unknown committed
1940
    return NULL;
1941

unknown's avatar
unknown committed
1942 1943 1944 1945
  String *result= args[tmp]->val_str(str);
  if (result)
    result->set_charset(collation.collation);
  null_value= args[tmp]->null_value;
1946
  return result;
unknown's avatar
unknown committed
1947 1948 1949
}


1950
void Item_func_make_set::split_sum_func(THD *thd, Item **ref_pointer_array,
1951
					List<Item> &fields)
1952
{
unknown's avatar
unknown committed
1953
  item->split_sum_func2(thd, ref_pointer_array, fields, &item, TRUE);
1954
  Item_str_func::split_sum_func(thd, ref_pointer_array, fields);
1955 1956 1957
}


unknown's avatar
unknown committed
1958 1959 1960
void Item_func_make_set::fix_length_and_dec()
{
  max_length=arg_count-1;
unknown's avatar
unknown committed
1961

1962
  if (agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV, 1))
unknown's avatar
unknown committed
1963 1964
    return;
  
1965
  for (uint i=0 ; i < arg_count ; i++)
unknown's avatar
unknown committed
1966
    max_length+=args[i]->max_length;
unknown's avatar
unknown committed
1967

1968 1969 1970
  used_tables_cache|=	  item->used_tables();
  not_null_tables_cache&= item->not_null_tables();
  const_item_cache&=	  item->const_item();
1971
  with_sum_func= with_sum_func || item->with_sum_func;
unknown's avatar
unknown committed
1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985
}


void Item_func_make_set::update_used_tables()
{
  Item_func::update_used_tables();
  item->update_used_tables();
  used_tables_cache|=item->used_tables();
  const_item_cache&=item->const_item();
}


String *Item_func_make_set::val_str(String *str)
{
1986
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
1987 1988 1989
  ulonglong bits;
  bool first_found=0;
  Item **ptr=args;
unknown's avatar
SCRUM  
unknown committed
1990
  String *result=&my_empty_string;
unknown's avatar
unknown committed
1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003

  bits=item->val_int();
  if ((null_value=item->null_value))
    return NULL;

  if (arg_count < 64)
    bits &= ((ulonglong) 1 << arg_count)-1;

  for (; bits; bits >>= 1, ptr++)
  {
    if (bits & 1)
    {
      String *res= (*ptr)->val_str(str);
unknown's avatar
unknown committed
2004
      if (res)					// Skip nulls
unknown's avatar
unknown committed
2005 2006 2007 2008 2009 2010 2011 2012 2013
      {
	if (!first_found)
	{					// First argument
	  first_found=1;
	  if (res != str)
	    result=res;				// Use original string
	  else
	  {
	    if (tmp_str.copy(*res))		// Don't use 'str'
unknown's avatar
SCRUM  
unknown committed
2014
	      return &my_empty_string;
unknown's avatar
unknown committed
2015 2016 2017 2018 2019 2020 2021 2022 2023
	    result= &tmp_str;
	  }
	}
	else
	{
	  if (result != &tmp_str)
	  {					// Copy data to tmp_str
	    if (tmp_str.alloc(result->length()+res->length()+1) ||
		tmp_str.copy(*result))
unknown's avatar
SCRUM  
unknown committed
2024
	      return &my_empty_string;
unknown's avatar
unknown committed
2025 2026 2027
	    result= &tmp_str;
	  }
	  if (tmp_str.append(',') || tmp_str.append(*res))
unknown's avatar
SCRUM  
unknown committed
2028
	    return &my_empty_string;
unknown's avatar
unknown committed
2029 2030 2031 2032 2033 2034 2035 2036
	}
      }
    }
  }
  return result;
}


2037 2038
void Item_func_make_set::print(String *str)
{
2039
  str->append(STRING_WITH_LEN("make_set("));
2040 2041 2042 2043
  item->print(str);
  if (arg_count)
  {
    str->append(',');
unknown's avatar
unknown committed
2044
    print_args(str, 0);
2045 2046 2047 2048 2049
  }
  str->append(')');
}


unknown's avatar
unknown committed
2050 2051
String *Item_func_char::val_str(String *str)
{
2052
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2053 2054 2055 2056 2057
  str->length(0);
  for (uint i=0 ; i < arg_count ; i++)
  {
    int32 num=(int32) args[i]->val_int();
    if (!args[i]->null_value)
2058
    {
unknown's avatar
unknown committed
2059 2060 2061 2062 2063 2064 2065 2066
      if (num&0xFF000000L) {
        str->append((char)(num>>24));
        goto b2;
      } else if (num&0xFF0000L) {
    b2:        str->append((char)(num>>16));
        goto b1;
      } else if (num&0xFF00L) {
    b1:        str->append((char)(num>>8));
unknown's avatar
unknown committed
2067
      }
unknown's avatar
unknown committed
2068
      str->append((char) num);
2069
    }
unknown's avatar
unknown committed
2070
  }
2071
  str->set_charset(collation.collation);
unknown's avatar
unknown committed
2072
  str->realloc(str->length());			// Add end 0 (for Purify)
2073
  return check_well_formed_result(str);
unknown's avatar
unknown committed
2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087
}


inline String* alloc_buffer(String *res,String *str,String *tmp_value,
			    ulong length)
{
  if (res->alloced_length() < length)
  {
    if (str->alloced_length() >= length)
    {
      (void) str->copy(*res);
      str->length(length);
      return str;
    }
2088 2089 2090 2091 2092
    if (tmp_value->alloc(length))
      return 0;
    (void) tmp_value->copy(*res);
    tmp_value->length(length);
    return tmp_value;
unknown's avatar
unknown committed
2093 2094 2095 2096 2097 2098 2099 2100
  }
  res->length(length);
  return res;
}


void Item_func_repeat::fix_length_and_dec()
{
2101
  collation.set(args[0]->collation);
unknown's avatar
unknown committed
2102 2103
  if (args[1]->const_item())
  {
2104 2105 2106
    ulonglong max_result_length= ((ulonglong) args[0]->max_length *
                                  args[1]->val_int());
    if (max_result_length >= MAX_BLOB_WIDTH)
unknown's avatar
unknown committed
2107
    {
2108 2109
      max_result_length= MAX_BLOB_WIDTH;
      maybe_null= 1;
unknown's avatar
unknown committed
2110
    }
2111
    max_length= (ulong) max_result_length;
unknown's avatar
unknown committed
2112 2113 2114
  }
  else
  {
2115 2116
    max_length= MAX_BLOB_WIDTH;
    maybe_null= 1;
unknown's avatar
unknown committed
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
  }
}

/*
** Item_func_repeat::str is carefully written to avoid reallocs
** as much as possible at the cost of a local buffer
*/

String *Item_func_repeat::val_str(String *str)
{
2127
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2128 2129 2130 2131 2132 2133 2134 2135 2136
  uint length,tot_length;
  char *to;
  long count= (long) args[1]->val_int();
  String *res =args[0]->val_str(str);

  if (args[0]->null_value || args[1]->null_value)
    goto err;				// string and/or delim are null
  null_value=0;
  if (count <= 0)			// For nicer SQL code
unknown's avatar
SCRUM  
unknown committed
2137
    return &my_empty_string;
unknown's avatar
unknown committed
2138 2139 2140
  if (count == 1)			// To avoid reallocs
    return res;
  length=res->length();
unknown's avatar
unknown committed
2141 2142
  // Safe length check
  if (length > current_thd->variables.max_allowed_packet/count)
2143 2144 2145
  {
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			ER_WARN_ALLOWED_PACKET_OVERFLOWED,
2146 2147
			ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
			func_name(), current_thd->variables.max_allowed_packet);
2148 2149
    goto err;
  }
unknown's avatar
unknown committed
2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169
  tot_length= length*(uint) count;
  if (!(res= alloc_buffer(res,str,&tmp_value,tot_length)))
    goto err;

  to=(char*) res->ptr()+length;
  while (--count)
  {
    memcpy(to,res->ptr(),length);
    to+=length;
  }
  return (res);

err:
  null_value=1;
  return 0;
}


void Item_func_rpad::fix_length_and_dec()
{
2170 2171
  // Handle character set for args[0] and args[2].
  if (agg_arg_charsets(collation, &args[0], 2, MY_COLL_ALLOW_CONV, 2))
2172
    return;
unknown's avatar
unknown committed
2173 2174
  if (args[1]->const_item())
  {
2175 2176 2177
    ulonglong length= ((ulonglong) args[1]->val_int() *
                       collation.collation->mbmaxlen);
    if (length >= MAX_BLOB_WIDTH)
unknown's avatar
unknown committed
2178
    {
2179 2180
      length= MAX_BLOB_WIDTH;
      maybe_null= 1;
unknown's avatar
unknown committed
2181
    }
2182
    max_length= (ulong) length;
unknown's avatar
unknown committed
2183 2184 2185
  }
  else
  {
2186 2187
    max_length= MAX_BLOB_WIDTH;
    maybe_null= 1;
unknown's avatar
unknown committed
2188 2189 2190 2191 2192 2193
  }
}


String *Item_func_rpad::val_str(String *str)
{
2194
  DBUG_ASSERT(fixed == 1);
2195
  uint32 res_byte_length,res_char_length,pad_char_length,pad_byte_length;
unknown's avatar
unknown committed
2196 2197 2198
  char *to;
  const char *ptr_pad;
  int32 count= (int32) args[1]->val_int();
2199
  int32 byte_count= count * collation.collation->mbmaxlen;
unknown's avatar
unknown committed
2200
  String *res =args[0]->val_str(str);
2201
  String *rpad = args[2]->val_str(&rpad_str);
unknown's avatar
unknown committed
2202

unknown's avatar
unknown committed
2203
  if (!res || args[1]->null_value || !rpad || count < 0)
unknown's avatar
unknown committed
2204 2205
    goto err;
  null_value=0;
2206
  if (count <= (int32) (res_char_length=res->numchars()))
2207
  {						// String to pad is big enough
2208
    res->length(res->charpos(count));		// Shorten result if longer
2209 2210
    return (res);
  }
2211
  pad_char_length= rpad->numchars();
2212 2213 2214 2215
  if ((ulong) byte_count > current_thd->variables.max_allowed_packet)
  {
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			ER_WARN_ALLOWED_PACKET_OVERFLOWED,
2216 2217
			ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
			func_name(), current_thd->variables.max_allowed_packet);
2218 2219
    goto err;
  }
unknown's avatar
unknown committed
2220
  if (args[2]->null_value || !pad_char_length)
unknown's avatar
unknown committed
2221
    goto err;
2222 2223
  res_byte_length= res->length();	/* Must be done before alloc_buffer */
  if (!(res= alloc_buffer(res,str,&tmp_value,byte_count)))
unknown's avatar
unknown committed
2224 2225
    goto err;

2226
  to= (char*) res->ptr()+res_byte_length;
unknown's avatar
unknown committed
2227
  ptr_pad=rpad->ptr();
2228 2229 2230
  pad_byte_length= rpad->length();
  count-= res_char_length;
  for ( ; (uint32) count > pad_char_length; count-= pad_char_length)
unknown's avatar
unknown committed
2231
  {
2232 2233
    memcpy(to,ptr_pad,pad_byte_length);
    to+= pad_byte_length;
unknown's avatar
unknown committed
2234
  }
2235 2236 2237 2238 2239 2240 2241
  if (count)
  {
    pad_byte_length= rpad->charpos(count);
    memcpy(to,ptr_pad,(size_t) pad_byte_length);
    to+= pad_byte_length;
  }
  res->length(to- (char*) res->ptr());
unknown's avatar
unknown committed
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251
  return (res);

 err:
  null_value=1;
  return 0;
}


void Item_func_lpad::fix_length_and_dec()
{
2252 2253
  // Handle character set for args[0] and args[2].
  if (agg_arg_charsets(collation, &args[0], 2, MY_COLL_ALLOW_CONV, 2))
2254
    return;
2255
  
unknown's avatar
unknown committed
2256 2257
  if (args[1]->const_item())
  {
2258 2259 2260
    ulonglong length= ((ulonglong) args[1]->val_int() *
                       collation.collation->mbmaxlen);
    if (length >= MAX_BLOB_WIDTH)
unknown's avatar
unknown committed
2261
    {
2262 2263
      length= MAX_BLOB_WIDTH;
      maybe_null= 1;
unknown's avatar
unknown committed
2264
    }
2265
    max_length= (ulong) length;
unknown's avatar
unknown committed
2266 2267 2268
  }
  else
  {
2269 2270
    max_length= MAX_BLOB_WIDTH;
    maybe_null= 1;
unknown's avatar
unknown committed
2271 2272 2273 2274 2275 2276
  }
}


String *Item_func_lpad::val_str(String *str)
{
2277
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2278
  uint32 res_char_length,pad_char_length;
2279
  ulong count= (long) args[1]->val_int(), byte_count;
2280 2281
  String *res= args[0]->val_str(&tmp_value);
  String *pad= args[2]->val_str(&lpad_str);
unknown's avatar
unknown committed
2282

2283
  if (!res || args[1]->null_value || !pad)
unknown's avatar
unknown committed
2284
    goto err;
2285

unknown's avatar
unknown committed
2286
  null_value=0;
2287 2288 2289 2290 2291 2292
  res_char_length= res->numchars();

  if (count <= res_char_length)
  {
    res->length(res->charpos(count));
    return res;
2293
  }
2294 2295 2296 2297
  
  pad_char_length= pad->numchars();
  byte_count= count * collation.collation->mbmaxlen;
  
2298 2299 2300 2301
  if (byte_count > current_thd->variables.max_allowed_packet)
  {
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			ER_WARN_ALLOWED_PACKET_OVERFLOWED,
2302 2303
			ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
			func_name(), current_thd->variables.max_allowed_packet);
2304 2305 2306 2307
    goto err;
  }

  if (args[2]->null_value || !pad_char_length || str->alloc(byte_count))
unknown's avatar
unknown committed
2308
    goto err;
2309 2310 2311 2312 2313
  
  str->length(0);
  str->set_charset(collation.collation);
  count-= res_char_length;
  while (count >= pad_char_length)
unknown's avatar
unknown committed
2314
  {
2315 2316
    str->append(*pad);
    count-= pad_char_length;
unknown's avatar
unknown committed
2317
  }
2318
  if (count > 0)
2319 2320
    str->append(pad->ptr(), pad->charpos(count), collation.collation);

2321 2322 2323
  str->append(*res);
  null_value= 0;
  return str;
unknown's avatar
unknown committed
2324

2325 2326
err:
  null_value= 1;
unknown's avatar
unknown committed
2327 2328 2329 2330 2331 2332
  return 0;
}


String *Item_func_conv::val_str(String *str)
{
2333
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2334 2335 2336 2337 2338
  String *res= args[0]->val_str(str);
  char *endptr,ans[65],*ptr;
  longlong dec;
  int from_base= (int) args[1]->val_int();
  int to_base= (int) args[2]->val_int();
2339
  int err;
unknown's avatar
unknown committed
2340 2341 2342 2343 2344 2345 2346 2347 2348

  if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
      abs(to_base) > 36 || abs(to_base) < 2 ||
      abs(from_base) > 36 || abs(from_base) < 2 || !(res->length()))
  {
    null_value=1;
    return 0;
  }
  null_value=0;
unknown's avatar
unknown committed
2349
  unsigned_flag= !(from_base < 0);
unknown's avatar
unknown committed
2350
  if (from_base < 0)
2351
    dec= my_strntoll(res->charset(),res->ptr(),res->length(),-from_base,&endptr,&err);
unknown's avatar
unknown committed
2352
  else
2353
    dec= (longlong) my_strntoull(res->charset(),res->ptr(),res->length(),from_base,&endptr,&err);
unknown's avatar
unknown committed
2354
  ptr= longlong2str(dec,ans,to_base);
2355
  if (str->copy(ans,(uint32) (ptr-ans), default_charset()))
unknown's avatar
SCRUM  
unknown committed
2356
    return &my_empty_string;
unknown's avatar
unknown committed
2357 2358 2359
  return str;
}

unknown's avatar
unknown committed
2360

2361 2362
String *Item_func_conv_charset::val_str(String *str)
{
2363
  DBUG_ASSERT(fixed == 1);
2364 2365
  if (use_cached_value)
    return null_value ? 0 : &str_value;
2366
  String *arg= args[0]->val_str(str);
2367
  uint dummy_errors;
2368 2369 2370 2371 2372
  if (!arg)
  {
    null_value=1;
    return 0;
  }
unknown's avatar
unknown committed
2373
  null_value= str_value.copy(arg->ptr(),arg->length(),arg->charset(),
2374
                             conv_charset, &dummy_errors);
2375
  return null_value ? 0 : check_well_formed_result(&str_value);
2376 2377 2378 2379
}

void Item_func_conv_charset::fix_length_and_dec()
{
2380
  collation.set(conv_charset, DERIVATION_IMPLICIT);
2381
  max_length = args[0]->max_length*conv_charset->mbmaxlen;
2382 2383
}

2384 2385
void Item_func_conv_charset::print(String *str)
{
2386
  str->append(STRING_WITH_LEN("convert("));
2387
  args[0]->print(str);
2388
  str->append(STRING_WITH_LEN(" using "));
2389 2390 2391
  str->append(conv_charset->csname);
  str->append(')');
}
unknown's avatar
unknown committed
2392 2393 2394

String *Item_func_set_collation::val_str(String *str)
{
2395
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2396
  str=args[0]->val_str(str);
unknown's avatar
unknown committed
2397 2398
  if ((null_value=args[0]->null_value))
    return 0;
2399
  str->set_charset(collation.collation);
unknown's avatar
unknown committed
2400 2401 2402
  return str;
}

2403
void Item_func_set_collation::fix_length_and_dec()
unknown's avatar
unknown committed
2404
{
unknown's avatar
unknown committed
2405 2406
  CHARSET_INFO *set_collation;
  const char *colname;
2407
  String tmp, *str= args[1]->val_str(&tmp);
unknown's avatar
unknown committed
2408
  colname= str->c_ptr();
unknown's avatar
unknown committed
2409
  if (colname == binary_keyword)
2410
    set_collation= get_charset_by_csname(args[0]->collation.collation->csname,
unknown's avatar
unknown committed
2411 2412
					 MY_CS_BINSORT,MYF(0));
  else
2413 2414 2415 2416 2417 2418 2419
  {
    if (!(set_collation= get_charset_by_name(colname,MYF(0))))
    {
      my_error(ER_UNKNOWN_COLLATION, MYF(0), colname);
      return;
    }
  }
unknown's avatar
unknown committed
2420

2421 2422
  if (!set_collation || 
      !my_charset_same(args[0]->collation.collation,set_collation))
2423
  {
2424 2425
    my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0),
             colname, args[0]->collation.collation->csname);
2426
    return;
2427
  }
2428
  collation.set(set_collation, DERIVATION_EXPLICIT);
2429
  max_length= args[0]->max_length;
unknown's avatar
unknown committed
2430 2431
}

2432

2433 2434 2435 2436 2437 2438 2439 2440 2441
bool Item_func_set_collation::eq(const Item *item, bool binary_cmp) const
{
  /* Assume we don't have rtti */
  if (this == item)
    return 1;
  if (item->type() != FUNC_ITEM)
    return 0;
  Item_func *item_func=(Item_func*) item;
  if (arg_count != item_func->arg_count ||
2442
      functype() != item_func->functype())
2443 2444
    return 0;
  Item_func_set_collation *item_func_sc=(Item_func_set_collation*) item;
2445
  if (collation.collation != item_func_sc->collation.collation)
2446 2447 2448 2449 2450 2451 2452
    return 0;
  for (uint i=0; i < arg_count ; i++)
    if (!args[i]->eq(item_func_sc->args[i], binary_cmp))
      return 0;
  return 1;
}

2453 2454 2455 2456 2457

void Item_func_set_collation::print(String *str)
{
  str->append('(');
  args[0]->print(str);
2458
  str->append(STRING_WITH_LEN(" collate "));
2459 2460 2461 2462 2463 2464
  DBUG_ASSERT(args[1]->basic_const_item() &&
              args[1]->type() == Item::STRING_ITEM);
  args[1]->str_value.print(str);
  str->append(')');
}

2465 2466
String *Item_func_charset::val_str(String *str)
{
2467
  DBUG_ASSERT(fixed == 1);
2468
  uint dummy_errors;
2469

2470 2471 2472
  CHARSET_INFO *cs= args[0]->collation.collation; 
  null_value= 0;
  str->copy(cs->csname, strlen(cs->csname),
2473
	    &my_charset_latin1, collation.collation, &dummy_errors);
unknown's avatar
unknown committed
2474 2475 2476 2477 2478
  return str;
}

String *Item_func_collation::val_str(String *str)
{
2479
  DBUG_ASSERT(fixed == 1);
2480
  uint dummy_errors;
2481
  CHARSET_INFO *cs= args[0]->collation.collation; 
unknown's avatar
unknown committed
2482

2483 2484
  null_value= 0;
  str->copy(cs->name, strlen(cs->name),
2485
	    &my_charset_latin1, collation.collation, &dummy_errors);
2486 2487
  return str;
}
unknown's avatar
unknown committed
2488 2489


unknown's avatar
unknown committed
2490 2491
String *Item_func_hex::val_str(String *str)
{
unknown's avatar
unknown committed
2492
  String *res;
2493
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2494 2495
  if (args[0]->result_type() != STRING_RESULT)
  {
2496
    ulonglong dec;
unknown's avatar
unknown committed
2497
    char ans[65],*ptr;
2498
    /* Return hex of unsigned longlong value */
unknown's avatar
unknown committed
2499 2500
    if (args[0]->result_type() == REAL_RESULT ||
        args[0]->result_type() == DECIMAL_RESULT)
2501
    {
unknown's avatar
unknown committed
2502
      double val= args[0]->val_real();
2503 2504 2505 2506 2507 2508 2509 2510 2511
      if ((val <= (double) LONGLONG_MIN) || 
          (val >= (double) (ulonglong) ULONGLONG_MAX))
        dec=  ~(longlong) 0;
      else
        dec= (ulonglong) (val + (val > 0 ? 0.5 : -0.5));
    }
    else
      dec= (ulonglong) args[0]->val_int();

unknown's avatar
unknown committed
2512 2513 2514
    if ((null_value= args[0]->null_value))
      return 0;
    ptr= longlong2str(dec,ans,16);
2515
    if (str->copy(ans,(uint32) (ptr-ans),default_charset()))
unknown's avatar
SCRUM  
unknown committed
2516
      return &my_empty_string;			// End of memory
unknown's avatar
unknown committed
2517 2518 2519 2520
    return str;
  }

  /* Convert given string to a hex string, character by character */
unknown's avatar
unknown committed
2521 2522
  res= args[0]->val_str(str);
  if (!res || tmp_value.alloc(res->length()*2+1))
unknown's avatar
unknown committed
2523 2524 2525 2526 2527 2528
  {
    null_value=1;
    return 0;
  }
  null_value=0;
  tmp_value.length(res->length()*2);
unknown's avatar
unknown committed
2529 2530

  octet2hex((char*) tmp_value.ptr(), res->ptr(), res->length());
unknown's avatar
unknown committed
2531 2532 2533
  return &tmp_value;
}

unknown's avatar
unknown committed
2534 2535
  /* Convert given hex string to a binary string */

unknown's avatar
unknown committed
2536 2537
String *Item_func_unhex::val_str(String *str)
{
unknown's avatar
unknown committed
2538 2539 2540 2541
  const char *from, *end;
  char *to;
  String *res;
  uint length;
2542
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2543

unknown's avatar
unknown committed
2544 2545
  res= args[0]->val_str(str);
  if (!res || tmp_value.alloc(length= (1+res->length())/2))
unknown's avatar
unknown committed
2546 2547 2548 2549
  {
    null_value=1;
    return 0;
  }
unknown's avatar
unknown committed
2550

unknown's avatar
unknown committed
2551 2552 2553
  from= res->ptr();
  null_value= 0;
  tmp_value.length(length);
unknown's avatar
unknown committed
2554 2555 2556
  to= (char*) tmp_value.ptr();
  if (res->length() % 2)
  {
unknown's avatar
unknown committed
2557 2558 2559
    int hex_char;
    *to++= hex_char= hexchar_to_int(*from++);
    if ((null_value= (hex_char == -1)))
unknown's avatar
unknown committed
2560 2561 2562 2563
      return 0;
  }
  for (end=res->ptr()+res->length(); from < end ; from+=2, to++)
  {
unknown's avatar
unknown committed
2564 2565 2566
    int hex_char;
    *to= (hex_char= hexchar_to_int(from[0])) << 4;
    if ((null_value= (hex_char == -1)))
unknown's avatar
unknown committed
2567
      return 0;
unknown's avatar
unknown committed
2568 2569
    *to|= hex_char= hexchar_to_int(from[1]);
    if ((null_value= (hex_char == -1)))
unknown's avatar
unknown committed
2570 2571 2572 2573
      return 0;
  }
  return &tmp_value;
}
unknown's avatar
unknown committed
2574

unknown's avatar
unknown committed
2575

2576 2577
void Item_func_binary::print(String *str)
{
2578
  str->append(STRING_WITH_LEN("cast("));
2579
  args[0]->print(str);
2580
  str->append(STRING_WITH_LEN(" as binary)"));
2581 2582 2583
}


unknown's avatar
unknown committed
2584 2585 2586 2587
#include <my_dir.h>				// For my_stat

String *Item_load_file::val_str(String *str)
{
2588
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2589 2590 2591
  String *file_name;
  File file;
  MY_STAT stat_info;
2592
  char path[FN_REFLEN];
unknown's avatar
unknown committed
2593 2594
  DBUG_ENTER("load_file");

2595
  if (!(file_name= args[0]->val_str(str))
unknown's avatar
unknown committed
2596
#ifndef NO_EMBEDDED_ACCESS_CHECKS
2597
      || !(current_thd->security_ctx->master_access & FILE_ACL)
unknown's avatar
unknown committed
2598
#endif
2599
      )
unknown's avatar
unknown committed
2600
    goto err;
2601

unknown's avatar
unknown committed
2602 2603
  (void) fn_format(path, file_name->c_ptr(), mysql_real_data_home, "",
		   MY_RELATIVE_PATH | MY_UNPACK_FILENAME);
2604

2605
  if (!my_stat(path, &stat_info, MYF(0)))
2606 2607
    goto err;

unknown's avatar
unknown committed
2608 2609 2610 2611 2612
  if (!(stat_info.st_mode & S_IROTH))
  {
    /* my_error(ER_TEXTFILE_NOT_READABLE, MYF(0), file_name->c_ptr()); */
    goto err;
  }
unknown's avatar
unknown committed
2613
  if (stat_info.st_size > (long) current_thd->variables.max_allowed_packet)
unknown's avatar
unknown committed
2614
  {
2615 2616
    push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_WARN,
			ER_WARN_ALLOWED_PACKET_OVERFLOWED,
2617 2618
			ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED),
			func_name(), current_thd->variables.max_allowed_packet);
unknown's avatar
unknown committed
2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642
    goto err;
  }
  if (tmp_value.alloc(stat_info.st_size))
    goto err;
  if ((file = my_open(file_name->c_ptr(), O_RDONLY, MYF(0))) < 0)
    goto err;
  if (my_read(file, (byte*) tmp_value.ptr(), stat_info.st_size, MYF(MY_NABP)))
  {
    my_close(file, MYF(0));
    goto err;
  }
  tmp_value.length(stat_info.st_size);
  my_close(file, MYF(0));
  null_value = 0;
  return &tmp_value;

err:
  null_value = 1;
  DBUG_RETURN(0);
}


String* Item_func_export_set::val_str(String* str)
{
2643
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2644
  ulonglong the_set = (ulonglong) args[0]->val_int();
2645
  String yes_buf, *yes;
unknown's avatar
unknown committed
2646
  yes = args[1]->val_str(&yes_buf);
2647
  String no_buf, *no;
unknown's avatar
unknown committed
2648
  no = args[2]->val_str(&no_buf);
2649
  String *sep = NULL, sep_buf ;
unknown's avatar
unknown committed
2650 2651 2652 2653

  uint num_set_values = 64;
  ulonglong mask = 0x1;
  str->length(0);
2654
  str->set_charset(collation.collation);
unknown's avatar
unknown committed
2655 2656 2657 2658 2659 2660 2661

  /* Check if some argument is a NULL value */
  if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
  {
    null_value=1;
    return 0;
  }
2662 2663 2664 2665
  /*
    Arg count can only be 3, 4 or 5 here. This is guaranteed from the
    grammar for EXPORT_SET()
  */
unknown's avatar
unknown committed
2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684
  switch(arg_count) {
  case 5:
    num_set_values = (uint) args[4]->val_int();
    if (num_set_values > 64)
      num_set_values=64;
    if (args[4]->null_value)
    {
      null_value=1;
      return 0;
    }
    /* Fall through */
  case 4:
    if (!(sep = args[3]->val_str(&sep_buf)))	// Only true if NULL
    {
      null_value=1;
      return 0;
    }
    break;
  case 3:
2685
    sep_buf.set(STRING_WITH_LEN(","), default_charset());
unknown's avatar
unknown committed
2686
    sep = &sep_buf;
2687 2688 2689
    break;
  default:
    DBUG_ASSERT(0); // cannot happen
unknown's avatar
unknown committed
2690 2691 2692 2693 2694 2695 2696 2697 2698
  }
  null_value=0;

  for (uint i = 0; i < num_set_values; i++, mask = (mask << 1))
  {
    if (the_set & mask)
      str->append(*yes);
    else
      str->append(*no);
2699
    if (i != num_set_values - 1)
unknown's avatar
unknown committed
2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
      str->append(*sep);
  }
  return str;
}

void Item_func_export_set::fix_length_and_dec()
{
  uint length=max(args[1]->max_length,args[2]->max_length);
  uint sep_length=(arg_count > 3 ? args[3]->max_length : 1);
  max_length=length*64+sep_length*63;
2710

2711 2712
  if (agg_arg_charsets(collation, args+1, min(4,arg_count)-1,
                       MY_COLL_ALLOW_CONV, 1))
unknown's avatar
unknown committed
2713
    return;
unknown's avatar
unknown committed
2714 2715 2716 2717
}

String* Item_func_inet_ntoa::val_str(String* str)
{
2718
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2719 2720 2721
  uchar buf[8], *p;
  ulonglong n = (ulonglong) args[0]->val_int();
  char num[4];
2722

unknown's avatar
unknown committed
2723
  /*
2724
    We do not know if args[0] is NULL until we have called
unknown's avatar
unknown committed
2725
    some val function on it if args[0] is not a constant!
2726 2727

    Also return null if n > 255.255.255.255
unknown's avatar
unknown committed
2728
  */
2729
  if ((null_value= (args[0]->null_value || n > (ulonglong) LL(4294967295))))
unknown's avatar
unknown committed
2730
    return 0;					// Null value
unknown's avatar
unknown committed
2731

unknown's avatar
unknown committed
2732
  str->length(0);
2733
  int4store(buf,n);
unknown's avatar
unknown committed
2734

2735
  /* Now we can assume little endian. */
2736

unknown's avatar
unknown committed
2737
  num[3]='.';
2738
  for (p=buf+4 ; p-- > buf ; )
unknown's avatar
unknown committed
2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755
  {
    uint c = *p;
    uint n1,n2;					// Try to avoid divisions
    n1= c / 100;				// 100 digits
    c-= n1*100;
    n2= c / 10;					// 10 digits
    c-=n2*10;					// last digit
    num[0]=(char) n1+'0';
    num[1]=(char) n2+'0';
    num[2]=(char) c+'0';
    uint length=(n1 ? 4 : n2 ? 3 : 2);		// Remove pre-zero

    (void) str->append(num+4-length,length);
  }
  str->length(str->length()-1);			// Remove last '.';
  return str;
}
unknown's avatar
unknown committed
2756

unknown's avatar
unknown committed
2757

2758
/*
2759 2760 2761 2762 2763 2764
  QUOTE() function returns argument string in single quotes suitable for
  using in a SQL statement.

  DESCRIPTION
    Adds a \ before all characters that needs to be escaped in a SQL string.
    We also escape '^Z' (END-OF-FILE in windows) to avoid probelms when
2765
    running commands from a file in windows.
2766 2767 2768

    This function is very useful when you want to generate SQL statements

2769 2770 2771 2772
  NOTE
    QUOTE(NULL) returns the string 'NULL' (4 letters, without quotes).

  RETURN VALUES
2773
    str		Quoted string
2774
    NULL	Out of memory.
2775
*/
2776 2777 2778

#define get_esc_bit(mask, num) (1 & (*((mask) + ((num) >> 3))) >> ((num) & 7))

unknown's avatar
unknown committed
2779 2780
String *Item_func_quote::val_str(String *str)
{
2781
  DBUG_ASSERT(fixed == 1);
2782 2783 2784
  /*
    Bit mask that has 1 for set for the position of the following characters:
    0, \, ' and ^Z
2785
  */
2786

2787
  static uchar escmask[32]=
2788 2789 2790 2791 2792 2793
  {
    0x01, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  };
unknown's avatar
unknown committed
2794

2795 2796 2797 2798
  char *from, *to, *end, *start;
  String *arg= args[0]->val_str(str);
  uint arg_length, new_length;
  if (!arg)					// Null argument
2799
  {
2800 2801
    /* Return the string 'NULL' */
    str->copy(STRING_WITH_LEN("NULL"), collation.collation);
2802 2803 2804 2805
    null_value= 0;
    return str;
  }

2806 2807
  arg_length= arg->length();
  new_length= arg_length+2; /* for beginning and ending ' signs */
2808

2809
  for (from= (char*) arg->ptr(), end= from + arg_length; from < end; from++)
2810
    new_length+= get_esc_bit(escmask, (uchar) *from);
unknown's avatar
unknown committed
2811

2812
  if (tmp_value.alloc(new_length))
2813
    goto null;
2814 2815

  /*
2816
    We replace characters from the end to the beginning
2817
  */
2818
  to= (char*) tmp_value.ptr() + new_length - 1;
2819
  *to--= '\'';
unknown's avatar
unknown committed
2820
  for (start= (char*) arg->ptr(),end= start + arg_length; end-- != start; to--)
unknown's avatar
unknown committed
2821
  {
2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843
    /*
      We can't use the bitmask here as we want to replace \O and ^Z with 0
      and Z
    */
    switch (*end)  {
    case 0:
      *to--= '0';
      *to=   '\\';
      break;
    case '\032':
      *to--= 'Z';
      *to=   '\\';
      break;
    case '\'':
    case '\\':
      *to--= *end;
      *to=   '\\';
      break;
    default:
      *to= *end;
      break;
    }
unknown's avatar
unknown committed
2844
  }
2845
  *to= '\'';
2846
  tmp_value.length(new_length);
unknown's avatar
unknown committed
2847
  tmp_value.set_charset(collation.collation);
2848
  null_value= 0;
2849
  return &tmp_value;
2850 2851 2852 2853

null:
  null_value= 1;
  return 0;
unknown's avatar
unknown committed
2854
}
unknown's avatar
unknown committed
2855

2856 2857
longlong Item_func_uncompressed_length::val_int()
{
2858
  DBUG_ASSERT(fixed == 1);
2859 2860 2861 2862 2863 2864 2865 2866
  String *res= args[0]->val_str(&value);
  if (!res)
  {
    null_value=1;
    return 0; /* purecov: inspected */
  }
  null_value=0;
  if (res->is_empty()) return 0;
unknown's avatar
unknown committed
2867 2868 2869 2870 2871 2872 2873 2874 2875

  /*
    res->ptr() using is safe because we have tested that string is not empty,
    res->c_ptr() is not used because:
      - we do not need \0 terminated string to get first 4 bytes
      - c_ptr() tests simbol after string end (uninitialiozed memory) which
        confuse valgrind
  */
  return uint4korr(res->ptr()) & 0x3FFFFFFF;
2876 2877 2878 2879
}

longlong Item_func_crc32::val_int()
{
2880
  DBUG_ASSERT(fixed == 1);
2881 2882 2883 2884 2885 2886 2887
  String *res=args[0]->val_str(&value);
  if (!res)
  {
    null_value=1;
    return 0; /* purecov: inspected */
  }
  null_value=0;
2888
  return (longlong) crc32(0L, (uchar*)res->ptr(), res->length());
2889 2890
}

unknown's avatar
unknown committed
2891
#ifdef HAVE_COMPRESS
2892
#include "zlib.h"
unknown's avatar
unknown committed
2893 2894 2895

String *Item_func_compress::val_str(String *str)
{
unknown's avatar
unknown committed
2896 2897 2898 2899 2900
  int err= Z_OK, code;
  ulong new_size;
  String *res;
  Byte *body;
  char *tmp, *last_char;
2901
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2902 2903

  if (!(res= args[0]->val_str(str)))
2904 2905 2906 2907
  {
    null_value= 1;
    return 0;
  }
2908 2909
  if (res->is_empty()) return res;

unknown's avatar
unknown committed
2910
  /*
unknown's avatar
unknown committed
2911
    Citation from zlib.h (comment for compress function):
unknown's avatar
unknown committed
2912 2913

    Compresses the source buffer into the destination buffer.  sourceLen is
unknown's avatar
unknown committed
2914 2915 2916 2917
    the byte length of the source buffer. Upon entry, destLen is the total
    size of the destination buffer, which must be at least 0.1% larger than
    sourceLen plus 12 bytes.
    We assume here that the buffer can't grow more than .25 %.
unknown's avatar
unknown committed
2918
  */
unknown's avatar
unknown committed
2919
  new_size= res->length() + res->length() / 5 + 12;
unknown's avatar
unknown committed
2920

unknown's avatar
unknown committed
2921 2922
  // Check new_size overflow: new_size <= res->length()
  if (((uint32) (new_size+5) <= res->length()) || 
2923 2924 2925 2926 2927
      buffer.realloc((uint32) new_size + 4 + 1))
  {
    null_value= 1;
    return 0;
  }
unknown's avatar
unknown committed
2928

unknown's avatar
unknown committed
2929
  body= ((Byte*)buffer.ptr()) + 4;
2930

unknown's avatar
unknown committed
2931
  // As far as we have checked res->is_empty() we can use ptr()
2932
  if ((err= compress(body, &new_size,
unknown's avatar
unknown committed
2933
		     (const Bytef*)res->ptr(), res->length())) != Z_OK)
unknown's avatar
unknown committed
2934 2935 2936 2937 2938 2939
  {
    code= err==Z_MEM_ERROR ? ER_ZLIB_Z_MEM_ERROR : ER_ZLIB_Z_BUF_ERROR;
    push_warning(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,code,ER(code));
    null_value= 1;
    return 0;
  }
2940

unknown's avatar
unknown committed
2941
  tmp= (char*)buffer.ptr(); // int4store is a macro; avoid side effects
2942
  int4store(tmp, res->length() & 0x3FFFFFFF);
2943

unknown's avatar
unknown committed
2944 2945
  /* This is to ensure that things works for CHAR fields, which trim ' ': */
  last_char= ((char*)body)+new_size-1;
unknown's avatar
unknown committed
2946 2947 2948 2949 2950
  if (*last_char == ' ')
  {
    *++last_char= '.';
    new_size++;
  }
2951

2952
  buffer.length((uint32)new_size + 4);
unknown's avatar
unknown committed
2953 2954 2955
  return &buffer;
}

2956

unknown's avatar
unknown committed
2957 2958
String *Item_func_uncompress::val_str(String *str)
{
2959
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
2960
  String *res= args[0]->val_str(str);
2961 2962
  ulong new_size;
  int err;
unknown's avatar
unknown committed
2963
  uint code;
2964

2965 2966
  if (!res)
    goto err;
2967
  null_value= 0;
2968 2969 2970 2971
  if (res->is_empty())
    return res;

  new_size= uint4korr(res->ptr()) & 0x3FFFFFFF;
2972
  if (new_size > current_thd->variables.max_allowed_packet)
unknown's avatar
unknown committed
2973 2974 2975
  {
    push_warning_printf(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,
			ER_TOO_BIG_FOR_UNCOMPRESS,
2976 2977
			ER(ER_TOO_BIG_FOR_UNCOMPRESS),
                        current_thd->variables.max_allowed_packet);
2978
    goto err;
unknown's avatar
unknown committed
2979
  }
2980 2981
  if (buffer.realloc((uint32)new_size))
    goto err;
2982

2983 2984
  if ((err= uncompress((Byte*)buffer.ptr(), &new_size,
		       ((const Bytef*)res->ptr())+4,res->length())) == Z_OK)
unknown's avatar
unknown committed
2985
  {
2986
    buffer.length((uint32) new_size);
unknown's avatar
unknown committed
2987 2988
    return &buffer;
  }
2989

2990 2991
  code= ((err == Z_BUF_ERROR) ? ER_ZLIB_Z_BUF_ERROR :
	 ((err == Z_MEM_ERROR) ? ER_ZLIB_Z_MEM_ERROR : ER_ZLIB_Z_DATA_ERROR));
unknown's avatar
unknown committed
2992
  push_warning(current_thd,MYSQL_ERROR::WARN_LEVEL_ERROR,code,ER(code));
2993 2994

err:
unknown's avatar
unknown committed
2995 2996 2997 2998
  null_value= 1;
  return 0;
}
#endif
unknown's avatar
unknown committed
2999 3000 3001 3002

/*
  UUID, as in
    DCE 1.1: Remote Procedure Call,
unknown's avatar
unknown committed
3003
    Open Group Technical Standard Document Number C706, October 1997,
unknown's avatar
unknown committed
3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024
    (supersedes C309 DCE: Remote Procedure Call 8/1994,
    which was basis for ISO/IEC 11578:1996 specification)
*/

static struct rand_struct uuid_rand;
static uint nanoseq;
static ulonglong uuid_time=0;
static char clock_seq_and_node_str[]="-0000-000000000000";

/* number of 100-nanosecond intervals between
   1582-10-15 00:00:00.00 and 1970-01-01 00:00:00.00 */
#define UUID_TIME_OFFSET ((ulonglong) 141427 * 24 * 60 * 60 * 1000 * 10 )

#define UUID_VERSION      0x1000
#define UUID_VARIANT      0x8000

static void tohex(char *to, uint from, uint len)
{
  to+= len;
  while (len--)
  {
3025
    *--to= _dig_vec_lower[from & 15];
unknown's avatar
unknown committed
3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038
    from >>= 4;
  }
}

static void set_clock_seq_str()
{
  uint16 clock_seq= ((uint)(my_rnd(&uuid_rand)*16383)) | UUID_VARIANT;
  tohex(clock_seq_and_node_str+1, clock_seq, 4);
  nanoseq= 0;
}

String *Item_func_uuid::val_str(String *str)
{
3039
  DBUG_ASSERT(fixed == 1);
unknown's avatar
unknown committed
3040
  char *s;
3041 3042
  THD *thd= current_thd;

unknown's avatar
unknown committed
3043 3044 3045 3046 3047
  pthread_mutex_lock(&LOCK_uuid_generator);
  if (! uuid_time) /* first UUID() call. initializing data */
  {
    ulong tmp=sql_rnd_with_mutex();
    uchar mac[6];
unknown's avatar
unknown committed
3048
    int i;
unknown's avatar
unknown committed
3049 3050 3051 3052 3053 3054 3055 3056
    if (my_gethwaddr(mac))
    {
      /*
        generating random "hardware addr"
        and because specs explicitly specify that it should NOT correlate
        with a clock_seq value (initialized random below), we use a separate
        randominit() here
      */
3057
      randominit(&uuid_rand, tmp + (ulong) thd, tmp + (ulong)query_id);
unknown's avatar
unknown committed
3058
      for (i=0; i < (int)sizeof(mac); i++)
unknown's avatar
unknown committed
3059 3060 3061 3062 3063
        mac[i]=(uchar)(my_rnd(&uuid_rand)*255);
    }
    s=clock_seq_and_node_str+sizeof(clock_seq_and_node_str)-1;
    for (i=sizeof(mac)-1 ; i>=0 ; i--)
    {
3064 3065
      *--s=_dig_vec_lower[mac[i] & 15];
      *--s=_dig_vec_lower[mac[i] >> 4];
unknown's avatar
unknown committed
3066
    }
3067 3068
    randominit(&uuid_rand, tmp + (ulong)start_time,
	       tmp + thd->status_var.bytes_sent);
unknown's avatar
unknown committed
3069 3070 3071
    set_clock_seq_str();
  }

unknown's avatar
unknown committed
3072
  ulonglong tv=my_getsystime() + UUID_TIME_OFFSET + nanoseq;
unknown's avatar
unknown committed
3073 3074
  if (unlikely(tv < uuid_time))
    set_clock_seq_str();
3075 3076 3077
  else if (unlikely(tv == uuid_time))
  {
    /* special protection from low-res system clocks */
unknown's avatar
unknown committed
3078 3079 3080 3081
    nanoseq++;
    tv++;
  }
  else
3082 3083 3084 3085 3086 3087 3088 3089
  {
    if (nanoseq)
    {
      tv-=nanoseq;
      nanoseq=0;
    }
    DBUG_ASSERT(tv > uuid_time);
  }
unknown's avatar
unknown committed
3090 3091 3092
  uuid_time=tv;
  pthread_mutex_unlock(&LOCK_uuid_generator);

3093 3094 3095
  uint32 time_low=            (uint32) (tv & 0xFFFFFFFF);
  uint16 time_mid=            (uint16) ((tv >> 32) & 0xFFFF);
  uint16 time_hi_and_version= (uint16) ((tv >> 48) | UUID_VERSION);
unknown's avatar
unknown committed
3096 3097 3098

  str->realloc(UUID_LENGTH+1);
  str->length(UUID_LENGTH);
unknown's avatar
unknown committed
3099
  str->set_charset(system_charset_info);
unknown's avatar
unknown committed
3100 3101 3102 3103 3104 3105 3106 3107 3108
  s=(char *) str->ptr();
  s[8]=s[13]='-';
  tohex(s, time_low, 8);
  tohex(s+9, time_mid, 4);
  tohex(s+14, time_hi_and_version, 4);
  strmov(s+18, clock_seq_and_node_str);
  return str;
}