1 /*
2 Copyright (c) 2000, 2017, Oracle and/or its affiliates.
3 Copyright (c) 2009, 2020, MariaDB Corporation.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; version 2 of the License.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA
17 */
18
19 /**
20 @file
21
22 @brief
23 This file defines all string functions
24
25 @warning
26 Some string functions don't always put and end-null on a String.
27 (This shouldn't be needed)
28 */
29
30 #ifdef USE_PRAGMA_IMPLEMENTATION
31 #pragma implementation // gcc: Class implementation
32 #endif
33
34 #include "mariadb.h" // HAVE_*
35
36 #include "sql_priv.h"
37 /*
38 It is necessary to include set_var.h instead of item.h because there
39 are dependencies on include order for set_var.h and item.h. This
isLegalToInlineToyInlinerInterface40 will be resolved later.
41 */
42 #include "sql_class.h" // set_var.h: THD
43 #include "set_var.h"
44 #include "sql_base.h"
45 #include "sql_time.h"
46 #include "sql_acl.h" // SUPER_ACL
47 #include "des_key_file.h" // st_des_keyschedule, st_des_keyblock
48 #include "password.h" // my_make_scrambled_password,
49 // my_make_scrambled_password_323
50 #include <m_ctype.h>
51 #include <my_md5.h>
52 C_MODE_START
53 #include "../mysys/my_static.h" // For soundex_map
54 C_MODE_END
55 #include "sql_show.h" // append_identifier
56 #include <sql_repl.h>
57 #include "sql_statistics.h"
58
59 size_t username_char_length= 80;
60
61
62 class Repeat_count
63 {
64 ulonglong m_count;
65 public:
66 Repeat_count(Item *item)
67 :m_count(0)
68 {
69 Longlong_hybrid nr= item->to_longlong_hybrid();
70 if (!item->null_value && !nr.neg())
71 {
72 // Assume that the maximum length of a String is < INT_MAX32
materializeCallConversionToyInlinerInterface73 m_count= (ulonglong) nr.value();
74 if (m_count > (ulonglong) INT_MAX32)
75 m_count= (ulonglong) INT_MAX32;
76 }
77 }
78 ulonglong count() const { return m_count; }
79 };
80
81
82 /*
83 For the Items which have only val_str_ascii() method
84 and don't have their own "native" val_str(),
85 we provide a "wrapper" method to convert from ASCII
initialize()86 to Item character set when it's necessary.
87 Conversion happens only in case of "tricky" Item character set (e.g. UCS2).
88 Normally conversion does not happen, and val_str_ascii() is immediately
89 returned instead.
90
91 No matter if conversion is needed or not needed,
92 the result is always returned in "str" (see MDEV-10306 why).
93
94 @param [OUT] str - Store the result here
95 @param [IN] ascii_buffer - Use this temporary buffer to call val_str_ascii()
96 */
97 String *Item_func::val_str_from_val_str_ascii(String *str, String *ascii_buffer)
98 {
99 DBUG_ASSERT(fixed == 1);
100
101 if (!(collation.collation->state & MY_CS_NONASCII))
102 {
103 String *res= val_str_ascii(str);
104 if (res)
105 res->set_charset(collation.collation);
106 return res;
107 }
108
109 DBUG_ASSERT(str != ascii_buffer);
110
111 uint errors;
112 String *res= val_str_ascii(ascii_buffer);
113 if (!res)
114 return 0;
115
116 if ((null_value= str->copy(res->ptr(), res->length(),
117 &my_charset_latin1, collation.collation,
118 &errors)))
119 return 0;
120
121 return str;
122 }
123
124
125 bool Item_str_func::fix_fields(THD *thd, Item **ref)
126 {
127 bool res= Item_func::fix_fields(thd, ref);
128 /*
printBinaryOp(mlir::OpAsmPrinter & printer,mlir::Operation * op)129 In Item_str_func::check_well_formed_result() we may set null_value
130 flag on the same condition as in test() below.
131 */
132 maybe_null= maybe_null || thd->is_strict_mode();
133 return res;
134 }
135
136
__anonb84039bf0102(Type type) 137 my_decimal *Item_str_func::val_decimal(my_decimal *decimal_value)
138 {
139 DBUG_ASSERT(fixed == 1);
140 StringBuffer<64> tmp;
141 String *res= val_str(&tmp);
142 return res ? decimal_from_string_with_check(decimal_value, res) : 0;
143 }
144
145
146 double Item_str_func::val_real()
147 {
148 DBUG_ASSERT(fixed == 1);
149 StringBuffer<64> tmp;
150 String *res= val_str(&tmp);
151 return res ? double_from_string_with_check(res) : 0.0;
build(mlir::OpBuilder & builder,mlir::OperationState & state,double value)152 }
153
154
155 longlong Item_str_func::val_int()
156 {
157 DBUG_ASSERT(fixed == 1);
158 StringBuffer<22> tmp;
159 String *res= val_str(&tmp);
160 return res ? longlong_from_string_with_check(res) : 0;
161 }
162
163
164 String *Item_func_md5::val_str_ascii(String *str)
165 {
parseConstantOp(mlir::OpAsmParser & parser,mlir::OperationState & result)166 DBUG_ASSERT(fixed == 1);
167 String * sptr= args[0]->val_str(str);
168 if (sptr)
169 {
170 uchar digest[16];
171
172 null_value=0;
173 compute_md5_hash(digest, (const char *) sptr->ptr(), sptr->length());
174 if (str->alloc(32)) // Ensure that memory is free
175 {
176 null_value=1;
177 return 0;
178 }
print(mlir::OpAsmPrinter & printer,ConstantOp op)179 array_to_hex((char *) str->ptr(), digest, 16);
180 str->set_charset(&my_charset_numeric);
181 str->length((uint) 32);
182 return str;
183 }
184 null_value=1;
185 return 0;
186 }
verify(ConstantOp op)187
188
189 String *Item_func_sha::val_str_ascii(String *str)
190 {
191 DBUG_ASSERT(fixed == 1);
192 String * sptr= args[0]->val_str(str);
193 if (sptr) /* If we got value different from NULL */
194 {
195 /* Temporary buffer to store 160bit digest */
196 uint8 digest[MY_SHA1_HASH_SIZE];
197 my_sha1(digest, (const char *) sptr->ptr(), sptr->length());
198 /* Ensure that memory is free and we got result */
199 if (!str->alloc(MY_SHA1_HASH_SIZE*2))
200 {
201 array_to_hex((char *) str->ptr(), digest, MY_SHA1_HASH_SIZE);
202 str->set_charset(&my_charset_numeric);
203 str->length((uint) MY_SHA1_HASH_SIZE*2);
204 null_value=0;
205 return str;
206 }
207 }
208 null_value=1;
209 return 0;
210 }
211
212 bool Item_func_sha::fix_length_and_dec()
213 {
214 // size of hex representation of hash
215 fix_length_and_charset(MY_SHA1_HASH_SIZE * 2, default_charset());
216 return FALSE;
217 }
218
build(mlir::OpBuilder & builder,mlir::OperationState & state,mlir::Value lhs,mlir::Value rhs)219 String *Item_func_sha2::val_str_ascii(String *str)
220 {
221 DBUG_ASSERT(fixed == 1);
222 unsigned char digest_buf[512/8]; // enough for SHA512
223 String *input_string;
224 const char *input_ptr;
225 size_t input_len;
226
227 input_string= args[0]->val_str(str);
228 str->set_charset(&my_charset_bin);
229
230 if (input_string == NULL)
231 {
232 null_value= TRUE;
233 return (String *) NULL;
234 }
235
236 null_value= args[0]->null_value;
237 if (null_value)
238 return (String *) NULL;
239
240 input_ptr= input_string->ptr();
241 input_len= input_string->length();
242
243 longlong digest_length= args[1]->val_int();
244 switch (digest_length) {
245 case 512:
246 my_sha512(digest_buf, input_ptr, input_len);
247 break;
248 case 384:
249 my_sha384(digest_buf, input_ptr, input_len);
250 break;
251 case 224:
252 my_sha224(digest_buf, input_ptr, input_len);
253 break;
254 case 0: // SHA-256 is the default
255 digest_length= 256;
256 /* fall through */
257 case 256:
258 my_sha256(digest_buf, input_ptr, input_len);
259 break;
260 default:
261 if (!args[1]->const_item())
262 {
263 THD *thd= current_thd;
264 push_warning_printf(thd,
265 Sql_condition::WARN_LEVEL_WARN,
266 ER_WRONG_PARAMETERS_TO_NATIVE_FCT,
267 ER_THD(thd, ER_WRONG_PARAMETERS_TO_NATIVE_FCT),
268 "sha2");
269 }
270 null_value= TRUE;
271 return NULL;
272 }
273 digest_length/= 8; /* bits to bytes */
274
275 /*
276 Since we're subverting the usual String methods, we must make sure that
277 the destination has space for the bytes we're about to write.
278 */
279 str->realloc((uint) digest_length*2 + 1); /* Each byte as two nybbles */
280
281 /* Convert the large number to a string-hex representation. */
282 array_to_hex((char *) str->ptr(), digest_buf, (uint)digest_length);
283
284 /* We poked raw bytes in. We must inform the the String of its length. */
285 str->length((uint) digest_length*2); /* Each byte as two nybbles */
286
287 null_value= FALSE;
288 return str;
289 }
290
291
292 bool Item_func_sha2::fix_length_and_dec()
293 {
294 maybe_null= 1;
295 max_length = 0;
296
297 int sha_variant= (int)(args[1]->const_item() ? args[1]->val_int() : 512);
298
299 switch (sha_variant) {
300 case 0: // SHA-256 is the default
301 sha_variant= 256;
302 /* fall through */
303 case 512:
304 case 384:
305 case 256:
306 case 224:
307 fix_length_and_charset(sha_variant/8 * 2, default_charset());
308 break;
309 default:
310 THD *thd= current_thd;
311 push_warning_printf(thd,
312 Sql_condition::WARN_LEVEL_WARN,
313 ER_WRONG_PARAMETERS_TO_NATIVE_FCT,
314 ER_THD(thd, ER_WRONG_PARAMETERS_TO_NATIVE_FCT),
315 "sha2");
316 }
317 return FALSE;
318 }
319
320 /* Implementation of AES encryption routines */
321 void Item_aes_crypt::create_key(String *user_key, uchar *real_key)
322 {
323 uchar *real_key_end= real_key + AES_KEY_LENGTH / 8;
324 uchar *ptr;
build(mlir::OpBuilder & builder,mlir::OperationState & state,mlir::Value value)325 const char *sptr= user_key->ptr();
326 const char *key_end= sptr + user_key->length();
327
328 bzero(real_key, AES_KEY_LENGTH / 8);
329
330 for (ptr= real_key; sptr < key_end; ptr++, sptr++)
inferShapes()331 {
332 if (ptr == real_key_end)
333 ptr= real_key;
334 *ptr ^= (uchar) *sptr;
335 }
336 }
verify(TransposeOp op)337
338
339 String *Item_aes_crypt::val_str(String *str2)
340 {
341 DBUG_ASSERT(fixed == 1);
342 StringBuffer<80> user_key_buf;
343 String *sptr= args[0]->val_str(&tmp_value);
344 String *user_key= args[1]->val_str(&user_key_buf);
345 uint32 aes_length;
346
347 if (sptr && user_key) // we need both arguments to be not NULL
348 {
349 null_value=0;
350 aes_length=my_aes_get_size(MY_AES_ECB, sptr->length());
351
352 if (!str2->alloc(aes_length)) // Ensure that memory is free
353 {
354 uchar rkey[AES_KEY_LENGTH / 8];
355 create_key(user_key, rkey);
356
357 if (!my_aes_crypt(MY_AES_ECB, what, (uchar*)sptr->ptr(), sptr->length(),
358 (uchar*)str2->ptr(), &aes_length,
359 rkey, AES_KEY_LENGTH / 8, 0, 0))
360 {
361 str2->length((uint) aes_length);
362 DBUG_ASSERT(collation.collation == &my_charset_bin);
363 str2->set_charset(&my_charset_bin);
364 return str2;
365 }
366 }
367 }
368 null_value=1;
369 return 0;
370 }
371
372 bool Item_func_aes_encrypt::fix_length_and_dec()
373 {
374 max_length=my_aes_get_size(MY_AES_ECB, args[0]->max_length);
375 what= ENCRYPTION_FLAG_ENCRYPT;
376 return FALSE;
377 }
378
379
380
381 bool Item_func_aes_decrypt::fix_length_and_dec()
382 {
383 max_length=args[0]->max_length;
384 maybe_null= 1;
385 what= ENCRYPTION_FLAG_DECRYPT;
386 return FALSE;
387 }
388
389
390 bool Item_func_to_base64::fix_length_and_dec()
391 {
392 maybe_null= args[0]->maybe_null;
393 collation.set(default_charset(), DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII);
394 if (args[0]->max_length > (uint) my_base64_encode_max_arg_length())
395 {
396 maybe_null= 1;
397 fix_char_length_ulonglong((ulonglong) my_base64_encode_max_arg_length());
398 }
399 else
400 {
401 int length= my_base64_needed_encoded_length((int) args[0]->max_length);
402 DBUG_ASSERT(length > 0);
403 fix_char_length_ulonglong((ulonglong) length - 1);
404 }
405 return FALSE;
406 }
407
408
409 String *Item_func_to_base64::val_str_ascii(String *str)
410 {
411 String *res= args[0]->val_str(&tmp_value);
412 bool too_long= false;
413 int length;
414 if (!res ||
415 res->length() > (uint) my_base64_encode_max_arg_length() ||
416 (too_long=
417 ((uint) (length= my_base64_needed_encoded_length((int) res->length())) >
418 current_thd->variables.max_allowed_packet)) ||
419 str->alloc((uint) length))
420 {
421 null_value= 1; // NULL input, too long input, or OOM.
422 if (too_long)
423 {
424 THD *thd= current_thd;
425 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
426 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
427 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
428 func_name(),
429 thd->variables.max_allowed_packet);
430 }
431 return 0;
432 }
433 my_base64_encode(res->ptr(), (int) res->length(), (char*) str->ptr());
434 DBUG_ASSERT(length > 0);
435 str->length((uint) length - 1); // Without trailing '\0'
436 null_value= 0;
437 return str;
438 }
439
440
441 bool Item_func_from_base64::fix_length_and_dec()
442 {
443 if (args[0]->max_length > (uint) my_base64_decode_max_arg_length())
444 {
445 fix_char_length_ulonglong((ulonglong) my_base64_decode_max_arg_length());
446 }
447 else
448 {
449 int length= my_base64_needed_decoded_length((int) args[0]->max_length);
450 fix_char_length_ulonglong((ulonglong) length);
451 }
452 maybe_null= 1; // Can be NULL, e.g. in case of badly formed input string
453 return FALSE;
454 }
455
456
457 String *Item_func_from_base64::val_str(String *str)
458 {
459 String *res= args[0]->val_str_ascii(&tmp_value);
460 int length;
461 const char *end_ptr;
462
463 if (!res)
464 goto err;
465
466 if (res->length() > (uint) my_base64_decode_max_arg_length() ||
467 ((uint) (length= my_base64_needed_decoded_length((int) res->length())) >
468 current_thd->variables.max_allowed_packet))
469 {
470 THD *thd= current_thd;
471 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
472 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
473 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
474 func_name(),
475 thd->variables.max_allowed_packet);
476 goto err;
477 }
478
479 if (str->alloc((uint) length))
480 goto err;
481
482 if ((length= my_base64_decode(res->ptr(), (int) res->length(),
483 (char *) str->ptr(), &end_ptr, 0)) < 0 ||
484 end_ptr < res->ptr() + res->length())
485 {
486 THD *thd= current_thd;
487 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
488 ER_BAD_BASE64_DATA, ER_THD(thd, ER_BAD_BASE64_DATA),
489 (int) (end_ptr - res->ptr()));
490 goto err;
491 }
492
493 str->length((uint) length);
494 null_value= 0;
495 return str;
496 err:
497 null_value= 1; // NULL input, too long input, OOM, or badly formed input
498 return 0;
499 }
500 ///////////////////////////////////////////////////////////////////////////////
501
502
503 const char *histogram_types[] =
504 {"SINGLE_PREC_HB", "DOUBLE_PREC_HB", 0};
505 static TYPELIB histogram_types_typelib=
506 { array_elements(histogram_types),
507 "histogram_types",
508 histogram_types, NULL};
509 const char *representation_by_type[]= {"%.3f", "%.5f"};
510
511 String *Item_func_decode_histogram::val_str(String *str)
512 {
513 DBUG_ASSERT(fixed == 1);
514 char buff[STRING_BUFFER_USUAL_SIZE];
515 String *res, tmp(buff, sizeof(buff), &my_charset_bin);
516 int type;
517
518 tmp.length(0);
519 if (!(res= args[0]->val_str(&tmp)) ||
520 (type= find_type(res->c_ptr_safe(),
521 &histogram_types_typelib, MYF(0))) <= 0)
522 {
523 null_value= 1;
524 return 0;
525 }
526 type--;
527
528 tmp.length(0);
529 if (!(res= args[1]->val_str(&tmp)))
530 {
531 null_value= 1;
532 return 0;
533 }
534 if (type == DOUBLE_PREC_HB && res->length() % 2 != 0)
535 res->length(res->length() - 1); // one byte is unused
536
537 double prev= 0.0;
538 uint i;
539 str->length(0);
540 char numbuf[32];
541 const uchar *p= (uchar*)res->c_ptr_safe();
542 for (i= 0; i < res->length(); i++)
543 {
544 double val;
545 switch (type)
546 {
547 case SINGLE_PREC_HB:
548 val= p[i] / ((double)((1 << 8) - 1));
549 break;
550 case DOUBLE_PREC_HB:
551 val= uint2korr(p + i) / ((double)((1 << 16) - 1));
552 i++;
553 break;
554 default:
555 val= 0;
556 DBUG_ASSERT(0);
557 }
558 /* show delta with previous value */
559 size_t size= my_snprintf(numbuf, sizeof(numbuf),
560 representation_by_type[type], val - prev);
561 str->append(numbuf, size);
562 str->append(",");
563 prev= val;
564 }
565 /* show delta with max */
566 size_t size= my_snprintf(numbuf, sizeof(numbuf),
567 representation_by_type[type], 1.0 - prev);
568 str->append(numbuf, size);
569
570 null_value=0;
571 return str;
572 }
573
574
575 ///////////////////////////////////////////////////////////////////////////////
576
577 /*
578 Realloc the result buffer.
579 NOTE: We should be prudent in the initial allocation unit -- the
580 size of the arguments is a function of data distribution, which
581 can be any. Instead of overcommitting at the first row, we grow
582 the allocated amount by the factor of 2. This ensures that no
583 more than 25% of memory will be overcommitted on average.
584
585 @param IN/OUT str - the result string
586 @param IN length - new total space required in "str"
587 @retval false - on success
588 @retval true - on error
589 */
590
591 bool Item_func_concat::realloc_result(String *str, uint length) const
592 {
593 if (str->alloced_length() >= length)
594 return false; // Alloced space is big enough, nothing to do.
595
596 if (str->alloced_length() == 0)
597 return str->alloc(length);
598
599 /*
600 Item_func_concat::val_str() makes sure the result length does not grow
601 higher than max_allowed_packet. So "length" is limited to 1G here.
602 We can't say anything about the current value of str->alloced_length(),
603 as str was initially set by args[0]->val_str(str).
604 So multiplication by 2 can overflow, if args[0] for some reasons
605 did not limit the result to max_alloced_packet. But it's not harmful,
606 "str" will be reallocated exactly to "length" bytes in case of overflow.
607 */
608 uint new_length= MY_MAX(str->alloced_length() * 2, length);
609 return str->realloc(new_length);
610 }
611
612
613 /**
614 Concatenate args with the following premises:
615 If only one arg (which is ok), return value of arg;
616 */
617
618 String *Item_func_concat::val_str(String *str)
619 {
620 DBUG_ASSERT(fixed == 1);
621 THD *thd= current_thd;
622 String *res;
623
624 null_value=0;
625 if (!(res= args[0]->val_str(str)))
626 goto null;
627
628 if (res != str)
629 str->copy_or_move(res->ptr(), res->length(), res->charset());
630
631 for (uint i= 1 ; i < arg_count ; i++)
632 {
633 if (!(res= args[i]->val_str(&tmp_value)) ||
634 append_value(thd, str, res))
635 goto null;
636 }
637
638 str->set_charset(collation.collation);
639 return str;
640
641 null:
642 null_value= true;
643 return 0;
644 }
645
646
647 String *Item_func_concat_operator_oracle::val_str(String *str)
648 {
649 DBUG_ASSERT(fixed == 1);
650 THD *thd= current_thd;
651 String *res= NULL;
652 uint i;
653
654 null_value=0;
655 // Search first non null argument
656 for (i= 0; i < arg_count; i++)
657 {
658 if ((res= args[i]->val_str(str)))
659 break;
660 }
661 if (!res)
662 goto null;
663
664 if (res != str)
665 str->copy(res->ptr(), res->length(), res->charset());
666
667 for (i++ ; i < arg_count ; i++)
668 {
669 if (!(res= args[i]->val_str(&tmp_value)) || res->length() == 0)
670 continue;
671 if (append_value(thd, str, res))
672 goto null;
673 }
674
675 str->set_charset(collation.collation);
676 return str;
677
678 null:
679 null_value= true;
680 return 0;
681 }
682
683
684 bool Item_func_concat::append_value(THD *thd, String *res, const String *app)
685 {
686 uint concat_len;
687 if ((concat_len= res->length() + app->length()) >
688 thd->variables.max_allowed_packet)
689 {
690 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
691 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
692 ER(ER_WARN_ALLOWED_PACKET_OVERFLOWED), func_name(),
693 thd->variables.max_allowed_packet);
694 return true;
695 }
696 DBUG_ASSERT(!res->uses_buffer_owned_by(app));
697 DBUG_ASSERT(!app->uses_buffer_owned_by(res));
698 return realloc_result(res, concat_len) || res->append(*app);
699 }
700
701
702 bool Item_func_concat::fix_length_and_dec()
703 {
704 ulonglong char_length= 0;
705
706 if (agg_arg_charsets_for_string_result(collation, args, arg_count))
707 return TRUE;
708
709 for (uint i=0 ; i < arg_count ; i++)
710 char_length+= args[i]->max_char_length();
711
712 fix_char_length_ulonglong(char_length);
713 return FALSE;
714 }
715
716 /**
717 @details
718 Function des_encrypt() by tonu@spam.ee & monty
719 Works only if compiled with OpenSSL library support.
720 @return
721 A binary string where first character is CHAR(128 | key-number).
722 If one uses a string key key_number is 127.
723 Encryption result is longer than original by formula:
724 @code new_length= org_length + (8-(org_length % 8))+1 @endcode
725 */
726
727 String *Item_func_des_encrypt::val_str(String *str)
728 {
729 DBUG_ASSERT(fixed == 1);
730 #if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
731 uint code= ER_WRONG_PARAMETERS_TO_PROCEDURE;
732 DES_cblock ivec;
733 struct st_des_keyblock keyblock;
734 struct st_des_keyschedule keyschedule;
735 const char *append_str="********";
736 uint key_number, res_length, tail;
737 String *res= args[0]->val_str(&tmp_value);
738
739 if ((null_value= args[0]->null_value))
740 return 0; // ENCRYPT(NULL) == NULL
741 if ((res_length=res->length()) == 0)
742 return make_empty_result();
743 if (arg_count == 1)
744 {
745 /* Protect against someone doing FLUSH DES_KEY_FILE */
746 mysql_mutex_lock(&LOCK_des_key_file);
747 keyschedule= des_keyschedule[key_number=des_default_key];
748 mysql_mutex_unlock(&LOCK_des_key_file);
749 }
750 else if (args[1]->result_type() == INT_RESULT)
751 {
752 key_number= (uint) args[1]->val_int();
753 if (key_number > 9)
754 goto error;
755 mysql_mutex_lock(&LOCK_des_key_file);
756 keyschedule= des_keyschedule[key_number];
757 mysql_mutex_unlock(&LOCK_des_key_file);
758 }
759 else
760 {
761 String *keystr= args[1]->val_str(str);
762 if (!keystr)
763 goto error;
764 key_number=127; // User key string
765
766 /* We make good 24-byte (168 bit) key from given plaintext key with MD5 */
767 bzero((char*) &ivec,sizeof(ivec));
768 if (!EVP_BytesToKey(EVP_des_ede3_cbc(),EVP_md5(),NULL,
769 (uchar*) keystr->ptr(), (int) keystr->length(),
770 1, (uchar*) &keyblock,ivec))
771 goto error;
772 DES_set_key_unchecked(&keyblock.key1,&keyschedule.ks1);
773 DES_set_key_unchecked(&keyblock.key2,&keyschedule.ks2);
774 DES_set_key_unchecked(&keyblock.key3,&keyschedule.ks3);
775 }
776
777 /*
778 The problem: DES algorithm requires original data to be in 8-bytes
779 chunks. Missing bytes get filled with '*'s and result of encryption
780 can be up to 8 bytes longer than original string. When decrypted,
781 we do not know the size of original string :(
782 We add one byte with value 0x1..0x8 as the last byte of the padded
783 string marking change of string length.
784 */
785
786 tail= 8 - (res_length % 8); // 1..8 marking extra length
787 res_length+=tail;
788 if (tmp_arg.realloc(res_length))
789 goto error;
790 tmp_arg.length(0);
791 tmp_arg.append(res->ptr(), res->length());
792 code= ER_OUT_OF_RESOURCES;
793 if (tmp_arg.append(append_str, tail) || str->alloc(res_length+1))
794 goto error;
795 tmp_arg[res_length-1]=tail; // save extra length
796 str->realloc(res_length+1);
797 str->length(res_length+1);
798 str->set_charset(&my_charset_bin);
799 (*str)[0]=(char) (128 | key_number);
800 // Real encryption
801 bzero((char*) &ivec,sizeof(ivec));
802 DES_ede3_cbc_encrypt((const uchar*) (tmp_arg.ptr()),
803 (uchar*) (str->ptr()+1),
804 res_length,
805 &keyschedule.ks1,
806 &keyschedule.ks2,
807 &keyschedule.ks3,
808 &ivec, TRUE);
809 return str;
810
811 error:
812 THD *thd= current_thd;
813 push_warning_printf(thd,Sql_condition::WARN_LEVEL_WARN,
814 code, ER_THD(thd, code),
815 "des_encrypt");
816 #else
817 THD *thd= current_thd;
818 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
819 ER_FEATURE_DISABLED, ER_THD(thd, ER_FEATURE_DISABLED),
820 "des_encrypt", "--with-ssl");
821 #endif /* defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY) */
822 null_value=1;
823 return 0;
824 }
825
826
827 String *Item_func_des_decrypt::val_str(String *str)
828 {
829 DBUG_ASSERT(fixed == 1);
830 #if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
831 uint code= ER_WRONG_PARAMETERS_TO_PROCEDURE;
832 DES_cblock ivec;
833 struct st_des_keyblock keyblock;
834 struct st_des_keyschedule keyschedule;
835 String *res= args[0]->val_str(&tmp_value);
836 uint length,tail;
837
838 if ((null_value= args[0]->null_value))
839 return 0;
840 length= res->length();
841 if (length < 9 || (length % 8) != 1 || !((*res)[0] & 128))
842 return res; // Skip decryption if not encrypted
843
844 if (arg_count == 1) // If automatic uncompression
845 {
846 uint key_number=(uint) (*res)[0] & 127;
847 // Check if automatic key and that we have privilege to uncompress using it
848 if (!(current_thd->security_ctx->master_access & SUPER_ACL) ||
849 key_number > 9)
850 goto error;
851
852 mysql_mutex_lock(&LOCK_des_key_file);
853 keyschedule= des_keyschedule[key_number];
854 mysql_mutex_unlock(&LOCK_des_key_file);
855 }
856 else
857 {
858 // We make good 24-byte (168 bit) key from given plaintext key with MD5
859 String *keystr= args[1]->val_str(str);
860 if (!keystr)
861 goto error;
862
863 bzero((char*) &ivec,sizeof(ivec));
864 if (!EVP_BytesToKey(EVP_des_ede3_cbc(),EVP_md5(),NULL,
865 (uchar*) keystr->ptr(),(int) keystr->length(),
866 1,(uchar*) &keyblock,ivec))
867 goto error;
868 // Here we set all 64-bit keys (56 effective) one by one
869 DES_set_key_unchecked(&keyblock.key1,&keyschedule.ks1);
870 DES_set_key_unchecked(&keyblock.key2,&keyschedule.ks2);
871 DES_set_key_unchecked(&keyblock.key3,&keyschedule.ks3);
872 }
873 code= ER_OUT_OF_RESOURCES;
874 if (str->alloc(length-1))
875 goto error;
876
877 bzero((char*) &ivec,sizeof(ivec));
878 DES_ede3_cbc_encrypt((const uchar*) res->ptr()+1,
879 (uchar*) (str->ptr()),
880 length-1,
881 &keyschedule.ks1,
882 &keyschedule.ks2,
883 &keyschedule.ks3,
884 &ivec, FALSE);
885 /* Restore old length of key */
886 if ((tail=(uint) (uchar) (*str)[length-2]) > 8)
887 goto wrong_key; // Wrong key
888 str->length(length-1-tail);
889 str->set_charset(&my_charset_bin);
890 return str;
891
892 error:
893 {
894 THD *thd= current_thd;
895 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
896 code, ER_THD(thd, code),
897 "des_decrypt");
898 }
899 wrong_key:
900 #else
901 {
902 THD *thd= current_thd;
903 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
904 ER_FEATURE_DISABLED, ER_THD(thd, ER_FEATURE_DISABLED),
905 "des_decrypt", "--with-ssl");
906 }
907 #endif /* defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY) */
908 null_value=1;
909 return 0;
910 }
911
912
913 /**
914 concat with separator. First arg is the separator
915 concat_ws takes at least two arguments.
916 */
917
918 String *Item_func_concat_ws::val_str(String *str)
919 {
920 DBUG_ASSERT(fixed == 1);
921 char tmp_str_buff[10];
922 String tmp_sep_str(tmp_str_buff, sizeof(tmp_str_buff),default_charset_info),
923 *sep_str, *res, *res2,*use_as_buff;
924 uint i;
925 bool is_const= 0;
926 THD *thd= 0;
927
928 null_value=0;
929 if (!(sep_str= args[0]->val_str(&tmp_sep_str)))
930 goto null;
931
932 use_as_buff= &tmp_value;
933 str->length(0); // QQ; Should be removed
934 res=str; // If 0 arg_count
935
936 // Skip until non-null argument is found.
937 // If not, return the empty string
938 for (i=1; i < arg_count; i++)
939 if ((res= args[i]->val_str(str)))
940 {
941 is_const= args[i]->const_item();
942 break;
943 }
944
945 if (i == arg_count)
946 return make_empty_result();
947
948 for (i++; i < arg_count ; i++)
949 {
950 if (!(res2= args[i]->val_str(use_as_buff)))
951 continue; // Skip NULL
952
953 if (!thd)
954 thd= current_thd;
955 if (res->length() + sep_str->length() + res2->length() >
956 thd->variables.max_allowed_packet)
957 {
958 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
959 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
960 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
961 func_name(),
962 thd->variables.max_allowed_packet);
963 goto null;
964 }
965 if (!is_const && res->alloced_length() >=
966 res->length() + sep_str->length() + res2->length())
967 { // Use old buffer
968 res->append(*sep_str); // res->length() > 0 always
969 res->append(*res2);
970 }
971 else if (str->alloced_length() >=
972 res->length() + sep_str->length() + res2->length())
973 {
974 /* We have room in str; We can't get any errors here */
975 if (str->ptr() == res2->ptr())
976 { // This is quite uncommon!
977 str->replace(0,0,*sep_str);
978 str->replace(0,0,*res);
979 }
980 else
981 {
982 str->copy(*res);
983 str->append(*sep_str);
984 str->append(*res2);
985 }
986 res=str;
987 use_as_buff= &tmp_value;
988 }
989 else if (res == &tmp_value)
990 {
991 if (res->append(*sep_str) || res->append(*res2))
992 goto null; // Must be a blob
993 }
994 else if (res2 == &tmp_value)
995 { // This can happen only 1 time
996 if (tmp_value.replace(0,0,*sep_str) || tmp_value.replace(0,0,*res))
997 goto null;
998 res= &tmp_value;
999 use_as_buff=str; // Put next arg here
1000 }
1001 else if (tmp_value.is_alloced() && res2->ptr() >= tmp_value.ptr() &&
1002 res2->ptr() < tmp_value.ptr() + tmp_value.alloced_length())
1003 {
1004 /*
1005 This happens really seldom:
1006 In this case res2 is sub string of tmp_value. We will
1007 now work in place in tmp_value to set it to res | sep_str | res2
1008 */
1009 /* Chop the last characters in tmp_value that isn't in res2 */
1010 tmp_value.length((uint32) (res2->ptr() - tmp_value.ptr()) +
1011 res2->length());
1012 /* Place res2 at start of tmp_value, remove chars before res2 */
1013 if (tmp_value.replace(0,(uint32) (res2->ptr() - tmp_value.ptr()),
1014 *res) ||
1015 tmp_value.replace(res->length(),0, *sep_str))
1016 goto null;
1017 res= &tmp_value;
1018 use_as_buff=str; // Put next arg here
1019 }
1020 else
1021 { // Two big const strings
1022 /*
1023 NOTE: We should be prudent in the initial allocation unit -- the
1024 size of the arguments is a function of data distribution, which can
1025 be any. Instead of overcommitting at the first row, we grow the
1026 allocated amount by the factor of 2. This ensures that no more than
1027 25% of memory will be overcommitted on average.
1028 */
1029
1030 uint concat_len= res->length() + sep_str->length() + res2->length();
1031
1032 if (tmp_value.alloced_length() < concat_len)
1033 {
1034 if (tmp_value.alloced_length() == 0)
1035 {
1036 if (tmp_value.alloc(concat_len))
1037 goto null;
1038 }
1039 else
1040 {
1041 uint new_len = MY_MAX(tmp_value.alloced_length() * 2, concat_len);
1042
1043 if (tmp_value.realloc(new_len))
1044 goto null;
1045 }
1046 }
1047
1048 if (tmp_value.copy(*res) ||
1049 tmp_value.append(*sep_str) ||
1050 tmp_value.append(*res2))
1051 goto null;
1052 res= &tmp_value;
1053 use_as_buff=str;
1054 }
1055 }
1056 res->set_charset(collation.collation);
1057 return res;
1058
1059 null:
1060 null_value=1;
1061 return 0;
1062 }
1063
1064
1065 bool Item_func_concat_ws::fix_length_and_dec()
1066 {
1067 ulonglong char_length;
1068
1069 if (agg_arg_charsets_for_string_result(collation, args, arg_count))
1070 return TRUE;
1071
1072 /*
1073 arg_count cannot be less than 2,
1074 it is done on parser level in sql_yacc.yy
1075 so, (arg_count - 2) is safe here.
1076 */
1077 char_length= (ulonglong) args[0]->max_char_length() * (arg_count - 2);
1078 for (uint i=1 ; i < arg_count ; i++)
1079 char_length+= args[i]->max_char_length();
1080
1081 fix_char_length_ulonglong(char_length);
1082 return FALSE;
1083 }
1084
1085
1086 String *Item_func_reverse::val_str(String *str)
1087 {
1088 DBUG_ASSERT(fixed == 1);
1089 String *res= args[0]->val_str(&tmp_value);
1090 const char *ptr, *end;
1091 char *tmp;
1092
1093 if ((null_value=args[0]->null_value))
1094 return 0;
1095 /* An empty string is a special case as the string pointer may be null */
1096 if (!res->length())
1097 return make_empty_result();
1098 if (str->alloced_length() < res->length() &&
1099 str->realloc(res->length()))
1100 {
1101 null_value= 1;
1102 return 0;
1103 }
1104 str->length(res->length());
1105 str->set_charset(res->charset());
1106 ptr= res->ptr();
1107 end= res->end();
1108 tmp= (char *) str->end();
1109 #ifdef USE_MB
1110 if (use_mb(res->charset()))
1111 {
1112 uint32 l;
1113 while (ptr < end)
1114 {
1115 if ((l= my_ismbchar(res->charset(),ptr,end)))
1116 {
1117 tmp-= l;
1118 DBUG_ASSERT(tmp >= str->ptr());
1119 memcpy(tmp,ptr,l);
1120 ptr+= l;
1121 }
1122 else
1123 *--tmp= *ptr++;
1124 }
1125 }
1126 else
1127 #endif /* USE_MB */
1128 {
1129 while (ptr < end)
1130 *--tmp= *ptr++;
1131 }
1132 return str;
1133 }
1134
1135
1136 bool Item_func_reverse::fix_length_and_dec()
1137 {
1138 if (agg_arg_charsets_for_string_result(collation, args, 1))
1139 return TRUE;
1140 DBUG_ASSERT(collation.collation != NULL);
1141 fix_char_length(args[0]->max_char_length());
1142 return FALSE;
1143 }
1144
1145 /**
1146 Replace all occurrences of string2 in string1 with string3.
1147
1148 Don't reallocate val_str() if not needed.
1149
1150 @todo
1151 Fix that this works with binary strings when using USE_MB
1152 */
1153
1154 String *Item_func_replace::val_str_internal(String *str,
1155 String *empty_string_for_null)
1156 {
1157 DBUG_ASSERT(fixed == 1);
1158 String *res,*res2,*res3;
1159 int offset;
1160 uint from_length,to_length;
1161 bool alloced=0;
1162 #ifdef USE_MB
1163 const char *ptr,*end,*strend,*search,*search_end;
1164 uint32 l;
1165 bool binary_cmp;
1166 #endif
1167 THD *thd= 0;
1168
1169 null_value=0;
1170 res=args[0]->val_str(str);
1171 if (args[0]->null_value)
1172 goto null;
1173 res2=args[1]->val_str(&tmp_value);
1174 if (args[1]->null_value)
1175 {
1176 if (!empty_string_for_null)
1177 goto null;
1178 res2= empty_string_for_null;
1179 }
1180 res->set_charset(collation.collation);
1181
1182 #ifdef USE_MB
1183 binary_cmp = ((res->charset()->state & MY_CS_BINSORT) || !use_mb(res->charset()));
1184 #endif
1185
1186 if (res2->length() == 0)
1187 return res;
1188 #ifndef USE_MB
1189 if ((offset=res->strstr(*res2)) < 0)
1190 return res;
1191 #else
1192 offset=0;
1193 if (binary_cmp && (offset=res->strstr(*res2)) < 0)
1194 return res;
1195 #endif
1196 if (!(res3=args[2]->val_str(&tmp_value2)))
1197 {
1198 if (!empty_string_for_null)
1199 goto null;
1200 res3= empty_string_for_null;
1201 }
1202 from_length= res2->length();
1203 to_length= res3->length();
1204
1205 #ifdef USE_MB
1206 if (!binary_cmp)
1207 {
1208 search=res2->ptr();
1209 search_end=search+from_length;
1210 redo:
1211 DBUG_ASSERT(res->ptr() || !offset);
1212 ptr=res->ptr()+offset;
1213 strend=res->ptr()+res->length();
1214 /*
1215 In some cases val_str() can return empty string
1216 with ptr() == NULL and length() == 0.
1217 Let's check strend to avoid overflow.
1218 */
1219 end= strend ? strend - from_length + 1 : NULL;
1220 while (ptr < end)
1221 {
1222 if (*ptr == *search)
1223 {
1224 char *i,*j;
1225 i=(char*) ptr+1; j=(char*) search+1;
1226 while (j != search_end)
1227 if (*i++ != *j++) goto skip;
1228 offset= (int) (ptr-res->ptr());
1229
1230 if (!thd)
1231 thd= current_thd;
1232
1233 if (res->length()-from_length + to_length >
1234 thd->variables.max_allowed_packet)
1235 {
1236 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
1237 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
1238 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
1239 func_name(),
1240 thd->variables.max_allowed_packet);
1241
1242 goto null;
1243 }
1244 if (!alloced)
1245 {
1246 alloced=1;
1247 res=copy_if_not_alloced(str,res,res->length()+to_length);
1248 }
1249 res->replace((uint) offset,from_length,*res3);
1250 offset+=(int) to_length;
1251 goto redo;
1252 }
1253 skip:
1254 if ((l=my_ismbchar(res->charset(), ptr,strend))) ptr+=l;
1255 else ++ptr;
1256 }
1257 }
1258 else
1259 #endif /* USE_MB */
1260 {
1261 thd= current_thd;
1262 do
1263 {
1264 if (res->length()-from_length + to_length >
1265 thd->variables.max_allowed_packet)
1266 {
1267 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
1268 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
1269 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
1270 func_name(),
1271 thd->variables.max_allowed_packet);
1272 goto null;
1273 }
1274 if (!alloced)
1275 {
1276 alloced=1;
1277 res=copy_if_not_alloced(str,res,res->length()+to_length);
1278 }
1279 res->replace((uint) offset,from_length,*res3);
1280 offset+=(int) to_length;
1281 }
1282 while ((offset=res->strstr(*res2,(uint) offset)) >= 0);
1283 }
1284 if (empty_string_for_null && !res->length())
1285 goto null;
1286
1287 return res;
1288
1289 null:
1290 null_value=1;
1291 return 0;
1292 }
1293
1294
1295 bool Item_func_replace::fix_length_and_dec()
1296 {
1297 ulonglong char_length= (ulonglong) args[0]->max_char_length();
1298 int diff=(int) (args[2]->max_char_length() - args[1]->max_char_length());
1299 if (diff > 0 && args[1]->max_char_length())
1300 { // Calculate of maxreplaces
1301 ulonglong max_substrs= char_length / args[1]->max_char_length();
1302 char_length+= max_substrs * (uint) diff;
1303 }
1304
1305 if (agg_arg_charsets_for_string_result_with_comparison(collation, args, 3))
1306 return TRUE;
1307 fix_char_length_ulonglong(char_length);
1308 return FALSE;
1309 }
1310
1311
1312 /*********************************************************************/
1313 bool Item_func_regexp_replace::fix_fields(THD *thd, Item **ref)
1314 {
1315 re.set_recursion_limit(thd);
1316 return Item_str_func::fix_fields(thd, ref);
1317 }
1318
1319
1320 bool Item_func_regexp_replace::fix_length_and_dec()
1321 {
1322 if (agg_arg_charsets_for_string_result_with_comparison(collation, args, 3))
1323 return TRUE;
1324 max_length= MAX_BLOB_WIDTH;
1325 re.init(collation.collation, 0);
1326 re.fix_owner(this, args[0], args[1]);
1327 return FALSE;
1328 }
1329
1330
1331 /*
1332 Traverse through the replacement string and append to "str".
1333 Sub-pattern references \0 .. \9 are recognized, which are replaced
1334 to the chunks of the source string.
1335 */
1336 bool Item_func_regexp_replace::append_replacement(String *str,
1337 const LEX_CSTRING *source,
1338 const LEX_CSTRING *replace)
1339 {
1340 const char *beg= replace->str;
1341 const char *end= beg + replace->length;
1342 CHARSET_INFO *cs= re.library_charset();
1343
1344 for ( ; ; )
1345 {
1346 my_wc_t wc;
1347 int cnv, n;
1348
1349 if ((cnv= cs->cset->mb_wc(cs, &wc, (const uchar *) beg,
1350 (const uchar *) end)) < 1)
1351 break; /* End of line */
1352 beg+= cnv;
1353
1354 if (wc != '\\')
1355 {
1356 if (str->append(beg - cnv, cnv, cs))
1357 return true;
1358 continue;
1359 }
1360
1361 if ((cnv= cs->cset->mb_wc(cs, &wc, (const uchar *) beg,
1362 (const uchar *) end)) < 1)
1363 break; /* End of line */
1364 beg+= cnv;
1365
1366 if ((n= ((int) wc) - '0') >= 0 && n <= 9)
1367 {
1368 if (n < re.nsubpatterns())
1369 {
1370 /* A valid sub-pattern reference found */
1371 int pbeg= re.subpattern_start(n), plength= re.subpattern_end(n) - pbeg;
1372 if (str->append(source->str + pbeg, plength, cs))
1373 return true;
1374 }
1375 }
1376 else
1377 {
1378 /*
1379 A non-digit character following after '\'.
1380 Just add the character itself.
1381 */
1382 if (str->append(beg - cnv, cnv, cs))
1383 return false;
1384 }
1385 }
1386 return false;
1387 }
1388
1389
1390 String *Item_func_regexp_replace::val_str(String *str)
1391 {
1392 DBUG_ASSERT(fixed == 1);
1393 char buff0[MAX_FIELD_WIDTH];
1394 char buff2[MAX_FIELD_WIDTH];
1395 String tmp0(buff0,sizeof(buff0),&my_charset_bin);
1396 String tmp2(buff2,sizeof(buff2),&my_charset_bin);
1397 String *source= args[0]->val_str(&tmp0);
1398 String *replace= args[2]->val_str(&tmp2);
1399 LEX_CSTRING src, rpl;
1400 int startoffset= 0;
1401
1402 if ((null_value= (args[0]->null_value || args[2]->null_value ||
1403 re.recompile(args[1]))))
1404 return (String *) 0;
1405
1406 if (!(source= re.convert_if_needed(source, &re.subject_converter)) ||
1407 !(replace= re.convert_if_needed(replace, &re.replace_converter)))
1408 goto err;
1409
1410 src= source->lex_cstring();
1411 rpl= replace->lex_cstring();
1412
1413 str->length(0);
1414 str->set_charset(collation.collation);
1415
1416 for ( ; ; ) // Iterate through all matches
1417 {
1418
1419 if (re.exec(src.str, src.length, startoffset))
1420 goto err;
1421
1422 if (!re.match() || re.subpattern_length(0) == 0)
1423 {
1424 /*
1425 No match or an empty match.
1426 Append the rest of the source string
1427 starting from startoffset until the end of the source.
1428 */
1429 if (str->append(src.str + startoffset, src.length - startoffset, re.library_charset()))
1430 goto err;
1431 return str;
1432 }
1433
1434 /*
1435 Append prefix, the part before the matching pattern.
1436 starting from startoffset until the next match
1437 */
1438 if (str->append(src.str + startoffset, re.subpattern_start(0) - startoffset, re.library_charset()))
1439 goto err;
1440
1441 // Append replacement
1442 if (append_replacement(str, &src, &rpl))
1443 goto err;
1444
1445 // Set the new start point as the end of previous match
1446 startoffset= re.subpattern_end(0);
1447 }
1448 return str;
1449
1450 err:
1451 null_value= true;
1452 return (String *) 0;
1453 }
1454
1455
1456 bool Item_func_regexp_substr::fix_fields(THD *thd, Item **ref)
1457 {
1458 re.set_recursion_limit(thd);
1459 return Item_str_func::fix_fields(thd, ref);
1460 }
1461
1462
1463 bool Item_func_regexp_substr::fix_length_and_dec()
1464 {
1465 if (agg_arg_charsets_for_string_result_with_comparison(collation, args, 2))
1466 return TRUE;
1467 fix_char_length(args[0]->max_char_length());
1468 re.init(collation.collation, 0);
1469 re.fix_owner(this, args[0], args[1]);
1470 return FALSE;
1471 }
1472
1473
1474 String *Item_func_regexp_substr::val_str(String *str)
1475 {
1476 DBUG_ASSERT(fixed == 1);
1477 char buff0[MAX_FIELD_WIDTH];
1478 String tmp0(buff0,sizeof(buff0),&my_charset_bin);
1479 String *source= args[0]->val_str(&tmp0);
1480
1481 if ((null_value= (args[0]->null_value || re.recompile(args[1]))))
1482 return (String *) 0;
1483
1484 if (!(source= re.convert_if_needed(source, &re.subject_converter)))
1485 goto err;
1486
1487 str->length(0);
1488 str->set_charset(collation.collation);
1489
1490 if (re.exec(source->ptr(), source->length(), 0))
1491 goto err;
1492
1493 if (!re.match())
1494 return str;
1495
1496 if (str->append(source->ptr() + re.subpattern_start(0),
1497 re.subpattern_end(0) - re.subpattern_start(0),
1498 re.library_charset()))
1499 goto err;
1500
1501 return str;
1502
1503 err:
1504 null_value= true;
1505 return (String *) 0;
1506 }
1507
1508
1509 /************************************************************************/
1510
1511
1512 String *Item_func_insert::val_str(String *str)
1513 {
1514 DBUG_ASSERT(fixed == 1);
1515 String *res,*res2;
1516 longlong start, length; /* must be longlong to avoid truncation */
1517
1518 null_value=0;
1519 res=args[0]->val_str(str);
1520 res2=args[3]->val_str(&tmp_value);
1521 start= args[1]->val_int() - 1;
1522 length= args[2]->val_int();
1523
1524 if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
1525 args[3]->null_value)
1526 goto null; /* purecov: inspected */
1527
1528 if ((start < 0) || (start > res->length()))
1529 return res; // Wrong param; skip insert
1530 if ((length < 0) || (length > res->length()))
1531 length= res->length();
1532
1533 /*
1534 There is one exception not handled (intentionally) by the character set
1535 aggregation code. If one string is strong side and is binary, and
1536 another one is weak side and is a multi-byte character string,
1537 then we need to operate on the second string in terms on bytes when
1538 calling ::numchars() and ::charpos(), rather than in terms of characters.
1539 Lets substitute its character set to binary.
1540 */
1541 if (collation.collation == &my_charset_bin)
1542 {
1543 res->set_charset(&my_charset_bin);
1544 res2->set_charset(&my_charset_bin);
1545 }
1546
1547 /* start and length are now sufficiently valid to pass to charpos function */
1548 start= res->charpos((int) start);
1549 length= res->charpos((int) length, (uint32) start);
1550
1551 /* Re-testing with corrected params */
1552 if (start + 1 > res->length()) // remember, start = args[1].val_int() - 1
1553 return res; /* purecov: inspected */ // Wrong param; skip insert
1554 if (length > res->length() - start)
1555 length= res->length() - start;
1556
1557 {
1558 THD *thd= current_thd;
1559 if ((ulonglong) (res->length() - length + res2->length()) >
1560 (ulonglong) thd->variables.max_allowed_packet)
1561 {
1562 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
1563 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
1564 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
1565 func_name(), thd->variables.max_allowed_packet);
1566 goto null;
1567 }
1568 }
1569 res=copy_if_not_alloced(str,res,res->length());
1570 res->replace((uint32) start,(uint32) length,*res2);
1571 return res;
1572 null:
1573 null_value=1;
1574 return 0;
1575 }
1576
1577
1578 bool Item_func_insert::fix_length_and_dec()
1579 {
1580 ulonglong char_length;
1581
1582 // Handle character set for args[0] and args[3].
1583 if (agg_arg_charsets_for_string_result(collation, args, 2, 3))
1584 return TRUE;
1585 char_length= ((ulonglong) args[0]->max_char_length() +
1586 (ulonglong) args[3]->max_char_length());
1587 fix_char_length_ulonglong(char_length);
1588 return FALSE;
1589 }
1590
1591
1592 String *Item_str_conv::val_str(String *str)
1593 {
1594 DBUG_ASSERT(fixed == 1);
1595 String *res;
1596 size_t alloced_length, len;
1597
1598 if ((null_value= (!(res= args[0]->val_str(&tmp_value)) ||
1599 str->alloc((alloced_length= res->length() * multiply)))))
1600 return 0;
1601
1602 len= converter(collation.collation, (char*) res->ptr(), res->length(),
1603 (char*) str->ptr(), alloced_length);
1604 DBUG_ASSERT(len <= alloced_length);
1605 str->set_charset(collation.collation);
1606 str->length(len);
1607 return str;
1608 }
1609
1610
1611 bool Item_func_lcase::fix_length_and_dec()
1612 {
1613 if (agg_arg_charsets_for_string_result(collation, args, 1))
1614 return TRUE;
1615 DBUG_ASSERT(collation.collation != NULL);
1616 multiply= collation.collation->casedn_multiply;
1617 converter= collation.collation->cset->casedn;
1618 fix_char_length_ulonglong((ulonglong) args[0]->max_char_length() * multiply);
1619 return FALSE;
1620 }
1621
1622 bool Item_func_ucase::fix_length_and_dec()
1623 {
1624 if (agg_arg_charsets_for_string_result(collation, args, 1))
1625 return TRUE;
1626 DBUG_ASSERT(collation.collation != NULL);
1627 multiply= collation.collation->caseup_multiply;
1628 converter= collation.collation->cset->caseup;
1629 fix_char_length_ulonglong((ulonglong) args[0]->max_char_length() * multiply);
1630 return FALSE;
1631 }
1632
1633
1634 String *Item_func_left::val_str(String *str)
1635 {
1636 DBUG_ASSERT(fixed == 1);
1637 String *res= args[0]->val_str(str);
1638
1639 /* must be longlong to avoid truncation */
1640 longlong length= args[1]->val_int();
1641 uint char_pos;
1642
1643 if ((null_value=(args[0]->null_value || args[1]->null_value)))
1644 return 0;
1645
1646 /* if "unsigned_flag" is set, we have a *huge* positive number. */
1647 if ((length <= 0) && (!args[1]->unsigned_flag))
1648 return make_empty_result();
1649 if ((res->length() <= (ulonglong) length) ||
1650 (res->length() <= (char_pos= res->charpos((int) length))))
1651 return res;
1652
1653 tmp_value.set(*res, 0, char_pos);
1654 return &tmp_value;
1655 }
1656
1657
1658 void Item_str_func::left_right_max_length()
1659 {
1660 uint32 char_length= args[0]->max_char_length();
1661 if (args[1]->const_item() && !args[1]->is_expensive())
1662 {
1663 Repeat_count tmp(args[1]);
1664 set_if_smaller(char_length, (uint) tmp.count());
1665 }
1666 fix_char_length(char_length);
1667 }
1668
1669
1670 bool Item_func_left::fix_length_and_dec()
1671 {
1672 if (agg_arg_charsets_for_string_result(collation, args, 1))
1673 return TRUE;
1674 DBUG_ASSERT(collation.collation != NULL);
1675 left_right_max_length();
1676 return FALSE;
1677 }
1678
1679
1680 String *Item_func_right::val_str(String *str)
1681 {
1682 DBUG_ASSERT(fixed == 1);
1683 String *res= args[0]->val_str(str);
1684 /* must be longlong to avoid truncation */
1685 longlong length= args[1]->val_int();
1686
1687 if ((null_value=(args[0]->null_value || args[1]->null_value)))
1688 return 0; /* purecov: inspected */
1689
1690 /* if "unsigned_flag" is set, we have a *huge* positive number. */
1691 if ((length <= 0) && (!args[1]->unsigned_flag))
1692 return make_empty_result(); /* purecov: inspected */
1693
1694 if (res->length() <= (ulonglong) length)
1695 return res; /* purecov: inspected */
1696
1697 uint start=res->numchars();
1698 if (start <= (uint) length)
1699 return res;
1700 start=res->charpos(start - (uint) length);
1701 tmp_value.set(*res,start,res->length()-start);
1702 return &tmp_value;
1703 }
1704
1705
1706 bool Item_func_right::fix_length_and_dec()
1707 {
1708 if (agg_arg_charsets_for_string_result(collation, args, 1))
1709 return TRUE;
1710 DBUG_ASSERT(collation.collation != NULL);
1711 left_right_max_length();
1712 return FALSE;
1713 }
1714
1715
1716 String *Item_func_substr::val_str(String *str)
1717 {
1718 DBUG_ASSERT(fixed == 1);
1719 String *res = args[0]->val_str(str);
1720 /* must be longlong to avoid truncation */
1721 longlong start= get_position();
1722 /* Assumes that the maximum length of a String is < INT_MAX32. */
1723 /* Limit so that code sees out-of-bound value properly. */
1724 longlong length= arg_count == 3 ? args[2]->val_int() : INT_MAX32;
1725 longlong tmp_length;
1726
1727 if ((null_value=(args[0]->null_value || args[1]->null_value ||
1728 (arg_count == 3 && args[2]->null_value))))
1729 return 0; /* purecov: inspected */
1730
1731 /* Negative or zero length, will return empty string. */
1732 if ((arg_count == 3) && (length <= 0) &&
1733 (length == 0 || !args[2]->unsigned_flag))
1734 return make_empty_result();
1735
1736 /* Assumes that the maximum length of a String is < INT_MAX32. */
1737 /* Set here so that rest of code sees out-of-bound value as such. */
1738 if ((length <= 0) || (length > INT_MAX32))
1739 length= INT_MAX32;
1740
1741 /* if "unsigned_flag" is set, we have a *huge* positive number. */
1742 /* Assumes that the maximum length of a String is < INT_MAX32. */
1743 if ((!args[1]->unsigned_flag && (start < INT_MIN32 || start > INT_MAX32)) ||
1744 (args[1]->unsigned_flag && ((ulonglong) start > INT_MAX32)))
1745 return make_empty_result();
1746
1747 start= ((start < 0) ? res->numchars() + start : start - 1);
1748 start= res->charpos((int) start);
1749 if ((start < 0) || ((uint) start + 1 > res->length()))
1750 return make_empty_result();
1751
1752 length= res->charpos((int) length, (uint32) start);
1753 tmp_length= res->length() - start;
1754 length= MY_MIN(length, tmp_length);
1755
1756 if (!start && (longlong) res->length() == length)
1757 return res;
1758 tmp_value.set(*res, (uint32) start, (uint32) length);
1759 return &tmp_value;
1760 }
1761
1762
1763 bool Item_func_substr::fix_length_and_dec()
1764 {
1765 max_length=args[0]->max_length;
1766
1767 if (agg_arg_charsets_for_string_result(collation, args, 1))
1768 return TRUE;
1769 DBUG_ASSERT(collation.collation != NULL);
1770 if (args[1]->const_item())
1771 {
1772 int32 start= (int32) get_position();
1773 if (args[1]->null_value)
1774 max_length= 0;
1775 else if (start < 0)
1776 max_length= ((uint)(-start) > max_length) ? 0 : (uint)(-start);
1777 else
1778 max_length-= MY_MIN((uint)(start - 1), max_length);
1779 }
1780 if (arg_count == 3 && args[2]->const_item())
1781 {
1782 int32 length= (int32) args[2]->val_int();
1783 if (args[2]->null_value || length <= 0)
1784 max_length=0; /* purecov: inspected */
1785 else
1786 set_if_smaller(max_length,(uint) length);
1787 }
1788 max_length*= collation.collation->mbmaxlen;
1789 return FALSE;
1790 }
1791
1792
1793 bool Item_func_substr_index::fix_length_and_dec()
1794 {
1795 if (agg_arg_charsets_for_string_result_with_comparison(collation, args, 2))
1796 return TRUE;
1797 fix_char_length(args[0]->max_char_length());
1798 return FALSE;
1799 }
1800
1801
1802 String *Item_func_substr_index::val_str(String *str)
1803 {
1804 DBUG_ASSERT(fixed == 1);
1805 char buff[MAX_FIELD_WIDTH];
1806 String tmp(buff,sizeof(buff),system_charset_info);
1807 String *res= args[0]->val_str(&tmp_value);
1808 String *delimiter= args[1]->val_str(&tmp);
1809 int32 count= (int32) args[2]->val_int();
1810 uint offset;
1811
1812 if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
1813 { // string and/or delim are null
1814 null_value=1;
1815 return 0;
1816 }
1817 null_value=0;
1818 uint delimiter_length= delimiter->length();
1819 if (!res->length() || !delimiter_length || !count)
1820 return make_empty_result(); // Wrong parameters
1821
1822 res->set_charset(collation.collation);
1823
1824 #ifdef USE_MB
1825 if (use_mb(res->charset()))
1826 {
1827 const char *ptr= res->ptr();
1828 const char *strend= ptr+res->length();
1829 const char *end= strend-delimiter_length+1;
1830 const char *search= delimiter->ptr();
1831 const char *search_end= search+delimiter_length;
1832 int32 n=0,c=count,pass;
1833 uint32 l;
1834 for (pass=(count>0);pass<2;++pass)
1835 {
1836 while (ptr < end)
1837 {
1838 if (*ptr == *search)
1839 {
1840 char *i,*j;
1841 i=(char*) ptr+1; j=(char*) search+1;
1842 while (j != search_end)
1843 if (*i++ != *j++) goto skip;
1844 if (pass==0) ++n;
1845 else if (!--c) break;
1846 ptr+= delimiter_length;
1847 continue;
1848 }
1849 skip:
1850 if ((l=my_ismbchar(res->charset(), ptr,strend))) ptr+=l;
1851 else ++ptr;
1852 } /* either not found or got total number when count<0 */
1853 if (pass == 0) /* count<0 */
1854 {
1855 c+=n+1;
1856 if (c<=0)
1857 {
1858 str->copy(res->ptr(), res->length(), collation.collation);
1859 return str; // not found, return the original string
1860 }
1861 ptr=res->ptr();
1862 }
1863 else
1864 {
1865 if (c)
1866 {
1867 str->copy(res->ptr(), res->length(), collation.collation);
1868 return str; // not found, return the original string
1869 }
1870 if (count>0) /* return left part */
1871 {
1872 str->copy(res->ptr(), (uint32) (ptr-res->ptr()), collation.collation);
1873 return str;
1874 }
1875 else /* return right part */
1876 {
1877 ptr+= delimiter_length;
1878 str->copy(res->ptr() + (ptr-res->ptr()), (uint32) (strend - ptr),
1879 collation.collation);
1880 return str;
1881 }
1882 }
1883 }
1884 }
1885 else
1886 #endif /* USE_MB */
1887 {
1888 if (count > 0)
1889 { // start counting from the beginning
1890 for (offset=0; ; offset+= delimiter_length)
1891 {
1892 if ((int) (offset= res->strstr(*delimiter, offset)) < 0)
1893 {
1894 str->copy(res->ptr(), res->length(), collation.collation);
1895 return str; // not found, return the original string
1896 }
1897 if (!--count)
1898 {
1899 str->copy(res->ptr(), offset, collation.collation);
1900 return str;
1901 }
1902 }
1903 }
1904 else
1905 {
1906 /*
1907 Negative index, start counting at the end
1908 */
1909 for (offset=res->length(); offset ;)
1910 {
1911 /*
1912 this call will result in finding the position pointing to one
1913 address space less than where the found substring is located
1914 in res
1915 */
1916 if ((int) (offset= res->strrstr(*delimiter, offset)) < 0)
1917 {
1918 str->copy(res->ptr(), res->length(), collation.collation);
1919 return str; // not found, return the original string
1920 }
1921 /*
1922 At this point, we've searched for the substring
1923 the number of times as supplied by the index value
1924 */
1925 if (!++count)
1926 {
1927 offset+= delimiter_length;
1928 str->copy(res->ptr() + offset, res->length() - offset,
1929 collation.collation);
1930 return str;
1931 }
1932 }
1933 if (count)
1934 {
1935 str->copy(res->ptr(), res->length(), collation.collation);
1936 return str; // not found, return the original string
1937 }
1938 }
1939 }
1940 DBUG_ASSERT(0);
1941 return NULL;
1942 }
1943
1944 /*
1945 ** The trim functions are extension to ANSI SQL because they trim substrings
1946 ** They ltrim() and rtrim() functions are optimized for 1 byte strings
1947 ** They also return the original string if possible, else they return
1948 ** a substring that points at the original string.
1949 */
1950
1951
1952 String *Item_func_ltrim::val_str(String *str)
1953 {
1954 DBUG_ASSERT(fixed == 1);
1955 char buff[MAX_FIELD_WIDTH], *ptr, *end;
1956 String tmp(buff,sizeof(buff),system_charset_info);
1957 String *res, *remove_str;
1958 uint UNINIT_VAR(remove_length);
1959
1960 res= args[0]->val_str(str);
1961 if ((null_value=args[0]->null_value))
1962 return 0;
1963 remove_str= &remove; /* Default value. */
1964 if (arg_count == 2)
1965 {
1966 remove_str= args[1]->val_str(&tmp);
1967 if ((null_value= args[1]->null_value))
1968 return 0;
1969 }
1970
1971 if ((remove_length= remove_str->length()) == 0 ||
1972 remove_length > res->length())
1973 return non_trimmed_value(res);
1974
1975 ptr= (char*) res->ptr();
1976 end= ptr+res->length();
1977 if (remove_length == 1)
1978 {
1979 char chr=(*remove_str)[0];
1980 while (ptr != end && *ptr == chr)
1981 ptr++;
1982 }
1983 else
1984 {
1985 const char *r_ptr=remove_str->ptr();
1986 end-=remove_length;
1987 while (ptr <= end && !memcmp(ptr, r_ptr, remove_length))
1988 ptr+=remove_length;
1989 end+=remove_length;
1990 }
1991 if (ptr == res->ptr())
1992 return non_trimmed_value(res);
1993 return trimmed_value(res, (uint32) (ptr - res->ptr()), (uint32) (end - ptr));
1994 }
1995
1996
1997 String *Item_func_rtrim::val_str(String *str)
1998 {
1999 DBUG_ASSERT(fixed == 1);
2000 char buff[MAX_FIELD_WIDTH], *ptr, *end;
2001 String tmp(buff, sizeof(buff), system_charset_info);
2002 String *res, *remove_str;
2003 uint UNINIT_VAR(remove_length);
2004
2005 res= args[0]->val_str(str);
2006 if ((null_value=args[0]->null_value))
2007 return 0;
2008 remove_str= &remove; /* Default value. */
2009 if (arg_count == 2)
2010 {
2011 remove_str= args[1]->val_str(&tmp);
2012 if ((null_value= args[1]->null_value))
2013 return 0;
2014 }
2015
2016 if ((remove_length= remove_str->length()) == 0 ||
2017 remove_length > res->length())
2018 return non_trimmed_value(res);
2019
2020 ptr= (char*) res->ptr();
2021 end= ptr+res->length();
2022 #ifdef USE_MB
2023 char *p=ptr;
2024 uint32 l;
2025 #endif
2026 if (remove_length == 1)
2027 {
2028 char chr=(*remove_str)[0];
2029 #ifdef USE_MB
2030 if (use_mb(collation.collation))
2031 {
2032 while (ptr < end)
2033 {
2034 if ((l= my_ismbchar(collation.collation, ptr, end))) ptr+= l, p=ptr;
2035 else ++ptr;
2036 }
2037 ptr=p;
2038 }
2039 #endif
2040 while (ptr != end && end[-1] == chr)
2041 end--;
2042 }
2043 else
2044 {
2045 const char *r_ptr=remove_str->ptr();
2046 #ifdef USE_MB
2047 if (use_mb(collation.collation))
2048 {
2049 loop:
2050 while (ptr + remove_length < end)
2051 {
2052 if ((l= my_ismbchar(collation.collation, ptr, end))) ptr+= l;
2053 else ++ptr;
2054 }
2055 if (ptr + remove_length == end && !memcmp(ptr,r_ptr,remove_length))
2056 {
2057 end-=remove_length;
2058 ptr=p;
2059 goto loop;
2060 }
2061 }
2062 else
2063 #endif /* USE_MB */
2064 {
2065 while (ptr + remove_length <= end &&
2066 !memcmp(end-remove_length, r_ptr, remove_length))
2067 end-=remove_length;
2068 }
2069 }
2070 if (end == res->ptr()+res->length())
2071 return non_trimmed_value(res);
2072 return trimmed_value(res, 0, (uint32) (end - res->ptr()));
2073 }
2074
2075
2076 String *Item_func_trim::val_str(String *str)
2077 {
2078 DBUG_ASSERT(fixed == 1);
2079 char buff[MAX_FIELD_WIDTH], *ptr, *end;
2080 const char *r_ptr;
2081 String tmp(buff, sizeof(buff), system_charset_info);
2082 String *res, *remove_str;
2083 uint UNINIT_VAR(remove_length);
2084
2085 res= args[0]->val_str(str);
2086 if ((null_value=args[0]->null_value))
2087 return 0;
2088 remove_str= &remove; /* Default value. */
2089 if (arg_count == 2)
2090 {
2091 remove_str= args[1]->val_str(&tmp);
2092 if ((null_value= args[1]->null_value))
2093 return 0;
2094 }
2095
2096 if ((remove_length= remove_str->length()) == 0 ||
2097 remove_length > res->length())
2098 return non_trimmed_value(res);
2099
2100 ptr= (char*) res->ptr();
2101 end= ptr+res->length();
2102 r_ptr= remove_str->ptr();
2103 while (ptr+remove_length <= end && !memcmp(ptr,r_ptr,remove_length))
2104 ptr+=remove_length;
2105 #ifdef USE_MB
2106 if (use_mb(collation.collation))
2107 {
2108 char *p=ptr;
2109 uint32 l;
2110 loop:
2111 while (ptr + remove_length < end)
2112 {
2113 if ((l= my_ismbchar(collation.collation, ptr, end)))
2114 ptr+= l;
2115 else
2116 ++ptr;
2117 }
2118 if (ptr + remove_length == end && !memcmp(ptr,r_ptr,remove_length))
2119 {
2120 end-=remove_length;
2121 ptr=p;
2122 goto loop;
2123 }
2124 ptr=p;
2125 }
2126 else
2127 #endif /* USE_MB */
2128 {
2129 while (ptr + remove_length <= end &&
2130 !memcmp(end-remove_length,r_ptr,remove_length))
2131 end-=remove_length;
2132 }
2133 if (ptr == res->ptr() && end == ptr+res->length())
2134 return non_trimmed_value(res);
2135 return trimmed_value(res, (uint32) (ptr - res->ptr()), (uint32) (end - ptr));
2136 }
2137
2138 bool Item_func_trim::fix_length_and_dec()
2139 {
2140 if (arg_count == 1)
2141 {
2142 if (agg_arg_charsets_for_string_result(collation, args, 1))
2143 return TRUE;
2144 DBUG_ASSERT(collation.collation != NULL);
2145 remove.set_charset(collation.collation);
2146 remove.set_ascii(" ",1);
2147 }
2148 else
2149 {
2150 // Handle character set for args[1] and args[0].
2151 // Note that we pass args[1] as the first item, and args[0] as the second.
2152 if (agg_arg_charsets_for_string_result_with_comparison(collation,
2153 &args[1], 2, -1))
2154 return TRUE;
2155 }
2156 fix_char_length(args[0]->max_char_length());
2157 return FALSE;
2158 }
2159
2160 void Item_func_trim::print(String *str, enum_query_type query_type)
2161 {
2162 if (arg_count == 1)
2163 {
2164 Item_func::print(str, query_type);
2165 return;
2166 }
2167 str->append(Item_func_trim::func_name());
2168 str->append(func_name_ext());
2169 str->append('(');
2170 str->append(mode_name());
2171 str->append(' ');
2172 args[1]->print(str, query_type);
2173 str->append(STRING_WITH_LEN(" from "));
2174 args[0]->print(str, query_type);
2175 str->append(')');
2176 }
2177
2178
2179 /*
2180 RTRIM(expr)
2181 TRIM(TRAILING ' ' FROM expr)
2182 remove argument's soft dependency on PAD_CHAR_TO_FULL_LENGTH:
2183 */
2184 Sql_mode_dependency Item_func_trim::value_depends_on_sql_mode() const
2185 {
2186 DBUG_ASSERT(fixed);
2187 if (arg_count == 1) // RTRIM(expr)
2188 return (args[0]->value_depends_on_sql_mode() &
2189 Sql_mode_dependency(~0, ~MODE_PAD_CHAR_TO_FULL_LENGTH)).
2190 soft_to_hard();
2191 // TRIM(... FROM expr)
2192 DBUG_ASSERT(arg_count == 2);
2193 if (!args[1]->value_depends_on_sql_mode_const_item())
2194 return Item_func::value_depends_on_sql_mode();
2195 StringBuffer<64> trimstrbuf;
2196 String *trimstr= args[1]->val_str(&trimstrbuf);
2197 if (!trimstr)
2198 return Sql_mode_dependency(); // will return NULL
2199 if (trimstr->length() == 0)
2200 return Item_func::value_depends_on_sql_mode(); // will trim nothing
2201 if (trimstr->lengthsp() != 0)
2202 return Item_func::value_depends_on_sql_mode(); // will trim not only spaces
2203 if (trimstr->length() > trimstr->charset()->mbminlen ||
2204 trimstr->numchars() > 1)
2205 return Item_func::value_depends_on_sql_mode(); // more than one space
2206 // TRIM(TRAILING ' ' FROM expr)
2207 return ((args[0]->value_depends_on_sql_mode() |
2208 args[1]->value_depends_on_sql_mode()) &
2209 Sql_mode_dependency(~0, ~MODE_PAD_CHAR_TO_FULL_LENGTH)).
2210 soft_to_hard();
2211 }
2212
2213
2214 /* Item_func_password */
2215
2216 bool Item_func_password::fix_fields(THD *thd, Item **ref)
2217 {
2218 if (deflt)
2219 alg= (thd->variables.old_passwords ? OLD : NEW);
2220 return Item_str_ascii_func::fix_fields(thd, ref);
2221 }
2222
2223 String *Item_func_password::val_str_ascii(String *str)
2224 {
2225 DBUG_ASSERT(fixed == 1);
2226 String *res= args[0]->val_str(str);
2227 switch (alg){
2228 case NEW:
2229 if (args[0]->null_value || res->length() == 0)
2230 return make_empty_result();
2231 my_make_scrambled_password(tmp_value, res->ptr(), res->length());
2232 str->set(tmp_value, SCRAMBLED_PASSWORD_CHAR_LENGTH, &my_charset_latin1);
2233 break;
2234 case OLD:
2235 if ((null_value=args[0]->null_value))
2236 return 0;
2237 if (res->length() == 0)
2238 return make_empty_result();
2239 my_make_scrambled_password_323(tmp_value, res->ptr(), res->length());
2240 str->set(tmp_value, SCRAMBLED_PASSWORD_CHAR_LENGTH_323, &my_charset_latin1);
2241 break;
2242 default:
2243 DBUG_ASSERT(0);
2244 }
2245 return str;
2246 }
2247
2248 char *Item_func_password::alloc(THD *thd, const char *password,
2249 size_t pass_len, enum PW_Alg al)
2250 {
2251 char *buff= (char *) thd->alloc((al==NEW)?
2252 SCRAMBLED_PASSWORD_CHAR_LENGTH + 1:
2253 SCRAMBLED_PASSWORD_CHAR_LENGTH_323 + 1);
2254 if (!buff)
2255 return NULL;
2256
2257 switch (al) {
2258 case NEW:
2259 my_make_scrambled_password(buff, password, pass_len);
2260 break;
2261 case OLD:
2262 my_make_scrambled_password_323(buff, password, pass_len);
2263 break;
2264 default:
2265 DBUG_ASSERT(0);
2266 }
2267 return buff;
2268 }
2269
2270
2271
2272 #define bin_to_ascii(c) ((c)>=38?((c)-38+'a'):(c)>=12?((c)-12+'A'):(c)+'.')
2273
2274 String *Item_func_encrypt::val_str(String *str)
2275 {
2276 DBUG_ASSERT(fixed == 1);
2277
2278 #ifdef HAVE_CRYPT
2279 String *res =args[0]->val_str(str);
2280
2281 char salt[3],*salt_ptr;
2282 if ((null_value=args[0]->null_value))
2283 return 0;
2284 if (res->length() == 0)
2285 return make_empty_result();
2286 if (arg_count == 1)
2287 { // generate random salt
2288 time_t timestamp=current_thd->query_start();
2289 salt[0] = bin_to_ascii( (ulong) timestamp & 0x3f);
2290 salt[1] = bin_to_ascii(( (ulong) timestamp >> 5) & 0x3f);
2291 salt[2] = 0;
2292 salt_ptr=salt;
2293 }
2294 else
2295 { // obtain salt from the first two bytes
2296 String *salt_str=args[1]->val_str(&tmp_value);
2297 if ((null_value= (args[1]->null_value || salt_str->length() < 2)))
2298 return 0;
2299 salt_ptr= salt_str->c_ptr_safe();
2300 }
2301 mysql_mutex_lock(&LOCK_crypt);
2302 char *tmp= crypt(res->c_ptr_safe(),salt_ptr);
2303 if (!tmp)
2304 {
2305 mysql_mutex_unlock(&LOCK_crypt);
2306 null_value= 1;
2307 return 0;
2308 }
2309 str->set(tmp, (uint) strlen(tmp), &my_charset_bin);
2310 str->copy();
2311 mysql_mutex_unlock(&LOCK_crypt);
2312 return str;
2313 #else
2314 null_value=1;
2315 return 0;
2316 #endif /* HAVE_CRYPT */
2317 }
2318
2319 bool Item_func_encode::seed()
2320 {
2321 char buf[80];
2322 ulong rand_nr[2];
2323 String *key, tmp(buf, sizeof(buf), system_charset_info);
2324
2325 if (!(key= args[1]->val_str(&tmp)))
2326 return TRUE;
2327
2328 hash_password(rand_nr, key->ptr(), key->length());
2329 sql_crypt.init(rand_nr);
2330
2331 return FALSE;
2332 }
2333
2334 bool Item_func_encode::fix_length_and_dec()
2335 {
2336 max_length=args[0]->max_length;
2337 maybe_null=args[0]->maybe_null || args[1]->maybe_null;
2338 collation.set(&my_charset_bin);
2339 /* Precompute the seed state if the item is constant. */
2340 seeded= args[1]->const_item() &&
2341 (args[1]->result_type() == STRING_RESULT) && !seed();
2342 return FALSE;
2343 }
2344
2345 String *Item_func_encode::val_str(String *str)
2346 {
2347 String *res;
2348 DBUG_ASSERT(fixed == 1);
2349
2350 if (!(res=args[0]->val_str(str)))
2351 {
2352 null_value= 1;
2353 return NULL;
2354 }
2355
2356 if (!seeded && seed())
2357 {
2358 null_value= 1;
2359 return NULL;
2360 }
2361
2362 null_value= 0;
2363 res= copy_if_not_alloced(str, res, res->length());
2364 crypto_transform(res);
2365 sql_crypt.reinit();
2366
2367 return res;
2368 }
2369
2370 void Item_func_encode::crypto_transform(String *res)
2371 {
2372 sql_crypt.encode((char*) res->ptr(),res->length());
2373 res->set_charset(&my_charset_bin);
2374 }
2375
2376 void Item_func_decode::crypto_transform(String *res)
2377 {
2378 sql_crypt.decode((char*) res->ptr(),res->length());
2379 }
2380
2381
2382 String *Item_func_database::val_str(String *str)
2383 {
2384 DBUG_ASSERT(fixed == 1);
2385 THD *thd= current_thd;
2386 if (thd->db.str == NULL)
2387 {
2388 null_value= 1;
2389 return 0;
2390 }
2391 else
2392 str->copy(thd->db.str, thd->db.length, system_charset_info);
2393 null_value= 0;
2394 return str;
2395 }
2396
2397
2398 String *Item_func_sqlerrm::val_str(String *str)
2399 {
2400 DBUG_ASSERT(fixed);
2401 DBUG_ASSERT(!null_value);
2402 Diagnostics_area::Sql_condition_iterator it=
2403 current_thd->get_stmt_da()->sql_conditions();
2404 const Sql_condition *err;
2405 if ((err= it++))
2406 {
2407 str->copy(err->get_message_text(), err->get_message_octet_length(),
2408 system_charset_info);
2409 return str;
2410 }
2411 str->copy(STRING_WITH_LEN("normal, successful completion"),
2412 system_charset_info);
2413 return str;
2414 }
2415
2416
2417 /**
2418 @note USER() is replicated correctly if binlog_format=ROW or (as of
2419 BUG#28086) binlog_format=MIXED, but is incorrectly replicated to ''
2420 if binlog_format=STATEMENT.
2421 */
2422 bool Item_func_user::init(const char *user, const char *host)
2423 {
2424 DBUG_ASSERT(fixed == 1);
2425
2426 // For system threads (e.g. replication SQL thread) user may be empty
2427 if (user)
2428 {
2429 CHARSET_INFO *cs= str_value.charset();
2430 size_t res_length= (strlen(user)+strlen(host)+2) * cs->mbmaxlen;
2431
2432 if (str_value.alloc((uint) res_length))
2433 {
2434 null_value=1;
2435 return TRUE;
2436 }
2437
2438 res_length=cs->cset->snprintf(cs, (char*)str_value.ptr(), (uint) res_length,
2439 "%s@%s", user, host);
2440 str_value.length((uint) res_length);
2441 str_value.mark_as_const();
2442 }
2443 return FALSE;
2444 }
2445
2446
2447 Item *Item_func_sysconst::safe_charset_converter(THD *thd, CHARSET_INFO *tocs)
2448 {
2449 /*
2450 During view or prepared statement creation, the item should not
2451 make use of const_charset_converter as it would imply substitution
2452 with constant items which is not correct. Functions can have different
2453 values during view creation and view execution based on context.
2454
2455 Return the identical item during view creation and prepare.
2456 */
2457 if (thd->lex->is_ps_or_view_context_analysis())
2458 return this;
2459 return const_charset_converter(thd, tocs, true, fully_qualified_func_name());
2460 }
2461
2462 bool Item_func_sysconst::const_item() const
2463 {
2464 if (current_thd->lex->is_ps_or_view_context_analysis())
2465 return false;
2466 return true;
2467 }
2468
2469 bool Item_func_user::fix_fields(THD *thd, Item **ref)
2470 {
2471 return (Item_func_sysconst::fix_fields(thd, ref) ||
2472 init(thd->main_security_ctx.user,
2473 thd->main_security_ctx.host_or_ip));
2474 }
2475
2476
2477 bool Item_func_current_user::fix_fields(THD *thd, Item **ref)
2478 {
2479 if (Item_func_sysconst::fix_fields(thd, ref))
2480 return TRUE;
2481
2482 Security_context *ctx= context && context->security_ctx
2483 ? context->security_ctx : thd->security_ctx;
2484 return init(ctx->priv_user, ctx->priv_host);
2485 }
2486
2487 bool Item_func_current_role::fix_fields(THD *thd, Item **ref)
2488 {
2489 if (Item_func_sysconst::fix_fields(thd, ref))
2490 return 1;
2491
2492 Security_context *ctx= context && context->security_ctx
2493 ? context->security_ctx : thd->security_ctx;
2494 if (ctx->priv_role[0])
2495 {
2496 if (str_value.copy(ctx->priv_role, strlen(ctx->priv_role),
2497 system_charset_info))
2498 return 1;
2499 str_value.mark_as_const();
2500 null_value= maybe_null= 0;
2501 return 0;
2502 }
2503 null_value= maybe_null= 1;
2504 return 0;
2505 }
2506
2507 bool Item_func_soundex::fix_length_and_dec()
2508 {
2509 uint32 char_length= args[0]->max_char_length();
2510 if (agg_arg_charsets_for_string_result(collation, args, 1))
2511 return TRUE;
2512 DBUG_ASSERT(collation.collation != NULL);
2513 set_if_bigger(char_length, 4);
2514 fix_char_length(char_length);
2515 return FALSE;
2516 }
2517
2518
2519 /**
2520 If alpha, map input letter to soundex code.
2521 If not alpha and remove_garbage is set then skip to next char
2522 else return 0
2523 */
2524
2525 static int soundex_toupper(int ch)
2526 {
2527 return (ch >= 'a' && ch <= 'z') ? ch - 'a' + 'A' : ch;
2528 }
2529
2530
2531 static char get_scode(int wc)
2532 {
2533 int ch= soundex_toupper(wc);
2534 if (ch < 'A' || ch > 'Z')
2535 {
2536 // Thread extended alfa (country spec)
2537 return '0'; // as vokal
2538 }
2539 return(soundex_map[ch-'A']);
2540 }
2541
2542
2543 static bool my_uni_isalpha(int wc)
2544 {
2545 /*
2546 Return true for all Basic Latin letters: a..z A..Z.
2547 Return true for all Unicode characters with code higher than U+00C0:
2548 - characters between 'z' and U+00C0 are controls and punctuations.
2549 - "U+00C0 LATIN CAPITAL LETTER A WITH GRAVE" is the first letter after 'z'.
2550 */
2551 return (wc >= 'a' && wc <= 'z') ||
2552 (wc >= 'A' && wc <= 'Z') ||
2553 (wc >= 0xC0);
2554 }
2555
2556
2557 String *Item_func_soundex::val_str(String *str)
2558 {
2559 DBUG_ASSERT(fixed == 1);
2560 String *res= args[0]->val_str(&tmp_value);
2561 char last_ch,ch;
2562 CHARSET_INFO *cs= collation.collation;
2563 my_wc_t wc;
2564 uint nchars;
2565 int rc;
2566
2567 if ((null_value= args[0]->null_value))
2568 return 0; /* purecov: inspected */
2569
2570 if (str->alloc(MY_MAX(res->length(), 4 * cs->mbminlen)))
2571 return &tmp_value; /* purecov: inspected */
2572 str->set_charset(collation.collation);
2573 char *to= (char *) str->ptr();
2574 char *to_end= to + str->alloced_length();
2575 char *from= (char *) res->ptr(), *end= from + res->length();
2576
2577 for ( ; ; ) /* Skip pre-space */
2578 {
2579 if ((rc= cs->cset->mb_wc(cs, &wc, (uchar*) from, (uchar*) end)) <= 0)
2580 return make_empty_result(); /* EOL or invalid byte sequence */
2581
2582 if (rc == 1 && cs->ctype)
2583 {
2584 /* Single byte letter found */
2585 if (my_isalpha(cs, *from))
2586 {
2587 last_ch= get_scode(*from); // Code of the first letter
2588 *to++= soundex_toupper(*from++); // Copy first letter
2589 break;
2590 }
2591 from++;
2592 }
2593 else
2594 {
2595 from+= rc;
2596 if (my_uni_isalpha(wc))
2597 {
2598 /* Multibyte letter found */
2599 wc= soundex_toupper(wc);
2600 last_ch= get_scode(wc); // Code of the first letter
2601 if ((rc= cs->cset->wc_mb(cs, wc, (uchar*) to, (uchar*) to_end)) <= 0)
2602 {
2603 /* Extra safety - should not really happen */
2604 DBUG_ASSERT(false);
2605 return make_empty_result();
2606 }
2607 to+= rc;
2608 break;
2609 }
2610 }
2611 }
2612
2613 /*
2614 last_ch is now set to the first 'double-letter' check.
2615 loop on input letters until end of input
2616 */
2617 for (nchars= 1 ; ; )
2618 {
2619 if ((rc= cs->cset->mb_wc(cs, &wc, (uchar*) from, (uchar*) end)) <= 0)
2620 break; /* EOL or invalid byte sequence */
2621
2622 if (rc == 1 && cs->ctype)
2623 {
2624 if (!my_isalpha(cs, *from++))
2625 continue;
2626 }
2627 else
2628 {
2629 from+= rc;
2630 if (!my_uni_isalpha(wc))
2631 continue;
2632 }
2633
2634 ch= get_scode(wc);
2635 if ((ch != '0') && (ch != last_ch)) // if not skipped or double
2636 {
2637 // letter, copy to output
2638 if ((rc= cs->cset->wc_mb(cs, (my_wc_t) ch,
2639 (uchar*) to, (uchar*) to_end)) <= 0)
2640 {
2641 // Extra safety - should not really happen
2642 DBUG_ASSERT(false);
2643 break;
2644 }
2645 to+= rc;
2646 nchars++;
2647 last_ch= ch; // save code of last input letter
2648 } // for next double-letter check
2649 }
2650
2651 /* Pad up to 4 characters with DIGIT ZERO, if the string is shorter */
2652 if (nchars < 4)
2653 {
2654 uint nbytes= (4 - nchars) * cs->mbminlen;
2655 cs->cset->fill(cs, to, nbytes, '0');
2656 to+= nbytes;
2657 }
2658
2659 str->length((uint) (to - str->ptr()));
2660 return str;
2661 }
2662
2663
2664 /**
2665 Change a number to format '3,333,333,333.000'.
2666
2667 This should be 'internationalized' sometimes.
2668 */
2669
2670 const int FORMAT_MAX_DECIMALS= 30;
2671
2672
2673 bool Item_func_format::fix_length_and_dec()
2674 {
2675 uint32 char_length= args[0]->max_char_length();
2676 uint32 max_sep_count= (char_length / 3) + (decimals ? 1 : 0) + /*sign*/1;
2677 collation.set(default_charset());
2678 fix_char_length(char_length + max_sep_count + decimals);
2679 if (arg_count == 3)
2680 locale= args[2]->basic_const_item() ? args[2]->locale_from_val_str() : NULL;
2681 else
2682 locale= &my_locale_en_US; /* Two arguments */
2683 return FALSE;
2684 }
2685
2686
2687 /**
2688 @todo
2689 This needs to be fixed for multi-byte character set where numbers
2690 are stored in more than one byte
2691 */
2692
2693 String *Item_func_format::val_str_ascii(String *str)
2694 {
2695 uint32 str_length;
2696 /* Number of decimal digits */
2697 int dec;
2698 /* Number of characters used to represent the decimals, including '.' */
2699 uint32 dec_length;
2700 const MY_LOCALE *lc;
2701 DBUG_ASSERT(fixed == 1);
2702
2703 dec= (int) args[1]->val_int();
2704 if (args[1]->null_value)
2705 {
2706 null_value=1;
2707 return NULL;
2708 }
2709
2710 lc= locale ? locale : args[2]->locale_from_val_str();
2711
2712 dec= set_zone(dec, 0, FORMAT_MAX_DECIMALS);
2713 dec_length= dec ? dec+1 : 0;
2714 null_value=0;
2715
2716 if (args[0]->result_type() == DECIMAL_RESULT ||
2717 args[0]->result_type() == INT_RESULT)
2718 {
2719 my_decimal dec_val, rnd_dec, *res;
2720 res= args[0]->val_decimal(&dec_val);
2721 if ((null_value=args[0]->null_value))
2722 return 0; /* purecov: inspected */
2723 my_decimal_round(E_DEC_FATAL_ERROR, res, dec, false, &rnd_dec);
2724 my_decimal2string(E_DEC_FATAL_ERROR, &rnd_dec, 0, 0, 0, str);
2725 str_length= str->length();
2726 }
2727 else
2728 {
2729 double nr= args[0]->val_real();
2730 if ((null_value=args[0]->null_value))
2731 return 0; /* purecov: inspected */
2732 nr= my_double_round(nr, (longlong) dec, FALSE, FALSE);
2733 str->set_real(nr, dec, &my_charset_numeric);
2734 if (!std::isfinite(nr))
2735 return str;
2736 str_length=str->length();
2737 }
2738 /* We need this test to handle 'nan' and short values */
2739 if (lc->grouping[0] > 0 &&
2740 str_length >= dec_length + 1 + lc->grouping[0])
2741 {
2742 /* We need space for ',' between each group of digits as well. */
2743 char buf[2 * FLOATING_POINT_BUFFER];
2744 int count;
2745 const char *grouping= lc->grouping;
2746 char sign_length= *str->ptr() == '-' ? 1 : 0;
2747 const char *src= str->ptr() + str_length - dec_length - 1;
2748 const char *src_begin= str->ptr() + sign_length;
2749 char *dst= buf + sizeof(buf);
2750
2751 /* Put the fractional part */
2752 if (dec)
2753 {
2754 dst-= (dec + 1);
2755 *dst= lc->decimal_point;
2756 memcpy(dst + 1, src + 2, dec);
2757 }
2758
2759 /* Put the integer part with grouping */
2760 for (count= *grouping; src >= src_begin; count--)
2761 {
2762 /*
2763 When *grouping==0x80 (which means "end of grouping")
2764 count will be initialized to -1 and
2765 we'll never get into this "if" anymore.
2766 */
2767 if (count == 0)
2768 {
2769 *--dst= lc->thousand_sep;
2770 if (grouping[1])
2771 grouping++;
2772 count= *grouping;
2773 }
2774 DBUG_ASSERT(dst > buf);
2775 *--dst= *src--;
2776 }
2777
2778 if (sign_length) /* Put '-' */
2779 *--dst= *str->ptr();
2780
2781 /* Put the rest of the integer part without grouping */
2782 str->copy(dst, buf + sizeof(buf) - dst, &my_charset_latin1);
2783 }
2784 else if (dec_length && lc->decimal_point != '.')
2785 {
2786 /*
2787 For short values without thousands (<1000)
2788 replace decimal point to localized value.
2789 */
2790 DBUG_ASSERT(dec_length <= str_length);
2791 ((char*) str->ptr())[str_length - dec_length]= lc->decimal_point;
2792 }
2793 return str;
2794 }
2795
2796
2797 bool Item_func_elt::fix_length_and_dec()
2798 {
2799 uint32 char_length= 0;
2800 decimals=0;
2801
2802 if (agg_arg_charsets_for_string_result(collation, args + 1, arg_count - 1))
2803 return TRUE;
2804
2805 for (uint i= 1 ; i < arg_count ; i++)
2806 {
2807 set_if_bigger(char_length, args[i]->max_char_length());
2808 set_if_bigger(decimals,args[i]->decimals);
2809 }
2810 fix_char_length(char_length);
2811 maybe_null=1; // NULL if wrong first arg
2812 return FALSE;
2813 }
2814
2815
2816 double Item_func_elt::val_real()
2817 {
2818 DBUG_ASSERT(fixed == 1);
2819 uint tmp;
2820 null_value=1;
2821 if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
2822 return 0.0;
2823 double result= args[tmp]->val_real();
2824 null_value= args[tmp]->null_value;
2825 return result;
2826 }
2827
2828
2829 longlong Item_func_elt::val_int()
2830 {
2831 DBUG_ASSERT(fixed == 1);
2832 uint tmp;
2833 null_value=1;
2834 if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
2835 return 0;
2836
2837 longlong result= args[tmp]->val_int();
2838 null_value= args[tmp]->null_value;
2839 return result;
2840 }
2841
2842
2843 String *Item_func_elt::val_str(String *str)
2844 {
2845 DBUG_ASSERT(fixed == 1);
2846 uint tmp;
2847 null_value=1;
2848 if ((tmp=(uint) args[0]->val_int()) == 0 || tmp >= arg_count)
2849 return NULL;
2850
2851 String *result= args[tmp]->val_str(str);
2852 if (result)
2853 result->set_charset(collation.collation);
2854 null_value= args[tmp]->null_value;
2855 return result;
2856 }
2857
2858
2859 bool Item_func_make_set::fix_length_and_dec()
2860 {
2861 uint32 char_length= arg_count - 2; /* Separators */
2862
2863 if (agg_arg_charsets_for_string_result(collation, args + 1, arg_count - 1))
2864 return TRUE;
2865
2866 for (uint i=1 ; i < arg_count ; i++)
2867 char_length+= args[i]->max_char_length();
2868 fix_char_length(char_length);
2869 return FALSE;
2870 }
2871
2872
2873 String *Item_func_make_set::val_str(String *str)
2874 {
2875 DBUG_ASSERT(fixed == 1);
2876 ulonglong bits;
2877 bool first_found=0;
2878 Item **ptr=args+1;
2879 String *result= make_empty_result();
2880
2881 bits=args[0]->val_int();
2882 if ((null_value=args[0]->null_value))
2883 return NULL;
2884
2885 if (arg_count < 65)
2886 bits &= ((ulonglong) 1 << (arg_count-1))-1;
2887
2888 for (; bits; bits >>= 1, ptr++)
2889 {
2890 if (bits & 1)
2891 {
2892 String *res= (*ptr)->val_str(str);
2893 if (res) // Skip nulls
2894 {
2895 if (!first_found)
2896 { // First argument
2897 first_found=1;
2898 if (res != str)
2899 result=res; // Use original string
2900 else
2901 {
2902 if (tmp_str.copy(*res)) // Don't use 'str'
2903 return make_empty_result();
2904 result= &tmp_str;
2905 }
2906 }
2907 else
2908 {
2909 if (result != &tmp_str)
2910 { // Copy data to tmp_str
2911 if (tmp_str.alloc(result->length()+res->length()+1) ||
2912 tmp_str.copy(*result))
2913 return make_empty_result();
2914 result= &tmp_str;
2915 }
2916 if (tmp_str.append(STRING_WITH_LEN(","), &my_charset_bin) || tmp_str.append(*res))
2917 return make_empty_result();
2918 }
2919 }
2920 }
2921 }
2922 return result;
2923 }
2924
2925
2926 void Item_func_char::print(String *str, enum_query_type query_type)
2927 {
2928 str->append(Item_func_char::func_name());
2929 str->append('(');
2930 print_args(str, 0, query_type);
2931 if (collation.collation != &my_charset_bin)
2932 {
2933 str->append(STRING_WITH_LEN(" using "));
2934 str->append(collation.collation->csname);
2935 }
2936 str->append(')');
2937 }
2938
2939
2940 String *Item_func_char::val_str(String *str)
2941 {
2942 DBUG_ASSERT(fixed == 1);
2943 str->length(0);
2944 str->set_charset(collation.collation);
2945 for (uint i=0 ; i < arg_count ; i++)
2946 {
2947 int32 num=(int32) args[i]->val_int();
2948 if (!args[i]->null_value)
2949 append_char(str, num);
2950 }
2951 str->realloc(str->length()); // Add end 0 (for Purify)
2952 return check_well_formed_result(str);
2953 }
2954
2955
2956 void Item_func_char::append_char(String *str, int32 num)
2957 {
2958 char tmp[4];
2959 if (num & 0xFF000000L)
2960 {
2961 mi_int4store(tmp, num);
2962 str->append(tmp, 4, &my_charset_bin);
2963 }
2964 else if (num & 0xFF0000L)
2965 {
2966 mi_int3store(tmp, num);
2967 str->append(tmp, 3, &my_charset_bin);
2968 }
2969 else if (num & 0xFF00L)
2970 {
2971 mi_int2store(tmp, num);
2972 str->append(tmp, 2, &my_charset_bin);
2973 }
2974 else
2975 {
2976 tmp[0]= (char) num;
2977 str->append(tmp, 1, &my_charset_bin);
2978 }
2979 }
2980
2981
2982 String *Item_func_chr::val_str(String *str)
2983 {
2984 DBUG_ASSERT(fixed == 1);
2985 str->length(0);
2986 str->set_charset(collation.collation);
2987 int32 num=(int32) args[0]->val_int();
2988 if (!args[0]->null_value)
2989 append_char(str, num);
2990 else
2991 {
2992 null_value= 1;
2993 return 0;
2994 }
2995 str->realloc(str->length()); // Add end 0 (for Purify)
2996 return check_well_formed_result(str);
2997 }
2998
2999
3000 inline String* alloc_buffer(String *res,String *str,String *tmp_value,
3001 ulong length)
3002 {
3003 if (res->alloced_length() < length)
3004 {
3005 if (str->alloced_length() >= length)
3006 {
3007 (void) str->copy(*res);
3008 str->length(length);
3009 return str;
3010 }
3011 if (tmp_value->alloc(length))
3012 return 0;
3013 (void) tmp_value->copy(*res);
3014 tmp_value->length(length);
3015 return tmp_value;
3016 }
3017 res->length(length);
3018 return res;
3019 }
3020
3021
3022 bool Item_func_repeat::fix_length_and_dec()
3023 {
3024 if (agg_arg_charsets_for_string_result(collation, args, 1))
3025 return TRUE;
3026 DBUG_ASSERT(collation.collation != NULL);
3027 if (args[1]->const_item() && !args[1]->is_expensive())
3028 {
3029 Repeat_count tmp(args[1]);
3030 ulonglong char_length= (ulonglong) args[0]->max_char_length() * tmp.count();
3031 fix_char_length_ulonglong(char_length);
3032 return false;
3033 }
3034 max_length= MAX_BLOB_WIDTH;
3035 maybe_null= true;
3036 return false;
3037 }
3038
3039 /**
3040 Item_func_repeat::str is carefully written to avoid reallocs
3041 as much as possible at the cost of a local buffer
3042 */
3043
3044 String *Item_func_repeat::val_str(String *str)
3045 {
3046 DBUG_ASSERT(fixed == 1);
3047 uint length,tot_length;
3048 char *to;
3049 /* must be longlong to avoid truncation */
3050 longlong count= args[1]->val_int();
3051 String *res= args[0]->val_str(str);
3052
3053 if (args[0]->null_value || args[1]->null_value)
3054 goto err; // string and/or delim are null
3055 null_value= 0;
3056
3057 if (count <= 0 && (count == 0 || !args[1]->unsigned_flag))
3058 return make_empty_result();
3059
3060 /* Assumes that the maximum length of a String is < INT_MAX32. */
3061 /* Bounds check on count: If this is triggered, we will error. */
3062 if ((ulonglong) count > INT_MAX32)
3063 count= INT_MAX32;
3064 if (count == 1) // To avoid reallocs
3065 return res;
3066 length=res->length();
3067
3068 // Safe length check
3069 {
3070 THD *thd= current_thd;
3071 if (length > thd->variables.max_allowed_packet / (uint) count)
3072 {
3073 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
3074 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
3075 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
3076 func_name(), thd->variables.max_allowed_packet);
3077 goto err;
3078 }
3079 }
3080 tot_length= length*(uint) count;
3081 if (!(res= alloc_buffer(res,str,&tmp_value,tot_length)))
3082 goto err;
3083
3084 to=(char*) res->ptr()+length;
3085 while (--count)
3086 {
3087 memcpy(to,res->ptr(),length);
3088 to+=length;
3089 }
3090 return (res);
3091
3092 err:
3093 null_value=1;
3094 return 0;
3095 }
3096
3097
3098 bool Item_func_space::fix_length_and_dec()
3099 {
3100 collation.set(default_charset(), DERIVATION_COERCIBLE, MY_REPERTOIRE_ASCII);
3101 if (args[0]->const_item() && !args[0]->is_expensive())
3102 {
3103 fix_char_length_ulonglong(Repeat_count(args[0]).count());
3104 return false;
3105 }
3106 max_length= MAX_BLOB_WIDTH;
3107 maybe_null= true;
3108 return false;
3109 }
3110
3111
3112 String *Item_func_space::val_str(String *str)
3113 {
3114 uint tot_length;
3115 longlong count= args[0]->val_int();
3116 CHARSET_INFO *cs= collation.collation;
3117
3118 if (args[0]->null_value)
3119 goto err; // string and/or delim are null
3120 null_value= 0;
3121
3122 if (count <= 0 && (count == 0 || !args[0]->unsigned_flag))
3123 return make_empty_result();
3124 /*
3125 Assumes that the maximum length of a String is < INT_MAX32.
3126 Bounds check on count: If this is triggered, we will error.
3127 */
3128 if ((ulonglong) count > INT_MAX32)
3129 count= INT_MAX32;
3130
3131 // Safe length check
3132 tot_length= (uint) count * cs->mbminlen;
3133 {
3134 THD *thd= current_thd;
3135 if (tot_length > thd->variables.max_allowed_packet)
3136 {
3137 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
3138 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
3139 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
3140 func_name(),
3141 thd->variables.max_allowed_packet);
3142 goto err;
3143 }
3144 }
3145 if (str->alloc(tot_length))
3146 goto err;
3147 str->length(tot_length);
3148 str->set_charset(cs);
3149 cs->cset->fill(cs, (char*) str->ptr(), tot_length, ' ');
3150 return str;
3151
3152 err:
3153 null_value= 1;
3154 return 0;
3155 }
3156
3157
3158 bool Item_func_binlog_gtid_pos::fix_length_and_dec()
3159 {
3160 collation.set(system_charset_info);
3161 max_length= MAX_BLOB_WIDTH;
3162 maybe_null= 1;
3163 return FALSE;
3164 }
3165
3166
3167 String *Item_func_binlog_gtid_pos::val_str(String *str)
3168 {
3169 DBUG_ASSERT(fixed == 1);
3170 #ifndef HAVE_REPLICATION
3171 null_value= 0;
3172 str->copy("", 0, system_charset_info);
3173 return str;
3174 #else
3175 String name_str, *name;
3176 longlong pos;
3177
3178 if (args[0]->null_value || args[1]->null_value)
3179 goto err;
3180
3181 name= args[0]->val_str(&name_str);
3182 pos= args[1]->val_int();
3183
3184 if (pos < 0 || pos > UINT_MAX32)
3185 goto err;
3186
3187 if (gtid_state_from_binlog_pos(name->c_ptr_safe(), (uint32)pos, str))
3188 goto err;
3189 null_value= 0;
3190 return str;
3191
3192 err:
3193 null_value= 1;
3194 return NULL;
3195 #endif /* !HAVE_REPLICATION */
3196 }
3197
3198
3199 static String *default_pad_str(String *pad_str, CHARSET_INFO *collation)
3200 {
3201 pad_str->set_charset(collation);
3202 pad_str->length(0);
3203 pad_str->append(" ", 1);
3204 return pad_str;
3205 }
3206
3207 bool Item_func_pad::fix_length_and_dec()
3208 {
3209 if (arg_count == 3)
3210 {
3211 String *str;
3212 if (!args[2]->basic_const_item() || !(str= args[2]->val_str(&pad_str)) || !str->length())
3213 maybe_null= true;
3214 // Handle character set for args[0] and args[2].
3215 if (agg_arg_charsets_for_string_result(collation, &args[0], 2, 2))
3216 return TRUE;
3217 }
3218 else
3219 {
3220 if (agg_arg_charsets_for_string_result(collation, &args[0], 1, 1))
3221 return TRUE;
3222 default_pad_str(&pad_str, collation.collation);
3223 }
3224
3225 DBUG_ASSERT(collation.collation->mbmaxlen > 0);
3226 if (args[1]->const_item() && !args[1]->is_expensive())
3227 {
3228 fix_char_length_ulonglong(Repeat_count(args[1]).count());
3229 return false;
3230 }
3231 max_length= MAX_BLOB_WIDTH;
3232 maybe_null= true;
3233 return false;
3234 }
3235
3236
3237 /*
3238 PAD(expr,length,' ')
3239 removes argument's soft dependency on PAD_CHAR_TO_FULL_LENGTH if the result
3240 is longer than the argument's maximim possible length.
3241 */
3242 Sql_mode_dependency Item_func_rpad::value_depends_on_sql_mode() const
3243 {
3244 DBUG_ASSERT(fixed);
3245 DBUG_ASSERT(arg_count >= 2);
3246 if (!args[1]->value_depends_on_sql_mode_const_item() ||
3247 (arg_count == 3 && !args[2]->value_depends_on_sql_mode_const_item()))
3248 return Item_func::value_depends_on_sql_mode();
3249 Longlong_hybrid len= args[1]->to_longlong_hybrid();
3250 if (args[1]->null_value || len.neg())
3251 return Sql_mode_dependency(); // will return NULL
3252 if (len.abs() > 0 && len.abs() < args[0]->max_char_length())
3253 return Item_func::value_depends_on_sql_mode();
3254 StringBuffer<64> padstrbuf;
3255 String *padstr= arg_count == 3 ? args[2]->val_str(&padstrbuf) :
3256 default_pad_str(&padstrbuf, collation.collation);
3257 if (!padstr || !padstr->length())
3258 return Sql_mode_dependency(); // will return NULL
3259 if (padstr->lengthsp() != 0)
3260 return Item_func::value_depends_on_sql_mode(); // will pad not only spaces
3261 // RPAD(expr, length, ' ') -- with a long enough length
3262 return ((args[0]->value_depends_on_sql_mode() |
3263 args[1]->value_depends_on_sql_mode()) &
3264 Sql_mode_dependency(~0, ~MODE_PAD_CHAR_TO_FULL_LENGTH)).
3265 soft_to_hard();
3266 }
3267
3268
3269
3270 String *Item_func_rpad::val_str(String *str)
3271 {
3272 DBUG_ASSERT(fixed == 1);
3273 uint32 res_byte_length,res_char_length,pad_char_length,pad_byte_length;
3274 char *to;
3275 const char *ptr_pad;
3276 /* must be longlong to avoid truncation */
3277 longlong count= args[1]->val_int();
3278 longlong byte_count;
3279 String *res= args[0]->val_str(str);
3280 String *rpad= arg_count == 2 ? &pad_str : args[2]->val_str(&pad_str);
3281
3282 if (!res || args[1]->null_value || !rpad ||
3283 ((count < 0) && !args[1]->unsigned_flag))
3284 goto err;
3285
3286 null_value=0;
3287
3288 if (count == 0)
3289 return make_empty_result();
3290
3291 /* Assumes that the maximum length of a String is < INT_MAX32. */
3292 /* Set here so that rest of code sees out-of-bound value as such. */
3293 if ((ulonglong) count > INT_MAX32)
3294 count= INT_MAX32;
3295 /*
3296 There is one exception not handled (intentionally) by the character set
3297 aggregation code. If one string is strong side and is binary, and
3298 another one is weak side and is a multi-byte character string,
3299 then we need to operate on the second string in terms on bytes when
3300 calling ::numchars() and ::charpos(), rather than in terms of characters.
3301 Lets substitute its character set to binary.
3302 */
3303 if (collation.collation == &my_charset_bin)
3304 {
3305 res->set_charset(&my_charset_bin);
3306 rpad->set_charset(&my_charset_bin);
3307 }
3308
3309 if (count <= (res_char_length= res->numchars()))
3310 { // String to pad is big enough
3311 res->length(res->charpos((int) count)); // Shorten result if longer
3312 return (res);
3313 }
3314
3315 byte_count= count * collation.collation->mbmaxlen;
3316 {
3317 THD *thd= current_thd;
3318 if ((ulonglong) byte_count > thd->variables.max_allowed_packet)
3319 {
3320 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
3321 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
3322 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
3323 func_name(), thd->variables.max_allowed_packet);
3324 goto err;
3325 }
3326 }
3327
3328 if (arg_count == 3)
3329 {
3330 if (args[2]->null_value || !(pad_char_length= rpad->numchars()))
3331 goto err;
3332 }
3333 else
3334 pad_char_length= 1; // Implicit space
3335
3336 res_byte_length= res->length(); /* Must be done before alloc_buffer */
3337 if (!(res= alloc_buffer(res,str,&tmp_value, (ulong) byte_count)))
3338 goto err;
3339
3340 to= (char*) res->ptr()+res_byte_length;
3341 ptr_pad=rpad->ptr();
3342 pad_byte_length= rpad->length();
3343 count-= res_char_length;
3344 for ( ; (uint32) count > pad_char_length; count-= pad_char_length)
3345 {
3346 memcpy(to,ptr_pad,pad_byte_length);
3347 to+= pad_byte_length;
3348 }
3349 if (count)
3350 {
3351 pad_byte_length= rpad->charpos((int) count);
3352 memcpy(to,ptr_pad,(size_t) pad_byte_length);
3353 to+= pad_byte_length;
3354 }
3355 res->length((uint) (to- (char*) res->ptr()));
3356 return (res);
3357
3358 err:
3359 null_value=1;
3360 return 0;
3361 }
3362
3363
3364 String *Item_func_lpad::val_str(String *str)
3365 {
3366 DBUG_ASSERT(fixed == 1);
3367 uint32 res_char_length,pad_char_length;
3368 /* must be longlong to avoid truncation */
3369 longlong count= args[1]->val_int();
3370 longlong byte_count;
3371 String *res= args[0]->val_str(&tmp_value);
3372 String *pad= arg_count == 2 ? &pad_str : args[2]->val_str(&pad_str);
3373
3374 if (!res || args[1]->null_value || !pad ||
3375 ((count < 0) && !args[1]->unsigned_flag))
3376 goto err;
3377
3378 null_value=0;
3379
3380 if (count == 0)
3381 return make_empty_result();
3382
3383 /* Assumes that the maximum length of a String is < INT_MAX32. */
3384 /* Set here so that rest of code sees out-of-bound value as such. */
3385 if ((ulonglong) count > INT_MAX32)
3386 count= INT_MAX32;
3387
3388 /*
3389 There is one exception not handled (intentionally) by the character set
3390 aggregation code. If one string is strong side and is binary, and
3391 another one is weak side and is a multi-byte character string,
3392 then we need to operate on the second string in terms on bytes when
3393 calling ::numchars() and ::charpos(), rather than in terms of characters.
3394 Lets substitute its character set to binary.
3395 */
3396 if (collation.collation == &my_charset_bin)
3397 {
3398 res->set_charset(&my_charset_bin);
3399 pad->set_charset(&my_charset_bin);
3400 }
3401
3402 res_char_length= res->numchars();
3403
3404 if (count <= res_char_length)
3405 {
3406 res->length(res->charpos((int) count));
3407 return res;
3408 }
3409
3410 byte_count= count * collation.collation->mbmaxlen;
3411
3412 {
3413 THD *thd= current_thd;
3414 if ((ulonglong) byte_count > thd->variables.max_allowed_packet)
3415 {
3416 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
3417 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
3418 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
3419 func_name(), thd->variables.max_allowed_packet);
3420 goto err;
3421 }
3422 }
3423
3424 if (str->alloc((uint32) byte_count))
3425 goto err;
3426
3427 if (arg_count == 3)
3428 {
3429 if (args[2]->null_value || !(pad_char_length= pad->numchars()))
3430 goto err;
3431 }
3432 else
3433 pad_char_length= 1; // Implicit space
3434
3435 str->length(0);
3436 str->set_charset(collation.collation);
3437 count-= res_char_length;
3438 while (count >= pad_char_length)
3439 {
3440 str->append(*pad);
3441 count-= pad_char_length;
3442 }
3443 if (count > 0)
3444 str->append(pad->ptr(), pad->charpos((int) count), collation.collation);
3445
3446 str->append(*res);
3447 null_value= 0;
3448 return str;
3449
3450 err:
3451 null_value= 1;
3452 return 0;
3453 }
3454
3455
3456 String *Item_func_conv::val_str(String *str)
3457 {
3458 DBUG_ASSERT(fixed == 1);
3459 String *res= args[0]->val_str(str);
3460 char *endptr,ans[65],*ptr;
3461 longlong dec;
3462 int from_base= (int) args[1]->val_int();
3463 int to_base= (int) args[2]->val_int();
3464 int err;
3465
3466 // Note that abs(INT_MIN) is undefined.
3467 if (args[0]->null_value || args[1]->null_value || args[2]->null_value ||
3468 from_base == INT_MIN || to_base == INT_MIN ||
3469 abs(to_base) > 36 || abs(to_base) < 2 ||
3470 abs(from_base) > 36 || abs(from_base) < 2 || !(res->length()))
3471 {
3472 null_value= 1;
3473 return NULL;
3474 }
3475 null_value= 0;
3476 unsigned_flag= !(from_base < 0);
3477
3478 if (args[0]->field_type() == MYSQL_TYPE_BIT)
3479 {
3480 /*
3481 Special case: The string representation of BIT doesn't resemble the
3482 decimal representation, so we shouldn't change it to string and then to
3483 decimal.
3484 */
3485 dec= args[0]->val_int();
3486 }
3487 else
3488 {
3489 if (from_base < 0)
3490 dec= my_strntoll(res->charset(), res->ptr(), res->length(),
3491 -from_base, &endptr, &err);
3492 else
3493 dec= (longlong) my_strntoull(res->charset(), res->ptr(), res->length(),
3494 from_base, &endptr, &err);
3495 }
3496
3497 if (!(ptr= longlong2str(dec, ans, to_base)) ||
3498 str->copy(ans, (uint32) (ptr - ans), default_charset()))
3499 {
3500 null_value= 1;
3501 return NULL;
3502 }
3503 return str;
3504 }
3505
3506
3507 String *Item_func_conv_charset::val_str(String *str)
3508 {
3509 DBUG_ASSERT(fixed == 1);
3510 if (use_cached_value)
3511 return null_value ? 0 : &str_value;
3512 String *arg= args[0]->val_str(&tmp_value);
3513 String_copier_for_item copier(current_thd);
3514 return ((null_value= args[0]->null_value ||
3515 copier.copy_with_warn(collation.collation, str,
3516 arg->charset(), arg->ptr(),
3517 arg->length(), arg->length()))) ?
3518 0 : str;
3519 }
3520
3521 bool Item_func_conv_charset::fix_length_and_dec()
3522 {
3523 DBUG_ASSERT(collation.derivation == DERIVATION_IMPLICIT);
3524 fix_char_length(args[0]->max_char_length());
3525 return FALSE;
3526 }
3527
3528 void Item_func_conv_charset::print(String *str, enum_query_type query_type)
3529 {
3530 str->append(STRING_WITH_LEN("convert("));
3531 args[0]->print(str, query_type);
3532 str->append(STRING_WITH_LEN(" using "));
3533 str->append(collation.collation->csname);
3534 str->append(')');
3535 }
3536
3537 String *Item_func_set_collation::val_str(String *str)
3538 {
3539 DBUG_ASSERT(fixed == 1);
3540 str=args[0]->val_str(str);
3541 if ((null_value=args[0]->null_value))
3542 return 0;
3543 str->set_charset(collation.collation);
3544 return str;
3545 }
3546
3547 bool Item_func_set_collation::fix_length_and_dec()
3548 {
3549 if (!my_charset_same(args[0]->collation.collation, m_set_collation))
3550 {
3551 my_error(ER_COLLATION_CHARSET_MISMATCH, MYF(0),
3552 m_set_collation->name, args[0]->collation.collation->csname);
3553 return TRUE;
3554 }
3555 collation.set(m_set_collation, DERIVATION_EXPLICIT,
3556 args[0]->collation.repertoire);
3557 max_length= args[0]->max_length;
3558 return FALSE;
3559 }
3560
3561
3562 bool Item_func_set_collation::eq(const Item *item, bool binary_cmp) const
3563 {
3564 return Item_func::eq(item, binary_cmp) &&
3565 collation.collation == item->collation.collation;
3566 }
3567
3568
3569 void Item_func_set_collation::print(String *str, enum_query_type query_type)
3570 {
3571 args[0]->print_parenthesised(str, query_type, precedence());
3572 str->append(STRING_WITH_LEN(" collate "));
3573 str->append(m_set_collation->name);
3574 }
3575
3576 String *Item_func_charset::val_str(String *str)
3577 {
3578 DBUG_ASSERT(fixed == 1);
3579 uint dummy_errors;
3580
3581 CHARSET_INFO *cs= args[0]->charset_for_protocol();
3582 null_value= 0;
3583 str->copy(cs->csname, (uint) strlen(cs->csname),
3584 &my_charset_latin1, collation.collation, &dummy_errors);
3585 return str;
3586 }
3587
3588 String *Item_func_collation::val_str(String *str)
3589 {
3590 DBUG_ASSERT(fixed == 1);
3591 uint dummy_errors;
3592 CHARSET_INFO *cs= args[0]->charset_for_protocol();
3593
3594 null_value= 0;
3595 str->copy(cs->name, (uint) strlen(cs->name),
3596 &my_charset_latin1, collation.collation, &dummy_errors);
3597 return str;
3598 }
3599
3600
3601 bool Item_func_weight_string::fix_length_and_dec()
3602 {
3603 CHARSET_INFO *cs= args[0]->collation.collation;
3604 collation.set(&my_charset_bin, args[0]->collation.derivation);
3605 flags= my_strxfrm_flag_normalize(flags, cs->levels_for_order);
3606 /*
3607 Use result_length if it was given explicitly in constructor,
3608 otherwise calculate max_length using argument's max_length
3609 and "nweights".
3610 */
3611 if (!(max_length= result_length))
3612 {
3613 size_t char_length;
3614 char_length= ((cs->state & MY_CS_STRNXFRM_BAD_NWEIGHTS) || !nweights) ?
3615 args[0]->max_char_length() : nweights * cs->levels_for_order;
3616 max_length= (uint32)cs->coll->strnxfrmlen(cs, char_length * cs->mbmaxlen);
3617 }
3618 maybe_null= 1;
3619 return FALSE;
3620 }
3621
3622
3623 /* Return a weight_string according to collation */
3624 String *Item_func_weight_string::val_str(String *str)
3625 {
3626 String *res;
3627 CHARSET_INFO *cs= args[0]->collation.collation;
3628 size_t tmp_length, frm_length;
3629 DBUG_ASSERT(fixed == 1);
3630
3631 if (args[0]->result_type() != STRING_RESULT ||
3632 !(res= args[0]->val_str(&tmp_value)))
3633 goto nl;
3634
3635 /*
3636 Use result_length if it was given in constructor
3637 explicitly, otherwise calculate result length
3638 from argument and "nweights".
3639 */
3640 if (!(tmp_length= result_length))
3641 {
3642 size_t char_length;
3643 if (cs->state & MY_CS_STRNXFRM_BAD_NWEIGHTS)
3644 {
3645 /*
3646 latin2_czech_cs and cp1250_czech_cs do not support
3647 the "nweights" limit in strnxfrm(). Use the full length.
3648 */
3649 char_length= res->length();
3650 }
3651 else
3652 {
3653 /*
3654 If we don't need to pad the result with spaces, then it should be
3655 OK to calculate character length of the argument approximately:
3656 "res->length() / cs->mbminlen" can return a number that is
3657 bigger than the real number of characters in the string, so
3658 we'll allocate a little bit more memory but avoid calling
3659 the slow res->numchars().
3660 In case if we do need to pad with spaces, we call res->numchars()
3661 to know the true number of characters.
3662 */
3663 if (!(char_length= nweights))
3664 char_length= (flags & MY_STRXFRM_PAD_WITH_SPACE) ?
3665 res->numchars() : (res->length() / cs->mbminlen);
3666 }
3667 tmp_length= cs->coll->strnxfrmlen(cs, char_length * cs->mbmaxlen);
3668 }
3669
3670 {
3671 THD *thd= current_thd;
3672 if (tmp_length > current_thd->variables.max_allowed_packet)
3673 {
3674 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
3675 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
3676 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
3677 func_name(),
3678 thd->variables.max_allowed_packet);
3679 goto nl;
3680 }
3681 }
3682
3683 if (str->alloc(tmp_length))
3684 goto nl;
3685
3686 frm_length= cs->coll->strnxfrm(cs,
3687 (uchar *) str->ptr(), tmp_length,
3688 nweights ? nweights : (uint)tmp_length,
3689 (const uchar *) res->ptr(), res->length(),
3690 flags);
3691 DBUG_ASSERT(frm_length <= tmp_length);
3692
3693 str->length(frm_length);
3694 null_value= 0;
3695 return str;
3696
3697 nl:
3698 null_value= 1;
3699 return 0;
3700 }
3701
3702
3703 void Item_func_weight_string::print(String *str, enum_query_type query_type)
3704 {
3705 str->append(func_name());
3706 str->append('(');
3707 args[0]->print(str, query_type);
3708 str->append(',');
3709 str->append_ulonglong(result_length);
3710 str->append(',');
3711 str->append_ulonglong(nweights);
3712 str->append(',');
3713 str->append_ulonglong(flags);
3714 str->append(')');
3715 }
3716
3717
3718 String *Item_func_hex::val_str_ascii_from_val_real(String *str)
3719 {
3720 ulonglong dec;
3721 double val= args[0]->val_real();
3722 if ((null_value= args[0]->null_value))
3723 return 0;
3724 if ((val <= (double) LONGLONG_MIN) ||
3725 (val >= (double) (ulonglong) ULONGLONG_MAX))
3726 dec= ~(longlong) 0;
3727 else
3728 dec= (ulonglong) (val + (val > 0 ? 0.5 : -0.5));
3729 return str->set_hex(dec) ? make_empty_result() : str;
3730 }
3731
3732
3733 String *Item_func_hex::val_str_ascii_from_val_str(String *str)
3734 {
3735 DBUG_ASSERT(&tmp_value != str);
3736 String *res= args[0]->val_str(&tmp_value);
3737 DBUG_ASSERT(res != str);
3738 if ((null_value= (res == NULL)))
3739 return NULL;
3740 return str->set_hex(res->ptr(), res->length()) ? make_empty_result() : str;
3741 }
3742
3743
3744 String *Item_func_hex::val_str_ascii_from_val_int(String *str)
3745 {
3746 ulonglong dec= (ulonglong) args[0]->val_int();
3747 if ((null_value= args[0]->null_value))
3748 return 0;
3749 return str->set_hex(dec) ? make_empty_result() : str;
3750 }
3751
3752
3753 /** Convert given hex string to a binary string. */
3754
3755 String *Item_func_unhex::val_str(String *str)
3756 {
3757 const char *from, *end;
3758 char *to;
3759 String *res;
3760 uint length;
3761 DBUG_ASSERT(fixed == 1);
3762
3763 res= args[0]->val_str(&tmp_value);
3764 if (!res || str->alloc(length= (1+res->length())/2))
3765 {
3766 null_value=1;
3767 return 0;
3768 }
3769
3770 from= res->ptr();
3771 null_value= 0;
3772 str->length(length);
3773 to= (char*) str->ptr();
3774 if (res->length() % 2)
3775 {
3776 int hex_char;
3777 *to++= hex_char= hexchar_to_int(*from++);
3778 if ((null_value= (hex_char == -1)))
3779 return 0;
3780 }
3781 for (end=res->ptr()+res->length(); from < end ; from+=2, to++)
3782 {
3783 int hex_char;
3784 *to= (hex_char= hexchar_to_int(from[0])) << 4;
3785 if ((null_value= (hex_char == -1)))
3786 return 0;
3787 *to|= hex_char= hexchar_to_int(from[1]);
3788 if ((null_value= (hex_char == -1)))
3789 return 0;
3790 }
3791 return str;
3792 }
3793
3794
3795 #ifndef DBUG_OFF
3796 String *Item_func_like_range::val_str(String *str)
3797 {
3798 DBUG_ASSERT(fixed == 1);
3799 longlong nbytes= args[1]->val_int();
3800 String *res= args[0]->val_str(str);
3801 size_t min_len, max_len;
3802 CHARSET_INFO *cs= collation.collation;
3803
3804 if (!res || args[0]->null_value || args[1]->null_value ||
3805 nbytes < 0 || nbytes > MAX_BLOB_WIDTH ||
3806 min_str.alloc((size_t)nbytes) || max_str.alloc((size_t)nbytes))
3807 goto err;
3808 null_value=0;
3809
3810 if (cs->coll->like_range(cs, res->ptr(), res->length(),
3811 '\\', '_', '%', (size_t)nbytes,
3812 (char*) min_str.ptr(), (char*) max_str.ptr(),
3813 &min_len, &max_len))
3814 goto err;
3815
3816 min_str.set_charset(collation.collation);
3817 max_str.set_charset(collation.collation);
3818 min_str.length(min_len);
3819 max_str.length(max_len);
3820
3821 return is_min ? &min_str : &max_str;
3822
3823 err:
3824 null_value= 1;
3825 return 0;
3826 }
3827 #endif
3828
3829
3830 void Item_func_binary::print(String *str, enum_query_type query_type)
3831 {
3832 str->append(STRING_WITH_LEN("cast("));
3833 args[0]->print(str, query_type);
3834 str->append(STRING_WITH_LEN(" as binary)"));
3835 }
3836
3837
3838 #include <my_dir.h> // For my_stat
3839
3840 String *Item_load_file::val_str(String *str)
3841 {
3842 DBUG_ASSERT(fixed == 1);
3843 String *file_name;
3844 File file;
3845 MY_STAT stat_info;
3846 char path[FN_REFLEN];
3847 DBUG_ENTER("load_file");
3848
3849 if (!(file_name= args[0]->val_str(str))
3850 #ifndef NO_EMBEDDED_ACCESS_CHECKS
3851 || !(current_thd->security_ctx->master_access & FILE_ACL)
3852 #endif
3853 )
3854 goto err;
3855
3856 (void) fn_format(path, file_name->c_ptr_safe(), mysql_real_data_home, "",
3857 MY_RELATIVE_PATH | MY_UNPACK_FILENAME);
3858
3859 /* Read only allowed from within dir specified by secure_file_priv */
3860 if (!is_secure_file_path(path))
3861 goto err;
3862
3863 if (!mysql_file_stat(key_file_loadfile, path, &stat_info, MYF(0)))
3864 goto err;
3865
3866 if (!(stat_info.st_mode & S_IROTH))
3867 {
3868 /* my_error(ER_TEXTFILE_NOT_READABLE, MYF(0), file_name->c_ptr()); */
3869 goto err;
3870 }
3871
3872 {
3873 THD *thd= current_thd;
3874 if (stat_info.st_size > (long) thd->variables.max_allowed_packet)
3875 {
3876 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
3877 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
3878 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
3879 func_name(), thd->variables.max_allowed_packet);
3880 goto err;
3881 }
3882 }
3883 if (tmp_value.alloc((size_t)stat_info.st_size))
3884 goto err;
3885 if ((file= mysql_file_open(key_file_loadfile,
3886 file_name->ptr(), O_RDONLY, MYF(0))) < 0)
3887 goto err;
3888 if (mysql_file_read(file, (uchar*) tmp_value.ptr(), (size_t)stat_info.st_size,
3889 MYF(MY_NABP)))
3890 {
3891 mysql_file_close(file, MYF(0));
3892 goto err;
3893 }
3894 tmp_value.length((uint32)stat_info.st_size);
3895 mysql_file_close(file, MYF(0));
3896 null_value = 0;
3897 DBUG_RETURN(&tmp_value);
3898
3899 err:
3900 null_value = 1;
3901 DBUG_RETURN(0);
3902 }
3903
3904
3905 String* Item_func_export_set::val_str(String* str)
3906 {
3907 DBUG_ASSERT(fixed == 1);
3908 String yes_buf, no_buf, sep_buf;
3909 const ulonglong the_set = (ulonglong) args[0]->val_int();
3910 const String *yes= args[1]->val_str(&yes_buf);
3911 const String *no= args[2]->val_str(&no_buf);
3912 const String *sep= NULL;
3913
3914 uint num_set_values = 64;
3915 str->length(0);
3916 str->set_charset(collation.collation);
3917
3918 /* Check if some argument is a NULL value */
3919 if (args[0]->null_value || args[1]->null_value || args[2]->null_value)
3920 {
3921 null_value= true;
3922 return NULL;
3923 }
3924 /*
3925 Arg count can only be 3, 4 or 5 here. This is guaranteed from the
3926 grammar for EXPORT_SET()
3927 */
3928 switch(arg_count) {
3929 case 5:
3930 num_set_values = (uint) args[4]->val_int();
3931 if (num_set_values > 64)
3932 num_set_values=64;
3933 if (args[4]->null_value)
3934 {
3935 null_value= true;
3936 return NULL;
3937 }
3938 /* Fall through */
3939 case 4:
3940 if (!(sep = args[3]->val_str(&sep_buf))) // Only true if NULL
3941 {
3942 null_value= true;
3943 return NULL;
3944 }
3945 break;
3946 case 3:
3947 {
3948 /* errors is not checked - assume "," can always be converted */
3949 uint errors;
3950 sep_buf.copy(STRING_WITH_LEN(","), &my_charset_bin,
3951 collation.collation, &errors);
3952 sep = &sep_buf;
3953 }
3954 break;
3955 default:
3956 DBUG_ASSERT(0); // cannot happen
3957 }
3958 null_value= false;
3959
3960 THD *thd= current_thd;
3961 const ulong max_allowed_packet= thd->variables.max_allowed_packet;
3962 const uint num_separators= num_set_values > 0 ? num_set_values - 1 : 0;
3963 const ulonglong max_total_length=
3964 num_set_values * MY_MAX(yes->length(), no->length()) +
3965 num_separators * sep->length();
3966
3967 if (unlikely(max_total_length > max_allowed_packet))
3968 {
3969 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
3970 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
3971 ER_THD(thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
3972 func_name(), max_allowed_packet);
3973 null_value= true;
3974 return NULL;
3975 }
3976
3977 uint ix;
3978 ulonglong mask;
3979 for (ix= 0, mask=0x1; ix < num_set_values; ++ix, mask = (mask << 1))
3980 {
3981 if (the_set & mask)
3982 str->append(*yes);
3983 else
3984 str->append(*no);
3985 if (ix != num_separators)
3986 str->append(*sep);
3987 }
3988 return str;
3989 }
3990
3991 bool Item_func_export_set::fix_length_and_dec()
3992 {
3993 uint32 length= MY_MAX(args[1]->max_char_length(), args[2]->max_char_length());
3994 uint32 sep_length= (arg_count > 3 ? args[3]->max_char_length() : 1);
3995
3996 if (agg_arg_charsets_for_string_result(collation,
3997 args + 1, MY_MIN(4, arg_count) - 1))
3998 return TRUE;
3999 fix_char_length(length * 64 + sep_length * 63);
4000 return FALSE;
4001 }
4002
4003
4004 #define get_esc_bit(mask, num) (1 & (*((mask) + ((num) >> 3))) >> ((num) & 7))
4005
4006 /**
4007 QUOTE() function returns argument string in single quotes suitable for
4008 using in a SQL statement.
4009
4010 Adds a \\ before all characters that needs to be escaped in a SQL string.
4011 We also escape '^Z' (END-OF-FILE in windows) to avoid problems when
4012 running commands from a file in windows.
4013
4014 This function is very useful when you want to generate SQL statements.
4015
4016 @note
4017 QUOTE(NULL) returns the string 'NULL' (4 letters, without quotes).
4018
4019 @retval
4020 str Quoted string
4021 @retval
4022 NULL Out of memory.
4023 */
4024
4025 String *Item_func_quote::val_str(String *str)
4026 {
4027 DBUG_ASSERT(fixed == 1);
4028 /*
4029 Bit mask that has 1 for set for the position of the following characters:
4030 0, \, ' and ^Z
4031 */
4032
4033 static uchar escmask[32]=
4034 {
4035 0x01, 0x00, 0x00, 0x04, 0x80, 0x00, 0x00, 0x00,
4036 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,
4037 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4038 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
4039 };
4040
4041 ulong max_allowed_packet= current_thd->variables.max_allowed_packet;
4042 char *from, *to, *end, *start;
4043 String *arg= args[0]->val_str(&tmp_value);
4044 uint arg_length, new_length;
4045 if (!arg) // Null argument
4046 {
4047 /* Return the string 'NULL' */
4048 str->copy(STRING_WITH_LEN("NULL"), collation.collation);
4049 null_value= 0;
4050 return str;
4051 }
4052
4053 arg_length= arg->length();
4054
4055 if (collation.collation->mbmaxlen == 1)
4056 {
4057 new_length= arg_length + 2; /* for beginning and ending ' signs */
4058 for (from= (char*) arg->ptr(), end= from + arg_length; from < end; from++)
4059 new_length+= get_esc_bit(escmask, (uchar) *from);
4060 if (new_length > max_allowed_packet)
4061 goto toolong;
4062 }
4063 else
4064 {
4065 new_length= (arg_length * 2) + /* For string characters */
4066 (2 * collation.collation->mbmaxlen); /* For quotes */
4067 set_if_smaller(new_length, max_allowed_packet);
4068 }
4069
4070 if (str->alloc(new_length))
4071 goto null;
4072
4073 if (collation.collation->mbmaxlen > 1)
4074 {
4075 CHARSET_INFO *cs= collation.collation;
4076 int mblen;
4077 uchar *to_end;
4078 to= (char*) str->ptr();
4079 to_end= (uchar*) to + new_length;
4080
4081 /* Put leading quote */
4082 if ((mblen= cs->cset->wc_mb(cs, '\'', (uchar *) to, to_end)) <= 0)
4083 goto toolong;
4084 to+= mblen;
4085
4086 for (start= (char*) arg->ptr(), end= start + arg_length; start < end; )
4087 {
4088 my_wc_t wc;
4089 bool escape;
4090 if ((mblen= cs->cset->mb_wc(cs, &wc, (uchar*) start, (uchar*) end)) <= 0)
4091 goto null;
4092 start+= mblen;
4093 switch (wc) {
4094 case 0: escape= 1; wc= '0'; break;
4095 case '\032': escape= 1; wc= 'Z'; break;
4096 case '\'': escape= 1; break;
4097 case '\\': escape= 1; break;
4098 default: escape= 0; break;
4099 }
4100 if (escape)
4101 {
4102 if ((mblen= cs->cset->wc_mb(cs, '\\', (uchar*) to, to_end)) <= 0)
4103 goto toolong;
4104 to+= mblen;
4105 }
4106 if ((mblen= cs->cset->wc_mb(cs, wc, (uchar*) to, to_end)) <= 0)
4107 goto toolong;
4108 to+= mblen;
4109 }
4110
4111 /* Put trailing quote */
4112 if ((mblen= cs->cset->wc_mb(cs, '\'', (uchar *) to, to_end)) <= 0)
4113 goto toolong;
4114 to+= mblen;
4115 new_length= (uint)(to - str->ptr());
4116 goto ret;
4117 }
4118
4119 /*
4120 We replace characters from the end to the beginning
4121 */
4122 to= (char*) str->ptr() + new_length - 1;
4123 *to--= '\'';
4124 for (start= (char*) arg->ptr(),end= start + arg_length; end-- != start; to--)
4125 {
4126 /*
4127 We can't use the bitmask here as we want to replace \O and ^Z with 0
4128 and Z
4129 */
4130 switch (*end) {
4131 case 0:
4132 *to--= '0';
4133 *to= '\\';
4134 break;
4135 case '\032':
4136 *to--= 'Z';
4137 *to= '\\';
4138 break;
4139 case '\'':
4140 case '\\':
4141 *to--= *end;
4142 *to= '\\';
4143 break;
4144 default:
4145 *to= *end;
4146 break;
4147 }
4148 }
4149 *to= '\'';
4150
4151 ret:
4152 str->length(new_length);
4153 str->set_charset(collation.collation);
4154 null_value= 0;
4155 return str;
4156
4157 toolong:
4158 push_warning_printf(current_thd, Sql_condition::WARN_LEVEL_WARN,
4159 ER_WARN_ALLOWED_PACKET_OVERFLOWED,
4160 ER_THD(current_thd, ER_WARN_ALLOWED_PACKET_OVERFLOWED),
4161 func_name(), max_allowed_packet);
4162 null:
4163 null_value= 1;
4164 return 0;
4165 }
4166
4167 longlong Item_func_uncompressed_length::val_int()
4168 {
4169 DBUG_ASSERT(fixed == 1);
4170 String *res= args[0]->val_str(&value);
4171 if (!res)
4172 {
4173 null_value=1;
4174 return 0; /* purecov: inspected */
4175 }
4176 null_value=0;
4177 if (res->is_empty()) return 0;
4178
4179 /*
4180 If length is <= 4 bytes, data is corrupt. This is the best we can do
4181 to detect garbage input without decompressing it.
4182 */
4183 if (res->length() <= 4)
4184 {
4185 THD *thd= current_thd;
4186 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
4187 ER_ZLIB_Z_DATA_ERROR,
4188 ER_THD(thd, ER_ZLIB_Z_DATA_ERROR));
4189 null_value= 1;
4190 return 0;
4191 }
4192
4193 /*
4194 res->ptr() using is safe because we have tested that string is at least
4195 5 bytes long.
4196 res->c_ptr() is not used because:
4197 - we do not need \0 terminated string to get first 4 bytes
4198 - c_ptr() tests simbol after string end (uninitialized memory) which
4199 confuse valgrind
4200 */
4201 return uint4korr(res->ptr()) & 0x3FFFFFFF;
4202 }
4203
4204 longlong Item_func_crc32::val_int()
4205 {
4206 DBUG_ASSERT(fixed == 1);
4207 String *res=args[0]->val_str(&value);
4208 if (!res)
4209 {
4210 null_value=1;
4211 return 0; /* purecov: inspected */
4212 }
4213 null_value=0;
4214 return (longlong) my_checksum(0L, (uchar*)res->ptr(), res->length());
4215 }
4216
4217 #ifdef HAVE_COMPRESS
4218 #include "zlib.h"
4219
4220 String *Item_func_compress::val_str(String *str)
4221 {
4222 int err= Z_OK, code;
4223 size_t new_size;
4224 String *res;
4225 Byte *body;
4226 char *tmp, *last_char;
4227 DBUG_ASSERT(fixed == 1);
4228
4229 if (!(res= args[0]->val_str(&tmp_value)))
4230 {
4231 null_value= 1;
4232 return 0;
4233 }
4234 null_value= 0;
4235 if (res->is_empty()) return res;
4236
4237 /*
4238 Citation from zlib.h (comment for compress function):
4239
4240 Compresses the source buffer into the destination buffer. sourceLen is
4241 the byte length of the source buffer. Upon entry, destLen is the total
4242 size of the destination buffer, which must be at least 0.1% larger than
4243 sourceLen plus 12 bytes.
4244 We assume here that the buffer can't grow more than .25 %.
4245 */
4246 new_size= res->length() + res->length() / 5 + 12;
4247
4248 // Check new_size overflow: new_size <= res->length()
4249 if (((uint32) (new_size+5) <= res->length()) ||
4250 str->realloc((uint32) new_size + 4 + 1))
4251 {
4252 null_value= 1;
4253 return 0;
4254 }
4255
4256 body= ((Byte*)str->ptr()) + 4;
4257
4258 // As far as we have checked res->is_empty() we can use ptr()
4259 if ((err= my_compress_buffer(body, &new_size, (const uchar *)res->ptr(),
4260 res->length())) != Z_OK)
4261 {
4262 THD *thd= current_thd;
4263 code= err==Z_MEM_ERROR ? ER_ZLIB_Z_MEM_ERROR : ER_ZLIB_Z_BUF_ERROR;
4264 push_warning(thd, Sql_condition::WARN_LEVEL_WARN, code,
4265 ER_THD(thd, code));
4266 null_value= 1;
4267 return 0;
4268 }
4269
4270 tmp= (char*) str->ptr(); // int4store is a macro; avoid side effects
4271 int4store(tmp, res->length() & 0x3FFFFFFF);
4272
4273 /* This is to ensure that things works for CHAR fields, which trim ' ': */
4274 last_char= ((char*)body)+new_size-1;
4275 if (*last_char == ' ')
4276 {
4277 *++last_char= '.';
4278 new_size++;
4279 }
4280
4281 str->length((uint32)new_size + 4);
4282 return str;
4283 }
4284
4285
4286 String *Item_func_uncompress::val_str(String *str)
4287 {
4288 DBUG_ASSERT(fixed == 1);
4289 String *res= args[0]->val_str(&tmp_value);
4290 ulong new_size;
4291 int err;
4292 uint code;
4293
4294 if (!res)
4295 goto err;
4296 null_value= 0;
4297 if (res->is_empty())
4298 return res;
4299
4300 /* If length is less than 4 bytes, data is corrupt */
4301 if (res->length() <= 4)
4302 {
4303 THD *thd= current_thd;
4304 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
4305 ER_ZLIB_Z_DATA_ERROR,
4306 ER_THD(thd, ER_ZLIB_Z_DATA_ERROR));
4307 goto err;
4308 }
4309
4310 /* Size of uncompressed data is stored as first 4 bytes of field */
4311 new_size= uint4korr(res->ptr()) & 0x3FFFFFFF;
4312 if (new_size > current_thd->variables.max_allowed_packet)
4313 {
4314 THD *thd= current_thd;
4315 push_warning_printf(thd,Sql_condition::WARN_LEVEL_WARN,
4316 ER_TOO_BIG_FOR_UNCOMPRESS,
4317 ER_THD(thd, ER_TOO_BIG_FOR_UNCOMPRESS),
4318 static_cast<int>(thd->variables.
4319 max_allowed_packet));
4320 goto err;
4321 }
4322 if (str->realloc((uint32)new_size))
4323 goto err;
4324
4325 if ((err= uncompress((Byte*)str->ptr(), &new_size,
4326 ((const Bytef*)res->ptr())+4,res->length()-4)) == Z_OK)
4327 {
4328 str->length((uint32) new_size);
4329 return str;
4330 }
4331
4332 code= ((err == Z_BUF_ERROR) ? ER_ZLIB_Z_BUF_ERROR :
4333 ((err == Z_MEM_ERROR) ? ER_ZLIB_Z_MEM_ERROR : ER_ZLIB_Z_DATA_ERROR));
4334 {
4335 THD *thd= current_thd;
4336 push_warning(thd, Sql_condition::WARN_LEVEL_WARN, code, ER_THD(thd, code));
4337 }
4338
4339 err:
4340 null_value= 1;
4341 return 0;
4342 }
4343 #endif
4344
4345
4346 String *Item_func_uuid::val_str(String *str)
4347 {
4348 DBUG_ASSERT(fixed == 1);
4349 uchar guid[MY_UUID_SIZE];
4350
4351 str->realloc(MY_UUID_STRING_LENGTH+1);
4352 str->length(MY_UUID_STRING_LENGTH);
4353 str->set_charset(system_charset_info);
4354 my_uuid(guid);
4355 my_uuid2str(guid, (char *)str->ptr());
4356
4357 return str;
4358 }
4359
4360
4361 Item_func_dyncol_create::Item_func_dyncol_create(THD *thd, List<Item> &args,
4362 DYNCALL_CREATE_DEF *dfs):
4363 Item_str_func(thd, args), defs(dfs), vals(0), keys_num(NULL), keys_str(NULL),
4364 names(FALSE), force_names(FALSE)
4365 {
4366 DBUG_ASSERT((args.elements & 0x1) == 0); // even number of arguments
4367 }
4368
4369
4370 bool Item_func_dyncol_create::fix_fields(THD *thd, Item **ref)
4371 {
4372 uint i;
4373 bool res= Item_func::fix_fields(thd, ref); // no need Item_str_func here
4374 if (!res)
4375 {
4376 vals= (DYNAMIC_COLUMN_VALUE *) alloc_root(thd->mem_root,
4377 sizeof(DYNAMIC_COLUMN_VALUE) *
4378 (arg_count / 2));
4379 for (i= 0;
4380 i + 1 < arg_count && args[i]->result_type() == INT_RESULT;
4381 i+= 2)
4382 ;
4383 if (i + 1 < arg_count)
4384 {
4385 names= TRUE;
4386 }
4387
4388 keys_num= (uint *) alloc_root(thd->mem_root,
4389 (sizeof(LEX_STRING) > sizeof(uint) ?
4390 sizeof(LEX_STRING) :
4391 sizeof(uint)) *
4392 (arg_count / 2));
4393 keys_str= (LEX_STRING *) keys_num;
4394 status_var_increment(thd->status_var.feature_dynamic_columns);
4395 }
4396 return res || vals == 0 || keys_num == 0;
4397 }
4398
4399
4400 bool Item_func_dyncol_create::fix_length_and_dec()
4401 {
4402 max_length= MAX_BLOB_WIDTH;
4403 maybe_null= TRUE;
4404 collation.set(&my_charset_bin);
4405 decimals= 0;
4406 return FALSE;
4407 }
4408
4409 bool Item_func_dyncol_create::prepare_arguments(THD *thd, bool force_names_arg)
4410 {
4411 char buff[STRING_BUFFER_USUAL_SIZE];
4412 String *res, tmp(buff, sizeof(buff), &my_charset_bin);
4413 uint column_count= (arg_count / 2);
4414 uint i;
4415 my_decimal dtmp, *dres;
4416 force_names= force_names_arg;
4417
4418 if (!(names || force_names))
4419 {
4420 for (i= 0; i < column_count; i++)
4421 {
4422 uint valpos= i * 2 + 1;
4423 DYNAMIC_COLUMN_TYPE type= defs[i].type;
4424 if (type == DYN_COL_NULL)
4425 switch (args[valpos]->field_type())
4426 {
4427 case MYSQL_TYPE_VARCHAR:
4428 case MYSQL_TYPE_ENUM:
4429 case MYSQL_TYPE_SET:
4430 case MYSQL_TYPE_TINY_BLOB:
4431 case MYSQL_TYPE_MEDIUM_BLOB:
4432 case MYSQL_TYPE_LONG_BLOB:
4433 case MYSQL_TYPE_BLOB:
4434 case MYSQL_TYPE_VAR_STRING:
4435 case MYSQL_TYPE_STRING:
4436 case MYSQL_TYPE_GEOMETRY:
4437 type= DYN_COL_STRING;
4438 break;
4439 default:
4440 break;
4441 }
4442
4443 if (type == DYN_COL_STRING &&
4444 args[valpos]->type() == Item::FUNC_ITEM &&
4445 ((Item_func *)args[valpos])->functype() == DYNCOL_FUNC)
4446 {
4447 force_names= 1;
4448 break;
4449 }
4450 }
4451 }
4452
4453 /* get values */
4454 for (i= 0; i < column_count; i++)
4455 {
4456 uint valpos= i * 2 + 1;
4457 DYNAMIC_COLUMN_TYPE type= defs[i].type;
4458 if (type == DYN_COL_NULL) // auto detect
4459 {
4460 /*
4461 We don't have a default here to ensure we get a warning if
4462 one adds a new not handled MYSQL_TYPE_...
4463 */
4464 switch (args[valpos]->field_type()) {
4465 case MYSQL_TYPE_DECIMAL:
4466 case MYSQL_TYPE_NEWDECIMAL:
4467 type= DYN_COL_DECIMAL;
4468 break;
4469 case MYSQL_TYPE_TINY:
4470 case MYSQL_TYPE_SHORT:
4471 case MYSQL_TYPE_LONG:
4472 case MYSQL_TYPE_LONGLONG:
4473 case MYSQL_TYPE_INT24:
4474 case MYSQL_TYPE_YEAR:
4475 case MYSQL_TYPE_BIT:
4476 type= args[valpos]->unsigned_flag ? DYN_COL_UINT : DYN_COL_INT;
4477 break;
4478 case MYSQL_TYPE_FLOAT:
4479 case MYSQL_TYPE_DOUBLE:
4480 type= DYN_COL_DOUBLE;
4481 break;
4482 case MYSQL_TYPE_NULL:
4483 type= DYN_COL_NULL;
4484 break;
4485 case MYSQL_TYPE_TIMESTAMP:
4486 case MYSQL_TYPE_TIMESTAMP2:
4487 case MYSQL_TYPE_DATETIME:
4488 case MYSQL_TYPE_DATETIME2:
4489 type= DYN_COL_DATETIME;
4490 break;
4491 case MYSQL_TYPE_DATE:
4492 case MYSQL_TYPE_NEWDATE:
4493 type= DYN_COL_DATE;
4494 break;
4495 case MYSQL_TYPE_TIME:
4496 case MYSQL_TYPE_TIME2:
4497 type= DYN_COL_TIME;
4498 break;
4499 case MYSQL_TYPE_VARCHAR:
4500 case MYSQL_TYPE_ENUM:
4501 case MYSQL_TYPE_SET:
4502 case MYSQL_TYPE_TINY_BLOB:
4503 case MYSQL_TYPE_MEDIUM_BLOB:
4504 case MYSQL_TYPE_LONG_BLOB:
4505 case MYSQL_TYPE_BLOB:
4506 case MYSQL_TYPE_VAR_STRING:
4507 case MYSQL_TYPE_STRING:
4508 case MYSQL_TYPE_GEOMETRY:
4509 type= DYN_COL_STRING;
4510 break;
4511 case MYSQL_TYPE_VARCHAR_COMPRESSED:
4512 case MYSQL_TYPE_BLOB_COMPRESSED:
4513 DBUG_ASSERT(0);
4514 }
4515 }
4516 if (type == DYN_COL_STRING &&
4517 args[valpos]->type() == Item::FUNC_ITEM &&
4518 ((Item_func *)args[valpos])->functype() == DYNCOL_FUNC)
4519 {
4520 DBUG_ASSERT(names || force_names);
4521 type= DYN_COL_DYNCOL;
4522 }
4523 if (names || force_names)
4524 {
4525 res= args[i * 2]->val_str(&tmp);
4526 if (res)
4527 {
4528 // guaranty UTF-8 string for names
4529 if (my_charset_same(res->charset(), DYNCOL_UTF))
4530 {
4531 keys_str[i].length= res->length();
4532 keys_str[i].str= thd->strmake(res->ptr(), res->length());
4533 }
4534 else
4535 {
4536 uint strlen= res->length() * DYNCOL_UTF->mbmaxlen + 1;
4537 uint dummy_errors;
4538 if (char *str= (char *) thd->alloc(strlen))
4539 {
4540 keys_str[i].length=
4541 copy_and_convert(str, strlen, DYNCOL_UTF,
4542 res->ptr(), res->length(), res->charset(),
4543 &dummy_errors);
4544 keys_str[i].str= str;
4545 }
4546 else
4547 keys_str[i].length= 0;
4548
4549 }
4550 }
4551 else
4552 {
4553 keys_str[i].length= 0;
4554 keys_str[i].str= NULL;
4555 }
4556 }
4557 else
4558 keys_num[i]= (uint) args[i * 2]->val_int();
4559 if (args[i * 2]->null_value)
4560 {
4561 /* to make cleanup possible */
4562 for (; i < column_count; i++)
4563 vals[i].type= DYN_COL_NULL;
4564 return 1;
4565 }
4566 vals[i].type= type;
4567 switch (type) {
4568 case DYN_COL_NULL:
4569 DBUG_ASSERT(args[valpos]->field_type() == MYSQL_TYPE_NULL);
4570 break;
4571 case DYN_COL_INT:
4572 vals[i].x.long_value= args[valpos]->val_int();
4573 break;
4574 case DYN_COL_UINT:
4575 vals[i].x.ulong_value= args[valpos]->val_int();
4576 break;
4577 case DYN_COL_DOUBLE:
4578 vals[i].x.double_value= args[valpos]->val_real();
4579 break;
4580 case DYN_COL_DYNCOL:
4581 case DYN_COL_STRING:
4582 res= args[valpos]->val_str(&tmp);
4583 if (res && defs[i].cs)
4584 res->set_charset(defs[i].cs);
4585 if (res &&
4586 (vals[i].x.string.value.str= thd->strmake(res->ptr(), res->length())))
4587 {
4588 vals[i].x.string.value.length= res->length();
4589 vals[i].x.string.charset= res->charset();
4590 }
4591 else
4592 {
4593 args[valpos]->null_value= 1; // In case of out of memory
4594 vals[i].x.string.value.str= NULL;
4595 vals[i].x.string.value.length= 0; // just to be safe
4596 }
4597 break;
4598 case DYN_COL_DECIMAL:
4599 if ((dres= args[valpos]->val_decimal(&dtmp)))
4600 {
4601 mariadb_dyncol_prepare_decimal(&vals[i]);
4602 DBUG_ASSERT(vals[i].x.decimal.value.len == dres->len);
4603 vals[i].x.decimal.value.intg= dres->intg;
4604 vals[i].x.decimal.value.frac= dres->frac;
4605 vals[i].x.decimal.value.sign= dres->sign();
4606 memcpy(vals[i].x.decimal.buffer, dres->buf,
4607 sizeof(vals[i].x.decimal.buffer));
4608 }
4609 else
4610 {
4611 mariadb_dyncol_prepare_decimal(&vals[i]); // just to be safe
4612 DBUG_ASSERT(args[valpos]->null_value);
4613 }
4614 break;
4615 case DYN_COL_DATETIME:
4616 case DYN_COL_DATE:
4617 args[valpos]->get_date(&vals[i].x.time_value,
4618 sql_mode_for_dates(thd));
4619 break;
4620 case DYN_COL_TIME:
4621 args[valpos]->get_time(&vals[i].x.time_value);
4622 break;
4623 default:
4624 DBUG_ASSERT(0);
4625 vals[i].type= DYN_COL_NULL;
4626 }
4627 if (vals[i].type != DYN_COL_NULL && args[valpos]->null_value)
4628 {
4629 vals[i].type= DYN_COL_NULL;
4630 }
4631 }
4632 return FALSE;
4633 }
4634
4635
4636 String *Item_func_dyncol_create::val_str(String *str)
4637 {
4638 DYNAMIC_COLUMN col;
4639 String *res;
4640 uint column_count= (arg_count / 2);
4641 enum enum_dyncol_func_result rc;
4642 DBUG_ASSERT((arg_count & 0x1) == 0); // even number of arguments
4643
4644 /* FIXME: add thd argument to Item::val_str() */
4645 if (prepare_arguments(current_thd, FALSE))
4646 {
4647 res= NULL;
4648 null_value= 1;
4649 }
4650 else
4651 {
4652 if ((rc= ((names || force_names) ?
4653 mariadb_dyncol_create_many_named(&col, column_count, keys_str,
4654 vals, TRUE) :
4655 mariadb_dyncol_create_many_num(&col, column_count, keys_num,
4656 vals, TRUE))))
4657 {
4658 dynamic_column_error_message(rc);
4659 mariadb_dyncol_free(&col);
4660 res= NULL;
4661 null_value= TRUE;
4662 }
4663 else
4664 {
4665 /* Move result from DYNAMIC_COLUMN to str_value */
4666 char *ptr;
4667 size_t length, alloc_length;
4668 dynstr_reassociate(&col, &ptr, &length, &alloc_length);
4669 str_value.reset(ptr, length, alloc_length, &my_charset_bin);
4670 res= &str_value;
4671 null_value= FALSE;
4672 }
4673 }
4674
4675 return res;
4676 }
4677
4678 void Item_func_dyncol_create::print_arguments(String *str,
4679 enum_query_type query_type)
4680 {
4681 uint i;
4682 uint column_count= (arg_count / 2);
4683 for (i= 0; i < column_count; i++)
4684 {
4685 args[i*2]->print(str, query_type);
4686 str->append(',');
4687 args[i*2 + 1]->print(str, query_type);
4688 switch (defs[i].type) {
4689 case DYN_COL_NULL: // automatic type => write nothing
4690 break;
4691 case DYN_COL_INT:
4692 str->append(STRING_WITH_LEN(" AS int"));
4693 break;
4694 case DYN_COL_UINT:
4695 str->append(STRING_WITH_LEN(" AS unsigned int"));
4696 break;
4697 case DYN_COL_DOUBLE:
4698 str->append(STRING_WITH_LEN(" AS double"));
4699 break;
4700 case DYN_COL_DYNCOL:
4701 case DYN_COL_STRING:
4702 str->append(STRING_WITH_LEN(" AS char"));
4703 if (defs[i].cs)
4704 {
4705 str->append(STRING_WITH_LEN(" charset "));
4706 str->append(defs[i].cs->csname);
4707 str->append(' ');
4708 }
4709 break;
4710 case DYN_COL_DECIMAL:
4711 str->append(STRING_WITH_LEN(" AS decimal"));
4712 break;
4713 case DYN_COL_DATETIME:
4714 str->append(STRING_WITH_LEN(" AS datetime"));
4715 break;
4716 case DYN_COL_DATE:
4717 str->append(STRING_WITH_LEN(" AS date"));
4718 break;
4719 case DYN_COL_TIME:
4720 str->append(STRING_WITH_LEN(" AS time"));
4721 break;
4722 }
4723 if (i < column_count - 1)
4724 str->append(',');
4725 }
4726 }
4727
4728
4729 void Item_func_dyncol_create::print(String *str,
4730 enum_query_type query_type)
4731 {
4732 DBUG_ASSERT((arg_count & 0x1) == 0); // even number of arguments
4733 str->append(STRING_WITH_LEN("column_create("));
4734 print_arguments(str, query_type);
4735 str->append(')');
4736 }
4737
4738 String *Item_func_dyncol_json::val_str(String *str)
4739 {
4740 DYNAMIC_STRING json, col;
4741 String *res;
4742 enum enum_dyncol_func_result rc;
4743
4744 res= args[0]->val_str(str);
4745 if (args[0]->null_value)
4746 goto null;
4747
4748 col.str= (char *)res->ptr();
4749 col.length= res->length();
4750 if ((rc= mariadb_dyncol_json(&col, &json)))
4751 {
4752 dynamic_column_error_message(rc);
4753 goto null;
4754 }
4755 bzero(&col, sizeof(col));
4756 {
4757 /* Move result from DYNAMIC_COLUMN to str */
4758 char *ptr;
4759 size_t length, alloc_length;
4760 dynstr_reassociate(&json, &ptr, &length, &alloc_length);
4761 str->reset(ptr, length, alloc_length, DYNCOL_UTF);
4762 null_value= FALSE;
4763 }
4764 str->set_charset(DYNCOL_UTF);
4765 return str;
4766
4767 null:
4768 bzero(&col, sizeof(col));
4769 null_value= TRUE;
4770 return NULL;
4771 }
4772
4773 String *Item_func_dyncol_add::val_str(String *str)
4774 {
4775 DYNAMIC_COLUMN col;
4776 String *res;
4777 uint column_count= (arg_count / 2);
4778 enum enum_dyncol_func_result rc;
4779 DBUG_ASSERT((arg_count & 0x1) == 1); // odd number of arguments
4780
4781 /* We store the packed data last */
4782 res= args[arg_count - 1]->val_str(str);
4783 if (args[arg_count - 1]->null_value ||
4784 init_dynamic_string(&col, NULL, res->length() + STRING_BUFFER_USUAL_SIZE,
4785 STRING_BUFFER_USUAL_SIZE))
4786 goto null;
4787
4788 col.length= res->length();
4789 memcpy(col.str, res->ptr(), col.length);
4790
4791 /* FIXME: add thd argument to Item::val_str() */
4792 if (prepare_arguments(current_thd, mariadb_dyncol_has_names(&col)))
4793 goto null;
4794
4795 if ((rc= ((names || force_names) ?
4796 mariadb_dyncol_update_many_named(&col, column_count,
4797 keys_str, vals) :
4798 mariadb_dyncol_update_many_num(&col, column_count,
4799 keys_num, vals))))
4800 {
4801 dynamic_column_error_message(rc);
4802 mariadb_dyncol_free(&col);
4803 goto null;
4804 }
4805
4806 {
4807 /* Move result from DYNAMIC_COLUMN to str */
4808 char *ptr;
4809 size_t length, alloc_length;
4810 dynstr_reassociate(&col, &ptr, &length, &alloc_length);
4811 str->reset(ptr, length, alloc_length, &my_charset_bin);
4812 null_value= FALSE;
4813 }
4814
4815 return str;
4816
4817 null:
4818 null_value= TRUE;
4819 return NULL;
4820 }
4821
4822
4823 void Item_func_dyncol_add::print(String *str,
4824 enum_query_type query_type)
4825 {
4826 DBUG_ASSERT((arg_count & 0x1) == 1); // odd number of arguments
4827 str->append(STRING_WITH_LEN("column_add("));
4828 args[arg_count - 1]->print(str, query_type);
4829 str->append(',');
4830 print_arguments(str, query_type);
4831 str->append(')');
4832 }
4833
4834
4835 /**
4836 Get value for a column stored in a dynamic column
4837
4838 @notes
4839 This function ensures that null_value is set correctly
4840 */
4841
4842 bool Item_dyncol_get::get_dyn_value(THD *thd, DYNAMIC_COLUMN_VALUE *val,
4843 String *tmp)
4844 {
4845 DYNAMIC_COLUMN dyn_str;
4846 String *res;
4847 longlong num= 0;
4848 LEX_STRING buf, *name= NULL;
4849 char nmstrbuf[11];
4850 String nmbuf(nmstrbuf, sizeof(nmstrbuf), system_charset_info);
4851 enum enum_dyncol_func_result rc;
4852
4853 if (args[1]->result_type() == INT_RESULT)
4854 num= args[1]->val_int();
4855 else
4856 {
4857 String *nm= args[1]->val_str(&nmbuf);
4858 if (!nm || args[1]->null_value)
4859 {
4860 null_value= 1;
4861 return 1;
4862 }
4863
4864 if (my_charset_same(nm->charset(), DYNCOL_UTF))
4865 {
4866 buf.str= (char *) nm->ptr();
4867 buf.length= nm->length();
4868 }
4869 else
4870 {
4871 uint strlen= nm->length() * DYNCOL_UTF->mbmaxlen + 1;
4872 uint dummy_errors;
4873 buf.str= (char *) thd->alloc(strlen);
4874 if (buf.str)
4875 {
4876 buf.length=
4877 copy_and_convert(buf.str, strlen, DYNCOL_UTF,
4878 nm->ptr(), nm->length(), nm->charset(),
4879 &dummy_errors);
4880 }
4881 else
4882 buf.length= 0;
4883 }
4884 name= &buf;
4885 }
4886
4887
4888 if (args[1]->null_value || num < 0 || num > INT_MAX)
4889 {
4890 null_value= 1;
4891 return 1;
4892 }
4893
4894 res= args[0]->val_str(tmp);
4895 if (args[0]->null_value)
4896 {
4897 null_value= 1;
4898 return 1;
4899 }
4900
4901 dyn_str.str= (char*) res->ptr();
4902 dyn_str.length= res->length();
4903 if ((rc= ((name == NULL) ?
4904 mariadb_dyncol_get_num(&dyn_str, (uint) num, val) :
4905 mariadb_dyncol_get_named(&dyn_str, name, val))))
4906 {
4907 dynamic_column_error_message(rc);
4908 null_value= 1;
4909 return 1;
4910 }
4911
4912 null_value= 0;
4913 return 0; // ok
4914 }
4915
4916
4917 String *Item_dyncol_get::val_str(String *str_result)
4918 {
4919 DYNAMIC_COLUMN_VALUE val;
4920 char buff[STRING_BUFFER_USUAL_SIZE];
4921 String tmp(buff, sizeof(buff), &my_charset_bin);
4922
4923 if (get_dyn_value(current_thd, &val, &tmp))
4924 return NULL;
4925
4926 switch (val.type) {
4927 case DYN_COL_NULL:
4928 goto null;
4929 case DYN_COL_INT:
4930 case DYN_COL_UINT:
4931 str_result->set_int(val.x.long_value, MY_TEST(val.type == DYN_COL_UINT),
4932 &my_charset_latin1);
4933 break;
4934 case DYN_COL_DOUBLE:
4935 str_result->set_real(val.x.double_value, NOT_FIXED_DEC, &my_charset_latin1);
4936 break;
4937 case DYN_COL_DYNCOL:
4938 case DYN_COL_STRING:
4939 if ((char*) tmp.ptr() <= val.x.string.value.str &&
4940 (char*) tmp.ptr() + tmp.length() >= val.x.string.value.str)
4941 {
4942 /* value is allocated in tmp buffer; We have to make a copy */
4943 str_result->copy(val.x.string.value.str, val.x.string.value.length,
4944 val.x.string.charset);
4945 }
4946 else
4947 {
4948 /*
4949 It's safe to use the current value because it's either pointing
4950 into a field or in a buffer for another item and this buffer
4951 is not going to be deleted during expression evaluation
4952 */
4953 str_result->set(val.x.string.value.str, val.x.string.value.length,
4954 val.x.string.charset);
4955 }
4956 break;
4957 case DYN_COL_DECIMAL:
4958 {
4959 int res;
4960 int length= decimal_string_size(&val.x.decimal.value);
4961 if (str_result->alloc(length))
4962 goto null;
4963 if ((res= decimal2string(&val.x.decimal.value, (char*) str_result->ptr(),
4964 &length, 0, 0, ' ')) != E_DEC_OK)
4965 {
4966 char buff[40];
4967 int len= sizeof(buff);
4968 DBUG_ASSERT(length < (int)sizeof(buff));
4969 decimal2string(&val.x.decimal.value, buff, &len, 0, 0, ' ');
4970 decimal_operation_results(res, buff, "CHAR");
4971 }
4972 str_result->set_charset(&my_charset_latin1);
4973 str_result->length(length);
4974 break;
4975 }
4976 case DYN_COL_DATETIME:
4977 case DYN_COL_DATE:
4978 case DYN_COL_TIME:
4979 {
4980 int length;
4981 /*
4982 We use AUTO_SEC_PART_DIGITS here to ensure that we do not loose
4983 any microseconds from the data. This is safe to do as we are
4984 asked to return the time argument as a string.
4985 */
4986 if (str_result->alloc(MAX_DATE_STRING_REP_LENGTH) ||
4987 !(length= my_TIME_to_str(&val.x.time_value, (char*) str_result->ptr(),
4988 AUTO_SEC_PART_DIGITS)))
4989 goto null;
4990 str_result->set_charset(&my_charset_latin1);
4991 str_result->length(length);
4992 break;
4993 }
4994 }
4995 return str_result;
4996
4997 null:
4998 null_value= TRUE;
4999 return 0;
5000 }
5001
5002
5003 longlong Item_dyncol_get::val_int()
5004 {
5005 THD *thd= current_thd;
5006 DYNAMIC_COLUMN_VALUE val;
5007 char buff[STRING_BUFFER_USUAL_SIZE];
5008 String tmp(buff, sizeof(buff), &my_charset_bin);
5009
5010 if (get_dyn_value(thd, &val, &tmp))
5011 return 0;
5012
5013 switch (val.type) {
5014 case DYN_COL_DYNCOL:
5015 case DYN_COL_NULL:
5016 goto null;
5017 case DYN_COL_UINT:
5018 unsigned_flag= 1; // Make it possible for caller to detect sign
5019 return val.x.long_value;
5020 case DYN_COL_INT:
5021 unsigned_flag= 0; // Make it possible for caller to detect sign
5022 return val.x.long_value;
5023 case DYN_COL_DOUBLE:
5024 return Converter_double_to_longlong_with_warn(thd, val.x.double_value,
5025 unsigned_flag).result();
5026 case DYN_COL_STRING:
5027 {
5028 int error;
5029 longlong num;
5030 char *end= val.x.string.value.str + val.x.string.value.length, *org_end= end;
5031
5032 num= my_strtoll10(val.x.string.value.str, &end, &error);
5033 if (unlikely(end != org_end || error > 0))
5034 {
5035 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
5036 ER_BAD_DATA,
5037 ER_THD(thd, ER_BAD_DATA),
5038 ErrConvString(val.x.string.value.str,
5039 val.x.string.value.length,
5040 val.x.string.charset).ptr(),
5041 unsigned_flag ? "UNSIGNED INT" : "INT");
5042 }
5043 unsigned_flag= error >= 0;
5044 return num;
5045 }
5046 case DYN_COL_DECIMAL:
5047 {
5048 longlong num;
5049 my_decimal2int(E_DEC_FATAL_ERROR, &val.x.decimal.value, unsigned_flag,
5050 &num);
5051 return num;
5052 }
5053 case DYN_COL_DATETIME:
5054 case DYN_COL_DATE:
5055 case DYN_COL_TIME:
5056 unsigned_flag= !val.x.time_value.neg;
5057 if (unsigned_flag)
5058 return TIME_to_ulonglong(&val.x.time_value);
5059 else
5060 return -(longlong)TIME_to_ulonglong(&val.x.time_value);
5061 }
5062
5063 null:
5064 null_value= TRUE;
5065 return 0;
5066 }
5067
5068
5069 double Item_dyncol_get::val_real()
5070 {
5071 THD *thd= current_thd;
5072 DYNAMIC_COLUMN_VALUE val;
5073 char buff[STRING_BUFFER_USUAL_SIZE];
5074 String tmp(buff, sizeof(buff), &my_charset_bin);
5075
5076 if (get_dyn_value(thd, &val, &tmp))
5077 return 0.0;
5078
5079 switch (val.type) {
5080 case DYN_COL_DYNCOL:
5081 case DYN_COL_NULL:
5082 goto null;
5083 case DYN_COL_UINT:
5084 return ulonglong2double(val.x.ulong_value);
5085 case DYN_COL_INT:
5086 return (double) val.x.long_value;
5087 case DYN_COL_DOUBLE:
5088 return (double) val.x.double_value;
5089 case DYN_COL_STRING:
5090 {
5091 int error;
5092 char *end;
5093 double res= my_strntod(val.x.string.charset, (char*) val.x.string.value.str,
5094 val.x.string.value.length, &end, &error);
5095
5096 if (end != (char*) val.x.string.value.str + val.x.string.value.length ||
5097 error)
5098 {
5099 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
5100 ER_BAD_DATA,
5101 ER_THD(thd, ER_BAD_DATA),
5102 ErrConvString(val.x.string.value.str,
5103 val.x.string.value.length,
5104 val.x.string.charset).ptr(),
5105 "DOUBLE");
5106 }
5107 return res;
5108 }
5109 case DYN_COL_DECIMAL:
5110 {
5111 double res;
5112 /* This will always succeed */
5113 decimal2double(&val.x.decimal.value, &res);
5114 return res;
5115 }
5116 case DYN_COL_DATETIME:
5117 case DYN_COL_DATE:
5118 case DYN_COL_TIME:
5119 return TIME_to_double(&val.x.time_value);
5120 }
5121
5122 null:
5123 null_value= TRUE;
5124 return 0.0;
5125 }
5126
5127
5128 my_decimal *Item_dyncol_get::val_decimal(my_decimal *decimal_value)
5129 {
5130 THD *thd= current_thd;
5131 DYNAMIC_COLUMN_VALUE val;
5132 char buff[STRING_BUFFER_USUAL_SIZE];
5133 String tmp(buff, sizeof(buff), &my_charset_bin);
5134
5135 if (get_dyn_value(thd, &val, &tmp))
5136 return NULL;
5137
5138 switch (val.type) {
5139 case DYN_COL_DYNCOL:
5140 case DYN_COL_NULL:
5141 goto null;
5142 case DYN_COL_UINT:
5143 int2my_decimal(E_DEC_FATAL_ERROR, val.x.long_value, TRUE, decimal_value);
5144 break;
5145 case DYN_COL_INT:
5146 int2my_decimal(E_DEC_FATAL_ERROR, val.x.long_value, FALSE, decimal_value);
5147 break;
5148 case DYN_COL_DOUBLE:
5149 double2my_decimal(E_DEC_FATAL_ERROR, val.x.double_value, decimal_value);
5150 break;
5151 case DYN_COL_STRING:
5152 {
5153 const char *end;
5154 int rc;
5155 rc= str2my_decimal(0, val.x.string.value.str, val.x.string.value.length,
5156 val.x.string.charset, decimal_value, &end);
5157 if (rc != E_DEC_OK ||
5158 end != val.x.string.value.str + val.x.string.value.length)
5159 {
5160 push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
5161 ER_BAD_DATA,
5162 ER_THD(thd, ER_BAD_DATA),
5163 ErrConvString(val.x.string.value.str,
5164 val.x.string.value.length,
5165 val.x.string.charset).ptr(),
5166 "DECIMAL");
5167 }
5168 break;
5169 }
5170 case DYN_COL_DECIMAL:
5171 decimal2my_decimal(&val.x.decimal.value, decimal_value);
5172 break;
5173 case DYN_COL_DATETIME:
5174 case DYN_COL_DATE:
5175 case DYN_COL_TIME:
5176 decimal_value= TIME_to_my_decimal(&val.x.time_value, decimal_value);
5177 break;
5178 }
5179 return decimal_value;
5180
5181 null:
5182 null_value= TRUE;
5183 return 0;
5184 }
5185
5186
5187 bool Item_dyncol_get::get_date(MYSQL_TIME *ltime, ulonglong fuzzy_date)
5188 {
5189 DYNAMIC_COLUMN_VALUE val;
5190 char buff[STRING_BUFFER_USUAL_SIZE];
5191 String tmp(buff, sizeof(buff), &my_charset_bin);
5192 bool signed_value= 0;
5193
5194 if (get_dyn_value(current_thd, &val, &tmp))
5195 return 1; // Error
5196
5197 switch (val.type) {
5198 case DYN_COL_DYNCOL:
5199 case DYN_COL_NULL:
5200 goto null;
5201 case DYN_COL_INT:
5202 signed_value= 1; // For error message
5203 /* fall through */
5204 case DYN_COL_UINT:
5205 if (signed_value || val.x.ulong_value <= LONGLONG_MAX)
5206 {
5207 longlong llval = (longlong)val.x.ulong_value;
5208 bool neg = llval < 0;
5209 if (int_to_datetime_with_warn(neg, (ulonglong)(neg ? -llval :
5210 llval),
5211 ltime, fuzzy_date, 0, 0 /* TODO */))
5212 goto null;
5213 return 0;
5214 }
5215 /* let double_to_datetime_with_warn() issue the warning message */
5216 val.x.double_value= static_cast<double>(ULONGLONG_MAX);
5217 /* fall through */
5218 case DYN_COL_DOUBLE:
5219 if (double_to_datetime_with_warn(val.x.double_value, ltime, fuzzy_date,
5220 0, 0 /* TODO */))
5221 goto null;
5222 return 0;
5223 case DYN_COL_DECIMAL:
5224 if (decimal_to_datetime_with_warn((my_decimal*)&val.x.decimal.value, ltime,
5225 fuzzy_date, 0, 0 /* TODO */))
5226 goto null;
5227 return 0;
5228 case DYN_COL_STRING:
5229 if (str_to_datetime_with_warn(&my_charset_numeric,
5230 val.x.string.value.str,
5231 val.x.string.value.length,
5232 ltime, fuzzy_date))
5233 goto null;
5234 return 0;
5235 case DYN_COL_DATETIME:
5236 case DYN_COL_DATE:
5237 case DYN_COL_TIME:
5238 *ltime= val.x.time_value;
5239 return 0;
5240 }
5241
5242 null:
5243 null_value= TRUE;
5244 return 1;
5245 }
5246
5247 void Item_dyncol_get::print(String *str, enum_query_type query_type)
5248 {
5249 /*
5250 Parent cast doesn't exist yet, only print dynamic column name. This happens
5251 when called from create_func_cast() / wrong_precision_error().
5252 */
5253 if (!str->length())
5254 {
5255 args[1]->print(str, query_type);
5256 return;
5257 }
5258
5259 /* see create_func_dyncol_get */
5260 DBUG_ASSERT(str->length() >= 5);
5261 DBUG_ASSERT(strncmp(str->ptr() + str->length() - 5, "cast(", 5) == 0);
5262
5263 str->length(str->length() - 5); // removing "cast("
5264 str->append(STRING_WITH_LEN("column_get("));
5265 args[0]->print(str, query_type);
5266 str->append(',');
5267 args[1]->print(str, query_type);
5268 /* let the parent cast item add " as <type>)" */
5269 }
5270
5271
5272 String *Item_func_dyncol_list::val_str(String *str)
5273 {
5274 uint i;
5275 enum enum_dyncol_func_result rc;
5276 LEX_STRING *names= 0;
5277 uint count;
5278 DYNAMIC_COLUMN col;
5279 String *res= args[0]->val_str(str);
5280
5281 if (args[0]->null_value)
5282 goto null;
5283 col.length= res->length();
5284 /* We do not change the string, so could do this trick */
5285 col.str= (char *)res->ptr();
5286 if ((rc= mariadb_dyncol_list_named(&col, &count, &names)))
5287 {
5288 bzero(&col, sizeof(col));
5289 dynamic_column_error_message(rc);
5290 goto null;
5291 }
5292 bzero(&col, sizeof(col));
5293
5294 /*
5295 We estimate average name length as 10
5296 */
5297 if (str->alloc(count * 13))
5298 goto null;
5299
5300 str->length(0);
5301 for (i= 0; i < count; i++)
5302 {
5303 append_identifier(current_thd, str, names[i].str, names[i].length);
5304 if (i < count - 1)
5305 str->qs_append(',');
5306 }
5307 null_value= FALSE;
5308 if (names)
5309 my_free(names);
5310 str->set_charset(DYNCOL_UTF);
5311 return str;
5312
5313 null:
5314 null_value= TRUE;
5315 if (names)
5316 my_free(names);
5317 return NULL;
5318 }
5319
5320 Item_temptable_rowid::Item_temptable_rowid(TABLE *table_arg)
5321 : Item_str_func(table_arg->in_use), table(table_arg)
5322 {
5323 max_length= table->file->ref_length;
5324 }
5325
5326 bool Item_temptable_rowid::fix_length_and_dec()
5327 {
5328 used_tables_cache= table->map;
5329 const_item_cache= false;
5330 return FALSE;
5331 }
5332
5333 String *Item_temptable_rowid::val_str(String *str)
5334 {
5335 if (!((null_value= table->null_row)))
5336 table->file->position(table->record[0]);
5337 str_value.set((char*)(table->file->ref), max_length, &my_charset_bin);
5338 return &str_value;
5339 }
5340